Rendern Sie LaTeX-Gleichungen und mathematische Formeln mit C#

LaTeX ist eine leistungsstarke Software zum Setzen von Mathematik. Es ermöglicht das Einbetten von Formeln und mathematischen Gleichungen in die Datei TEX, die ein von LaTeX erstelltes Quelldokument ist. Es bietet viele Befehle zum Festlegen des Formats des Dokuments, darunter Text, Symbole, mathematische Ausdrücke und Grafiken. Wir können grundlegende Gleichungen und mathematische Formeln programmgesteuert schreiben, ohne LaTeX zu verwenden. In diesem Artikel lernen wir, wie man LaTeX-Gleichungen und mathematische Formeln mit C# rendert.

Folgende Themen sollen in diesem Artikel behandelt werden:

• C#-API zum Rendern von LaTeX-Gleichungen und mathematischen Formeln
• LaTeX-Inline-Mathematikformeln rendern
• Rendern Sie komplexe Gleichungen
• Lange Gleichungen anzeigen
• Mehrere Gleichungen ausrichten
• Gruppen- und Zentrumsgleichungen
• Rendern von Matrizen, Klammern und Klammern
• Rendern Sie Brüche und Binome

C#-API zum Rendern von LaTeX-Gleichungen und mathematischen Formeln

Zum Rendern von mathematischen LaTeX-Formeln verwenden wir die API Aspose.TeX for .NET. Es ermöglicht das Setzen von TeX-Dateien in verschiedene Dateiformate wie PDF, XPS oder Bilder. Bitte downloaden Sie die DLL der API oder installieren Sie sie mit NuGet.

PM> Install-Package Aspose.TeX

LaTeX-Inline-Mathematikformeln mit C# rendern

Wir können einfache mathematische Formeln oder Gleichungen rendern, indem wir die folgenden Schritte ausführen:

1. Erstellen Sie zunächst eine Instanz der Klasse MathRendererOptions.
2. Geben Sie als Nächstes die Präambel des LaTeX-Dokuments an.
3. Legen Sie optional verschiedene Eigenschaften wie Scale, TextColor, BackgroundColor usw. fest.
4. Erstellen Sie danach den Ausgabestream für das Formelbild.
5. Rufen Sie schließlich die Methode Render() auf, um die Formel zu rendern. Als Argument werden Formelstring, Stream, MathRendererOptions und die Ausgabebildgröße verwendet.

Das folgende Codebeispiel zeigt, wie eine mathematische Formel programmgesteuert mit C# gerendert wird.

// Dieses Codebeispiel zeigt, wie mathematische Formeln und Gleichungen gerendert werden
// Erstellen Sie Rendering-Optionen, indem Sie die Bildauflösung auf 150 dpi festlegen
MathRendererOptions options = new PngMathRendererOptions() { Resolution = 150 };

// Geben Sie die Präambel an.
options.Preamble = @"\usepackage{amsmath}
                    \usepackage{amsfonts}
                    \usepackage{amssymb}
                    \usepackage{color}";

// Geben Sie den Skalierungsfaktor 300 % an.
options.Scale = 3000;

// Legen Sie die Vordergrundfarbe fest.
options.TextColor = System.Drawing.Color.Black;

// Geben Sie die Hintergrundfarbe an.
options.BackgroundColor = System.Drawing.Color.White;

// Geben Sie den Ausgabestream für die Protokolldatei an.
options.LogStream = new MemoryStream();

// Geben Sie an, ob die Terminalausgabe auf der Konsole angezeigt werden soll oder nicht.
options.ShowTerminal = true;

// Die Variable, in die die Abmessungen des resultierenden Bildes geschrieben werden.
System.Drawing.SizeF size = new System.Drawing.SizeF();

// Erstellen Sie den Ausgabestream für das Formelbild.
using (Stream stream = File.Open(@"D:\Files\Tex\math-formula.png", FileMode.Create))
    // Rendern ausführen.
    MathRenderer.Render(@"This is a sample formula $f(x) = x^2$ example.", stream, options, out size);

