Textfeld-Inhaltsberechnung (C-Text aus Feld plus Rechnen)

Berechnen Sie komplexe Textoperationen mit numerischen Werten aus Formularfeldern. Ideal für Datenverarbeitung, Finanzanalysen und wissenschaftliche Berechnungen.

Textinput (enthält Zahlenwerte):

Extraktionsmuster:

Benutzerdefinierter Regex: Verwenden Sie JavaScript-Regex-Syntax. Beispiel: \d+ für ganze Zahlen

Mathematische Operation:

Benutzerdefinierte Formel (JavaScript):

<label for="wpc-decimal-places" class="wpc-form-label">Dezimalstellen:</label>
            <input type="number" id="wpc-decimal-places" class="wpc-form-input" min="0" max="10" value="2">
        </div>

<button id="wpc-calculate-btn" class="wpc-btn">Berechnen & Visualisieren</button>

<div id="wpc-results" class="wpc-results" style="display: none;">
            <h3 class="wpc-results-title">Ergebnisse:</h3>
            <div id="wpc-result-values" class="wpc-result-item"></div>
            <div id="wpc-result-operation" class="wpc-result-item"></div>
            <div id="wpc-result-final" class="wpc-result-item" style="font-weight: 700; color: #2563eb;"></div>
            <div id="wpc-result-stats" class="wpc-result-item"></div>
        </div>

<article class="wpc-content">
        <h2>Umfassender Leitfaden: Textfeld-Inhaltsberechnung (C-Text aus Feld plus Rechnen)</h2>

<p>Die Extraktion und Verarbeitung numerischer Daten aus Textfeldern ist eine grundlegende Fähigkeit in der Datenanalyse, Programmierung und automatisierten Dokumentenverarbeitung. Dieser Leitfaden erklärt die technischen Grundlagen, praktischen Anwendungen und fortgeschrittenen Techniken für die Verarbeitung von “C-Text aus Feld plus Rechnen”-Operationen.</p>

<h3>1. Grundlagen der Textextraktion</h3>
        <p>Die Extraktion numerischer Werte aus Text basiert auf zwei Hauptmethoden:</p>
        <ol>
            <li><strong>Musterbasierte Extraktion:</strong> Verwendung regulärer Ausdrücke (Regex) zur Identifizierung numerischer Muster in Textstrings</li>
            <li><strong>Positionsbasierte Extraktion:</strong> Zahlen werden basierend auf ihrer Position im Text oder relativ zu anderen Zeichen extrahiert</li>
        </ol>

<div class="wpc-table-container">
            <table class="wpc-table">
                <caption>Vergleich von Extraktionstechniken</caption>
                <thead>
                    <tr>
                        <th>Technik</th>
                        <th>Genauigkeit</th>
                        <th>Flexibilität</th>
                        <th>Verarbeitungsgeschwindigkeit</th>
                        <th>Typische Anwendungen</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Einfache Regex (z.B. \d+)</td>
                        <td>Mittel</td>
                        <td>Niedrig</td>
                        <td>Sehr hoch</td>
                        <td>Logdatei-Analyse, einfache Formulare</td>
                    </tr>
                    <tr>
                        <td>Komplexe Regex (z.B. mit Lookaheads)</td>
                        <td>Hoch</td>
                        <td>Hoch</td>
                        <td>Mittel</td>
                        <td>Finanzdokumente, wissenschaftliche Daten</td>
                    </tr>
                    <tr>
                        <td>NLP-basiert (Natural Language Processing)</td>
                        <td>Sehr hoch</td>
                        <td>Sehr hoch</td>
                        <td>Niedrig</td>
                        <td>Vertragsanalyse, medizinische Texte</td>
                    </tr>
                    <tr>
                        <td>Positionsbasiert</td>
                        <td>Mittel</td>
                        <td>Niedrig</td>
                        <td>Hoch</td>
                        <td>Strukturierte Formulare, Tabellendaten</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>2. Mathematische Operationen auf extrahierten Werten</h3>
        <p>Nach der Extraktion können verschiedene mathematische Operationen durchgeführt werden:</p>
        <ul>
            <li><strong>Aggregationsfunktionen:</strong> Summe, Durchschnitt, Median, Modus</li>
            <li><strong>Statistische Analysen:</strong> Standardabweichung, Varianz, Percentile</li>
            <li><strong>Finanzmathematik:</strong> Zinsberechnungen, Amortisation, Net Present Value</li>
            <li><strong>Wissenschaftliche Berechnungen:</strong> Logarithmen, Exponentialfunktionen, trigonometrische Operationen</li>
        </ul>