// Andere Ergebnisse anzeigen.
System.Console.Out.WriteLine(options.ErrorReport);
System.Console.Out.WriteLine();
System.Console.Out.WriteLine("Size: " + size);

Komplexe Gleichungen in C# rendern

Wir können alle komplexen Gleichungen oder Formeln rendern, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 wie unten gezeigt bereitstellen:

MathRenderer.Render(@"\begin{equation*}
                e^x = x^{\color{red}0} + x^{\color{red}1} + 
                \frac{x^{\color{red}2}}{2} + 
                \frac{x^{\color{red}3}}{6} + 
                \cdots = \sum_{n\geq 0} \frac{x^{\color{red}n}}{n!}
                \end{equation*}", stream, options, out size);

Lange Gleichungen in C# anzeigen

Wir können lange Gleichungen in mehreren Zeilen anzeigen, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 wie unten gezeigt bereitstellen:

MathRenderer.Render(@"\begin{document}
                    \begin{multline*}
	            p(x) = x^1+x^2+x^3+x^4\\ 
	            - x^4 - x^3 - x^2 - x
	            \end{multline*}
                    \end{document}", stream, options, out size);

Mehrere Gleichungen mit C# ausrichten

Wir können auch mehrere Gleichungen oder Formeln gleichzeitig ausrichten und rendern, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 wie unten gezeigt bereitstellen:

MathRenderer.Render(@"\begin{document}
                         \begin{align*}
                         a+b   &  a-b   &  (a+b)(a-b)\\
                         x+y   &  x-y   &  (x+y)(x-y)\\
                         p+q   &  p-q   &  (p+q)(p-q)
                         \end{align*}
                         \end{document}", stream, options, out size);

Gleichungen gruppieren und zentrieren mit C#

Wir können mehrere Gleichungen beim Rendern gruppieren und zentrieren, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 angeben, wie unten gezeigt:

MathRenderer.Render(@"\begin{gather*} 
                (a+b)=a^2+b^2+2ab \\ 
                (a-b)=a^2+b^2-2ab \\
                (a-b)=a^2+b^2-2ab
                \end{gather*}", stream, options, out size);

Rendern von Matrizen, Klammern und Klammern in C# {#Render-Matrices,-Parenthesis,-and-Brackets-in-CSharp}

Wir können auch Matrizen, Klammern und Klammern rendern, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 wie unten gezeigt bereitstellen:

MathRenderer.Render(@"\begin{document}
	            [ 
	            \left \{
	              \begin{tabular}{ccc}
	              1 & 4 & 7 \\
	              2 & 5 & 8 \\
	              3 & 6 & 9 
	              \end{tabular}
	            \right \}
	            ]
	            \end{document}", stream, options, out size);

Brüche und Binome mit C# rendern

Wir können auch Brüche und Binome rendern, indem wir die zuvor erwähnten Schritte befolgen. Wir müssen jedoch nur die Formelzeichenfolge in Schritt 4 wie unten gezeigt bereitstellen:

MathRenderer.Render(@"\begin{document}
	            [
	                \binom{n}{k} = \frac{n!}{k!(n-k)!}
	            ]
	            \end{document}", stream, options, out size);

Holen Sie sich eine kostenlose Lizenz

Sie können eine kostenlose temporäre Lizenz erhalten, um die Bibliothek ohne Evaluierungseinschränkungen zu testen.

Fazit

In diesem Artikel haben wir gelernt, wie man:

• Rendern einfacher und komplexer mathematischer Formeln und Gleichungen in C#
• Gleichungen programmgesteuert ausrichten und gruppieren
• Rendern von Matrizen, Klammern, Klammern, Brüchen und Binomen

Außerdem können Sie mithilfe der Dokumentation mehr über Aspose.TeX für die .NET-API erfahren. Bei Unklarheiten können Sie uns gerne im Forum kontaktieren.

Siehe auch

• Konvertieren Sie TeX (LaTeX) programmgesteuert mit C# in eine PDF- oder XPS-Datei