<p>Die Wahl der Operation hängt vom Anwendungskontext ab. In Finanzanwendungen sind beispielsweise gewichtete Durchschnitte und Zinseszinsberechnungen besonders relevant, während in wissenschaftlichen Anwendungen oft komplexe statistische Analysen erforderlich sind.</p>

<h3>3. Praktische Implementierung in JavaScript</h3>
        <p>Die folgende Code-Struktur zeigt die grundlegende Implementierung in JavaScript:</p>
        <pre style="background: #f8fafc; padding: 1rem; border-radius: 0.375rem; overflow-x: auto;">
// 1. Textextraktion mit Regex
const text = "Die Werte sind 25, 42 und 18";
const numbers = text.match(/\d+/g).map(Number); // [25, 42, 18]

// 2. Mathematische Operationen
const sum = numbers.reduce((a, b) => a + b, 0);
const average = sum / numbers.length;
const max = Math.max(...numbers);

// 3. Ergebnisformatierung
console.log(`Summe: ${sum.toFixed(2)}`);
console.log(`Durchschnitt: ${average.toFixed(2)}`);
console.log(`Maximalwert: ${max}`);
        </pre>

<h3>4. Fortgeschrittene Techniken</h3>
        <p>Für komplexe Anwendungsfälle können folgende erweiterte Techniken eingesetzt werden:</p>
        <ol>
            <li><strong>Kontextsensitive Extraktion:</strong> Berücksichtigung des umgebenden Textes zur genaueren Identifizierung von Zahlen (z.B. “Temperatur: 23°C” vs. “Alter: 23”)</li>
            <li><strong>Einheitenumrechnung:</strong> Automatische Umrechnung von Werten mit Einheiten (z.B. “5 kg” in Gramm umrechnen)</li>
            <li><strong>Fehlerbehandlung:</strong> Robuste Mechanismen für ungültige Eingaben oder fehlende Werte</li>
            <li><strong>Batch-Verarbeitung:</strong> Verarbeitung großer Textmengen mit Web Workers für bessere Performance</li>
        </ol>

<div class="wpc-table-container">
            <table class="wpc-table">
                <caption>Performance-Vergleich von JavaScript-Extraktionsmethoden (10.000 Iterationen)</caption>
                <thead>
                    <tr>
                        <th>Methode</th>
                        <th>Durchschnittliche Dauer (ms)</th>
                        <th>Speicherverbrauch (MB)</th>
                        <th>Genauigkeit (%)</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td>Einfacher Regex (\d+)</td>
                        <td>12.4</td>
                        <td>0.8</td>
                        <td>92</td>
                    </tr>
                    <tr>
                        <td>Komplexer Regex mit Gruppen</td>
                        <td>45.7</td>
                        <td>1.2</td>
                        <td>98</td>
                    </tr>
                    <tr>
                        <td>String.split() + Filter</td>
                        <td>28.3</td>
                        <td>1.0</td>
                        <td>85</td>
                    </tr>
                    <tr>
                        <td>NLP-Bibliothek (compromise.js)</td>
                        <td>124.5</td>
                        <td>3.7</td>
                        <td>99</td>
                    </tr>
                </tbody>
            </table>
        </div>

<h3>5. Anwendungsbeispiele aus der Praxis</h3>
        <p>Die Textfeld-Inhaltsberechnung findet in zahlreichen Branchen Anwendung:</p>
        <ul>
            <li><strong>Finanzwesen:</strong> Automatische Extraktion von Beträgen aus Rechnungen oder Bankauszügen für die Buchhaltung</li>
            <li><strong>E-Commerce:</strong> Analyse von Kundenbewertungen mit numerischen Ratings und Textkommentaren</li>
            <li><strong>Gesundheitswesen:</strong> Verarbeitung von Patientendaten aus medizinischen Berichten</li>
            <li><strong>Logistik:</strong> Extraktion von Sendungsnummern und Gewichtsangaben aus Versanddokumenten</li>
            <li><strong>Wissenschaft:</strong> Analyse von Messdaten aus Forschungsprotokollen</li>
        </ul>

<p>Ein besonders interessantes Anwendungsbeispiel ist die <strong>automatische Rechnungsverarbeitung</strong>. Moderne Systeme können:</p>
        <ol>
            <li>Rechnungen als PDF oder Bild einlesen</li>
            <li>Mit OCR (Optical Character Recognition) Text extrahieren</li>
            <li>Reguläre Ausdrücke anwenden, um Beträge, Steuern und Rechnungsnummern zu identifizieren</li>
            <li>Die extrahierten Daten mit Buchhaltungssystemen abgleichen</li>
            <li>Abweichungen oder potenzielle Fehler markieren</li>
        </ol>

<h3>6. Best Practices für robuste Implementierungen</h3>
        <p>Für produktive Anwendungen sollten folgende Prinzipien beachtet werden:</p>
        <ul>
            <li><strong>Validierung:</strong> Immer extrahierte Werte auf Plausibilität prüfen (z.B. negative Beträge in Bestellmengen)</li>
            <li><strong>Internationalisierung:</strong> Unterschiedliche Zahlenformate berücksichtigen (z.B. 1.000,50 vs. 1,000.50)</li>
            <li><strong>Performance:</strong> Bei großen Textmengen asynchrone Verarbeitung oder Web Worker einsetzen</li>
            <li><strong>Sicherheit:</strong> Bei Benutzereingaben immer Sanitization durchführen, um Regex-Injection zu verhindern</li>
            <li><strong>Dokumentation:</strong> Klare Spezifikation der unterstützten Textformate und Extraktionregeln</li>
            <li><strong>Testing:</strong> Umfassende Testfälle mit Edge Cases (leere Felder, ungültige Formate, sehr große Zahlen)</li>
        </ul>

<h3>7. Zukunftstrends und KI-Integration</h3>
        <p>Die Entwicklung auf dem Gebiet der Textextraktion schreitet schnell voran:</p>
        <ul>
            <li><strong>KI-gestützte Extraktion:</strong> Moderne NLP-Modelle wie BERT können Zahlen in ihrem Kontext verstehen und extrahieren</li>
            <li><strong>Echtzeit-Verarbeitung:</strong> Stream-basierte Analyse von Textdaten mit sofortiger Rückmeldung</li>
            <li><strong>Multimodale Systeme:</strong> Kombination von Textextraktion mit Bild- und Sprachanalyse</li>
            <li><strong>Low-Code-Plattformen:</strong> Visuelle Tools für Fachanwender ohne Programmierkenntnisse</li>
            <li><strong>Blockchain-Integration:</strong> Nachverfolgbare Extraktion und Verarbeitung sensibler Daten</li>
        </ul>

<p>Besonders vielversprechend ist der Einsatz von <strong>Transformers-Modellen</strong> für die Textextraktion. Diese können:</p>
        <ul>
            <li>Zahlen in ihrem semantischen Kontext verstehen (z.B. “5 kg Äpfel” vs. “5 Äpfel à 1 kg”)</li>
            <li>Mit unstrukturierten Texten umgehen, die für klassische Regex zu komplex sind</li>
            <li>Lernen, welche Zahlen in einem bestimmten Dokumententyp relevant sind</li>
            <li>Mehrsprachige Dokumente verarbeiten</li>
        </ul>

<h2>Wissenschaftliche Grundlagen und weiterführende Ressourcen</h2>
        <p>Die theoretischen Grundlagen für Textextraktion und -verarbeitung finden sich in mehreren wissenschaftlichen Disziplinen:</p>
        <ul>
            <li><strong>Formale Sprachen:</strong> Theorie der regulären Ausdrücke und automatischen Spracherkennung</li>
            <li><strong>Informatik:</strong> Algorithmen für String-Matching und Parsing</li>
            <li><strong>Linguistik:</strong> Analyse von Zahlwörtern und numerischen Ausdrücken in natürlicher Sprache</li>
            <li><strong>Statistik:</strong> Methoden der Datenaggregation und -analyse</li>
        </ul>

<p>Für vertiefende Informationen empfehlen wir folgende autoritative Quellen:</p>
        <ul>
            <li><a href="https://nlp.stanford.edu/IR-book/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">Stanford University: Introduction to Information Retrieval</a> – Umfassende Behandlung von Textextraktionsmethoden</li>
            <li><a href="https://www.nist.gov/topics/data-science" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">NIST: Data Science Ressources</a> – Offizielle Standards und Best Practices für Datenverarbeitung</li>
            <li><a href="https://www.w3.org/TR/xpath-functions/" class="wpc-authority-link" target="_blank" rel="noopener noreferrer">W3C: XPath and XQuery Functions</a> – Standardisierte Funktionen für Textverarbeitung in XML/HTML</li>
        </ul>

<h2>Häufige Fehler und ihre Lösungen</h2>
        <p>Bei der Implementierung von Textfeld-Berechnungen treten häufig folgende Probleme auf:</p>

<h3>Problem 1: Falsche Zahlenformate</h3>
        <p><strong>Symptom:</strong> Zahlen mit Dezimaltrennzeichen werden nicht korrekt erkannt (z.B. “3,14” vs. “3.14”)</p>
        <p><strong>Lösung:</strong> Lokale Einstellungen berücksichtigen und flexible Regex-Muster verwenden:</p>
        <pre style="background: #f8fafc; padding: 1rem; border-radius: 0.375rem; overflow-x: auto;">
// Flexibles Muster für internationale Zahlenformate
const numberRegex = /[+-]?\d{1,3}(?:[\d,.]*\d)?(?:[eE][+-]?\d+)?/g;
        </pre>

<h3>Problem 2: Performance-Probleme bei großen Texten</h3>
        <p><strong>Symptom:</strong> Die Verarbeitung großer Dokumente blockiert den Hauptthread</p>
        <p><strong>Lösung:</strong> Web Worker für die Extraktion verwenden:</p>
        <pre style="background: #f8fafc; padding: 1rem; border-radius: 0.375rem; overflow-x: auto;">
// worker.js
self.onmessage = function(e) {
    const numbers = e.data.text.match(/\d+/g).map(Number);
    const sum = numbers.reduce((a, b) => a + b, 0);
    postMessage({ sum, count: numbers.length });
};

// Hauptthread
const worker = new Worker('worker.js');
worker.postMessage({ text: largeText });
worker.onmessage = function(e) {
    console.log('Summe:', e.data.sum);
};
        </pre>

<h3>Problem 3: Ungenauigkeiten bei Gleitkommazahlen</h3>
        <p><strong>Symptom:</strong> Rundungsfehler bei finanziellen Berechnungen (z.B. 0.1 + 0.2 ≠ 0.3)</p>
        <p><strong>Lösung:</strong> Spezialisierte Bibliotheken für präzise Arithmetik verwenden:</p>
        <pre style="background: #f8fafc; padding: 1rem; border-radius: 0.375rem; overflow-x: auto;">
// Verwendung von decimal.js für präzise Berechnungen
import Decimal from 'decimal.js';
const result = new Decimal(0.1).plus(0.2).toNumber(); // 0.3
        </pre>

<h2>Zusammenfassung und Ausblick</h2>
        <p>Die Extraktion und Verarbeitung numerischer Daten aus Textfeldern ist eine Schlüsseltechnologie für die digitale Transformation in nahezu allen Branchen. Von einfachen Formularberechnungen bis hin zu komplexen KI-gestützten Analysen bietet dieses Feld enorme Möglichkeiten für Automatisierung und Effizienzsteigerung.</p>

<p>Die Zukunft wird durch folgende Entwicklungen geprägt sein:</p>
        <ul>
            <li>Noch intelligentere Extraktion durch KI-Modelle, die den Kontext von Zahlen verstehen</li>
            <li>Echtzeit-Verarbeitung von Datenströmen für IoT-Anwendungen</li>
            <li>Verbesserte Integration mit anderen Datenquellen (Bilder, Sprache, Sensoren)</li>
            <li>Demokratisierung durch Low-Code-Tools, die Fachanwendern ohne Programmierkenntnisse mächtige Analysen ermöglichen</li>
        </ul>

<p>Für Entwickler und Datenanalysten lohnt es sich, die Grundlagen der Textextraktion zu beherrschen und gleichzeitig die neuen KI-gestützten Ansätze zu erkunden. Die Kombination aus klassischen Methoden und modernen KI-Techniken wird in den kommenden Jahren besonders leistungsfähige Lösungen ermöglichen.</p>
    </article>
</section>

// Chart.js instance
    let calculationChart = null;

// Toggle custom regex input visibility
    extractPattern.addEventListener('change', function() {
        customRegexGroup.style.display = this.value === 'custom-regex' ? 'block' : 'none';
    });

// Toggle custom formula input visibility
    operationSelect.addEventListener('change', function() {
        customFormulaGroup.style.display = this.value === 'custom' ? 'block' : 'none';
    });

// Calculate button click handler
    calculateBtn.addEventListener('click', function() {
        try {
            // Extract numbers from text
            const text = textInput.value.trim();
            let numbers = [];

if (text) {
                switch (extractPattern.value) {
                    case 'numbers':
                        // Extract all numbers (integers and decimals)
                        numbers = text.match(/[+-]?\d+(\.\d+)?/g)?.map(Number) || [];
                        break;
                    case 'comma-separated':
                        // Extract comma-separated values
                        numbers = text.split(',')
                            .map(item => item.trim().match(/[+-]?\d+(\.\d+)?/)?.[0])
                            .filter(Boolean)
                            .map(Number);
                        break;
                    case 'colon-separated':
                        // Extract values after colons
                        numbers = text.match(/:[\s]*([+-]?\d+(\.\d+)?)/g)?
                            .map(match => match.match(/[+-]?\d+(\.\d+)?/)?.[0])
                            .filter(Boolean)
                            .map(Number) || [];
                        break;
                    case 'custom-regex':
                        // Use custom regex pattern
                        if (customRegexInput.value.trim()) {
                            const regex = new RegExp(customRegexInput.value.trim(), 'g');
                            const matches = text.match(regex) || [];
                            numbers = matches.map(match => {
                                // Try to convert to number, keep as string if failed
                                const num = Number(match);
                                return isNaN(num) ? match : num;
                            }).filter(item => typeof item === 'number');
                        }
                        break;
                }
            }

if (numbers.length === 0) {
                throw new Error('Keine gültigen Zahlen im Text gefunden. Bitte überprüfen Sie Ihre Eingabe und das Extraktionsmuster.');
            }

// Clean numbers array (filter out NaN values)
            numbers = numbers.filter(n => !isNaN(n));

if (numbers.length === 0) {
                throw new Error('Nach der Bereinigung wurden keine gültigen Zahlen gefunden.');
            }

// Perform calculation
            let result, operationName;
            const decimalPlaces = parseInt(decimalPlacesInput.value) || 2;

switch (operationSelect.value) {
                case 'sum':
                    result = numbers.reduce((a, b) => a + b, 0);
                    operationName = 'Summe';
                    break;
                case 'average':
                    result = numbers.reduce((a, b) => a + b, 0) / numbers.length;
                    operationName = 'Durchschnitt';
                    break;
                case 'max':
                    result = Math.max(...numbers);
                    operationName = 'Maximalwert';
                    break;
                case 'min':
                    result = Math.min(...numbers);
                    operationName = 'Minimalwert';
                    break;
                case 'product':
                    result = numbers.reduce((a, b) => a * b, 1);
                    operationName = 'Produkt';
                    break;
                case 'custom':
                    if (!customFormulaInput.value.trim()) {
                        throw new Error('Bitte geben Sie eine benutzerdefinierte Formel ein.');
                    }
                    try {
                        // Create a safe evaluation context
                        const values = numbers;
                        const safeEval = (expr) => {
                            const allowedGlobals = {
                                values,
                                Math,
                                parseInt,
                                parseFloat,
                                isNaN,
                                isFinite
                            };
                            const keys = ['values', 'Math', 'parseInt', 'parseFloat', 'isNaN', 'isFinite'];
                            const values = keys.map(key => allowedGlobals[key]);

return Function(...keys, `return (${expr})`)(...values);
                        };

result = safeEval(customFormulaInput.value.trim());
                        operationName = 'Benutzerdefinierte Berechnung';
                    } catch (e) {
                        throw new Error(`Fehler in der benutzerdefinierten Formel: ${e.message}`);
                    }
                    break;
            }

if (typeof result !== 'number' || !isFinite(result)) {
                throw new Error('Das Berechnungsergebnis ist keine gültige Zahl.');
            }

// Format results
            const formattedResult = result.toFixed(decimalPlaces);
            const sum = numbers.reduce((a, b) => a + b, 0).toFixed(2);
            const avg = (numbers.reduce((a, b) => a + b, 0) / numbers.length).toFixed(2);
            const max = Math.max(...numbers).toFixed(2);
            const min = Math.min(...numbers).toFixed(2);

// Display results
            resultValues.innerHTML = `<strong>Extrahierte Werte:</strong> ${numbers.join(', ')} (${numbers.length} Zahlen)`;
            resultOperation.innerHTML = `<strong>Operation:</strong> ${operationName}`;
            resultFinal.innerHTML = `<strong>Ergebnis:</strong> ${formattedResult}`;
            resultStats.innerHTML = `
                <strong>Statistiken:</strong><br>
                Summe: ${sum}, Durchschnitt: ${avg}, Max: ${max}, Min: ${min}
            `;

resultsDiv.style.display = 'block';

// Create/update chart
            createChart(numbers, operationName, result);

} catch (error) {
            alert(`Fehler: ${error.message}`);
            resultsDiv.style.display = 'none';
            if (calculationChart) {
                calculationChart.destroy();
                calculationChart = null;
            }
        }
    });

// Function to create/update chart
    function createChart(numbers, operationName, result) {
        const ctx = chartCanvas.getContext('2d');

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

// Prepare chart data
        const labels = numbers.map((_, i) => `Wert ${i+1}`);
        const backgroundColors = numbers.map((_, i) => {
            const hue = (i * 30) % 360;
            return `hsl(${hue}, 70%, 60%)`;
        });

const datasets = [
            {
                label: 'Extrahierte Werte',
                data: numbers,
                backgroundColor: backgroundColors,
                borderColor: backgroundColors.map(c => c.replace('70%', '80%').replace('60%', '40%')),
                borderWidth: 1
            }
        ];

// Add result line if applicable
        if (['sum', 'average', 'product'].includes(operationSelect.value)) {
            datasets.push({
                label: `Ergebnis (${operationName})`,
                data: numbers.map(() => result),
                type: 'line',
                borderColor: '#2563eb',
                borderWidth: 2,
                borderDash: [5, 5],
                fill: false
            });
        }

// Create chart
        calculationChart = new Chart(ctx, {
            type: 'bar',
            data: {
                labels: labels,
                datasets: datasets
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    y: {
                        beginAtZero: true,
                        title: {
                            display: true,
                            text: 'Werte'
                        }
                    },
                    x: {
                        title: {
                            display: true,
                            text: 'Extrahierte Zahlen'
                        }
                    }
                },
                plugins: {
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                return `${context.dataset.label}: ${context.raw.toFixed(2)}`;
                            }
                        }
                    },
                    legend: {
                        position: 'top',
                    },
                    title: {
                        display: true,
                        text: `Berechnung: ${operationName}`,
                        font: {
                            size: 16
                        }
                    }
                }
            }
        });
    }
});
</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="/c-text-aus-feld-plus-rechnen/#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">