latex2exp

https://www.stefanom.io/latex2exp/
Admin
latex2exp is an R package that lets you use LaTeX in plots. It parses and converts LaTeX to R’s...
Tokens:13,216
Snippets:187
Trust Score:7.4
Update:4 months ago
Show doc for...
Tokens:
Raw
### latex2exp_examples()

Source: https://www.stefanom.io/latex2exp/reference/index.html

Provides examples of how to use the latex2exp package.

```APIDOC
## latex2exp_examples()

### Description
Provides examples for the latex2exp package.

### Returns
Typically, this function will execute and display examples.
```

--------------------------------

### Run latex2exp Examples

Source: https://www.stefanom.io/latex2exp/articles/using-latex2exp.html

Executes a function to display various examples of the latex2exp package's capabilities.

```R
latex2exp_examples(cex = 0.9)
```

--------------------------------

### Install latex2exp Development Version from GitHub

Source: https://www.stefanom.io/latex2exp/index.html

Install the development version of the latex2exp package from GitHub using the devtools package.

```r
devtools::install_github('stefano-meschiari/latex2exp')
```

--------------------------------

### Layout and Spacing Examples

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering fractions, phantom spaces, and different types of horizontal spacing.

```R
TeX(r"(**$\\frac{x+y}{x-y}$**)")
```

```R
TeX(r"(**$A \\phantom B$**)")
```

```R
TeX(r"(**$A \\ B$**)")
```

```R
TeX(r"(**$A \; B$**)")
```

```R
TeX(r"(**$A \, B$**)")
```

--------------------------------

### Binary Operator Example

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Renders a binary operator like modulo.

```R
TeX(r"(**$\\alpha \\mod \\beta$**)")
```

--------------------------------

### Text Size Commands

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Applies different text sizes (normal, small, tiny) to example text.

```R
TeX(r"(**\\normalsize{example text}**)")
```

```R
TeX(r"(**\\small{example text}**)")
```

```R
TeX(r"(**\\tiny{example text}**)")
```

--------------------------------

### Set Operator Examples

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Renders various set operators including subset, superset, and set difference.

```R
TeX(r"(**$A \\subset B$**)")
```

```R
TeX(r"(**$A \\subseteq B$**)")
```

```R
TeX(r"(**$A \\nsubset B$**)")
```

```R
TeX(r"(**$A \\supset B$**)")
```

```R
TeX(r"(**$A \\supseteq B$**)")
```

```R
TeX(r"(**$A \\setminus B$**)")
```

```R
TeX(r"(**$A \\cup B$**)")
```

```R
TeX(r"(**$A \\cap B$**)")
```

--------------------------------

### Formatting Commands

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Applies different text formatting styles (bold, italic, roman) to example text.

```R
TeX(r"(**\\textbf{example text}**)")
```

```R
TeX(r"(**\\textit{example text}**)")
```

```R
TeX(r"(**\\bf{example text}**)")
```

```R
TeX(r"(**\\it{example text}**)")
```

```R
TeX(r"(**\\textrm{example text}**)")
```

--------------------------------

### Symbol Examples

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Renders various mathematical symbols including infinity, partial derivative, degree, suits, Hebrew letters, currency, and geometric shapes.

```R
TeX(r"(**$\\infty$**)")
```

```R
TeX(r"(**$\\partial$**)")
```

```R
TeX(r"(**$\\degree$**)")
```

```R
TeX(r"(**$\\clubsuit$**)")
```

```R
TeX(r"(**$\\diamondsuit$**)")
```

```R
TeX(r"(**$\\heartsuit$**)")
```

```R
TeX(r"(**$\\spadesuit$**)")
```

```R
TeX(r"(**$\\aleph$**)")
```

```R
TeX(r"(**$\\euro$**)")
```

```R
TeX(r"(**$\\textbackslash$**)")
```

```R
TeX(r"(**$\\diamond$**)")
```

```R
TeX(r"(**$\\uptriangle$**)")
```

```R
TeX(r"(**$\\righttriangle$**)")
```

```R
TeX(r"(**$\\downtriangle$**)")
```

```R
TeX(r"(**$\\lefttriangle$**)")
```

```R
TeX(r"(**$\\smiley$**)")
```

```R
TeX(r"(**$\\sharp$**)")
```

```R
TeX(r"(**$\\eighthnote$**)")
```

```R
TeX(r"(**$\\twonotes$**)")
```

```R
TeX(r"(**$\\sun$**)")
```

```R
TeX(r"(**$\\venus$**)")
```

```R
TeX(r"(**$\\mars$**)")
```

```R
TeX(r"(**$\\Exclam$**)")
```

```R
TeX(r"(**$\\dagger$**)")
```

```R
TeX(r"(**$\\ddagger$**)")
```

```R
TeX(r"(**''**)")
```

```R
TeX(r"(**'$**)")
```

```R
TeX(r"(**$\\degree$**)")
```

```R
TeX(r"(**$\\prime$**)")
```

```R
TeX(r"(**$\\second$**)")
```

```R
TeX(r"(**$\\third$**)")
```

```R
TeX(r"(**$\\%$**)")
```

```R
TeX(r"(**$\\S$**)")
```

```R
TeX(r"(**$\\permil$**)")
```

```R
TeX(r"(**$\\blacksquare$**)")
```

```R
TeX(r"(**$\\square$**)")
```

```R
TeX(r"(**$\\smwhtsquare$**)")
```

--------------------------------

### Arrow Examples

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Renders various arrow types, including single-headed, double-headed, and up/down arrows.

```R
TeX(r"(**$\\alpha \\rightarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\leftarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\leftrightarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\Rightarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\Leftarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\Leftrightarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\uparrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\downarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\Uparrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\Downarrow \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\to \\beta$**)")
```

```R
TeX(r"(**$\\alpha \\iff \\beta$**)")
```

--------------------------------

### Install latex2exp from CRAN

Source: https://www.stefanom.io/latex2exp/index.html

Install the latex2exp package from the Comprehensive R Archive Network (CRAN).

```r
install.packages('latex2exp')
```

--------------------------------

### Other Operator Examples

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Renders common mathematical operators such as for all, exists, imaginary part, real part, and negation.

```R
TeX(r"(**$\\forall$**)")
```

```R
TeX(r"(**$\\exists$**)")
```

```R
TeX(r"(**$\\Im$**)")
```

```R
TeX(r"(**$\\Re$**)")
```

```R
TeX(r"(**$\\wp$**)")
```

```R
TeX(r"(**$\\surd$**)")
```

```R
TeX(r"(**$\\neg$**)")
```

```R
TeX(r"(**$\\ni$**)")
```

```R
TeX(r"(**$\\pmod$**)")
```

--------------------------------

### Basic LaTeX String Rendering

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Renders a simple LaTeX string using the TeX function. This is a fundamental example for understanding basic usage.

```R
library(latex2exp)

TeX("$\alpha = \beta \times \frac{1}{2}")
```

--------------------------------

### Get List of Supported LaTeX Commands

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_supported.html

Call this function to retrieve a data frame of all supported LaTeX commands. Set `show = TRUE` to display a searchable table of symbols.

```R
latex2exp_supported()
```

--------------------------------

### Error Rendering Modulo

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

This snippet shows an example of a LaTeX command ('\pmod') that could not be rendered by latex2exp, along with the error message and parsed expression. It highlights potential issues with unsupported commands or syntax.

```R
## Warning in value[[3L]](cond): Couldn't render $\pmod$ because of error Error in TeX(content): Error while converting LaTeX into valid plotmath.
## Original string: $\pmod$
## Parsed expression: phantom() ~ group('(', 'mod' ~ , ')')
## Error in str2expression(rendered) : <text>:1:32: unexpected ','
## 1: phantom() ~ group('(', 'mod' ~ ,
##                                    ^

```

--------------------------------

### Previewing LaTeX Formula

Source: https://www.stefanom.io/latex2exp/articles/using-latex2exp.html

Quickly preview a translated LaTeX string using the plot function. This example includes a complex formula with fractions and exponents.

```R
plot(TeX(r'(A $\LaTeX$ formula: $\frac{2hc^2}{\lambda^5}\frac{1}{e^{\frac{hc}{\lambda k_B T}} - 1}$)'), cex = 2, main = "")
```

--------------------------------

### LaTeX Expression with Escaped Backslashes

Source: https://www.stefanom.io/latex2exp/articles/using-latex2exp.html

An alternative to raw strings for older R versions, this example shows how to escape backslashes for LaTeX commands.

```R
TeX("\\textbf{Euler's identity} is $e^{i\\pi} + 1 = 0$.")
```

--------------------------------

### Rendering Fractions and Subscripts/Superscripts

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Shows how to render fractions, subscripts, and superscripts. Essential for displaying mathematical formulas.

```R
TeX("$\frac{a}{b}")
TeX("$a_{b}")
TeX("$a^{b}")
TeX("$a^{b}_{c}")
```

--------------------------------

### Render Binary Similar To

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary similar to relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \sim \beta$**)")
```

--------------------------------

### Rendering Matrices and Arrays

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates the rendering of matrices and arrays using LaTeX syntax. Suitable for displaying tabular mathematical data.

```R
TeX("$\begin{pmatrix} a & b \\ c & d \end{pmatrix}$")
TeX("$\begin{bmatrix} a & b \\ c & d \end{bmatrix}$")
TeX("$\begin{array}{cc} a & b \\ c & d \end{array}$")
```

--------------------------------

### Render Binary Identical To

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary identical to relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \equiv \beta$**)")
```

--------------------------------

### Render Binary Logical AND

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary logical AND operation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \wedge \beta$**)")
```

--------------------------------

### Render Binary Less Than

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary less than comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha < \beta$**)")
```

--------------------------------

### latex2exp_supported()

Source: https://www.stefanom.io/latex2exp/reference/index.html

Returns a list of LaTeX commands that are supported by the package.

```APIDOC
## latex2exp_supported()

### Description
Returns the list of supported LaTeX commands.

### Returns
A list or vector containing supported LaTeX commands.
```

--------------------------------

### Rendering Delimiters and Parentheses

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Shows how to use different types of delimiters and parentheses, including auto-sizing ones. Important for grouping terms in expressions.

```R
TeX("$(\frac{a}{b})$")
TeX("$[a+b]$")
TeX("$\{a \cup b\}$")
TeX("$\left(\frac{a}{b}\right)$")
```

--------------------------------

### Operators with Subscripts and Superscripts

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering operators with custom roots, summations, products, integrals, unions, intersections, limits, minimum, and maximum.

```R
TeX(r"(**$\\sqrt[z]{x+y}$**)")
```

```R
TeX(r"(**$\\sum_{i=0}^{\\infty}$**)")
```

```R
TeX(r"(**$\\prod_{i=0}^{\\infty}$**)")
```

```R
TeX(r"(**$\\int_{i=0}^{\\infty}$**)")
```

```R
TeX(r"(**$\\bigcup_{i} A_i$**)")
```

```R
TeX(r"(**$\\bigcap_{i} A_i$**)")
```

```R
TeX(r"(**$\\lim_{x \\to \\infty} \\frac{1}{x}$**)")
```

```R
TeX(r"(**$\\min_{x \\in X} x^2$**)")
```

```R
TeX(r"(**$\\max_{x \\in X} x^2$**)")
```

--------------------------------

### Render Binary Proportional To

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary proportional to relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \propto \beta$**)")
```

--------------------------------

### TeX Scalable Parentheses

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for scalable parentheses, brackets, braces, and absolute value symbols.

```TeX
TeX(r"(**$\\left( a+b \\right)$**)")
```

```TeX
TeX(r"(**$\\left[ a+b \\right]$**)")
```

```TeX
TeX(r"(**$\\left{ a+b \\right}$**)")
```

```TeX
TeX(r"(**$\\left| a+b \\right|$**)")
```

```TeX
TeX(r"(**$\\left. a+b \\right.$**)")
```

```TeX
TeX(r"(**$\\|| a+b \\||$**)")
```

--------------------------------

### Rendering Script Style

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates how to control the script style (e.g., for limits of summation) using \displaystyle and \textstyle.

```R
TeX("$\scriptstyle \sum_{i=1}^{n} i$")
TeX("$\scriptscriptstyle \sum_{i=1}^{n} i$")
```

--------------------------------

### Render Binary Plus-Minus

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary plus-minus operation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \pm \beta$**)")
```

--------------------------------

### Rendering Mathematical Operators

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates the rendering of various mathematical operators, including integral, summation, and product. Essential for calculus and statistics.

```R
TeX("$\int_{a}^{b} f(x) dx$")
TeX("$\sum_{i=1}^{n} i$")
TeX("$\prod_{i=1}^{n} i$")
```

--------------------------------

### Render Binary Tensor Product

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary tensor product between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \otimes \beta$**)")
```

--------------------------------

### Rendering Large Operators

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Shows how to render large operators like summation and integral with limits. Essential for advanced mathematical expressions.

```R
TeX("$\displaystyle \sum_{i=1}^{n} i^2$")
TeX("$\displaystyle \int_{0}^{\infty} e^{-x^2} dx$")
```

--------------------------------

### Render Binary Less Than or Equal

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary less than or equal to comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \leq \beta$**)")
```

--------------------------------

### Render Binary Approximately Equal

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary approximately equal to comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \approx \beta$**)")
```

--------------------------------

### Basic LaTeX Expression

Source: https://www.stefanom.io/latex2exp/articles/using-latex2exp.html

Demonstrates basic LaTeX formatting including bold text, inline math mode, superscripts, and special characters like pi. Uses raw string literals for cleaner syntax.

```R
TeX(r"(\textbf{Euler's identity} is $e^{i\pi} + 1 = 0$.")
```

--------------------------------

### Render Arithmetic Addition

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a simple arithmetic addition expression using Greek letters alpha and beta.

```R
TeX(r"(**$\alpha + \beta$**)")
```

--------------------------------

### TeX Vector Notation

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for vector notation, including norm, bra, ket, and braket.

```TeX
TeX(r"(**$\\norm{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\bra{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\ket{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\braket{\\Psi | \\Psi}$**)")
```

--------------------------------

### TeX Decorations

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for applying decorations such as tildes, hats, and overlines to symbols.

```TeX
TeX(r"(**$\\tilde{\Psi}$**)")
```

```TeX
TeX(r"(**$\\hat{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\widehat{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\widetilde{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\bar{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\dot{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\underline{\\Psi}$**)")
```

```TeX
TeX(r"(**$\\mathring{\\Psi}$**)")
```

--------------------------------

### TeX Miscellanea

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for common miscellanea like LaTeX and TeX.

```TeX
TeX(r"(**$\\LaTeX$**)")
```

```TeX
TeX(r"(**$\\TeX$**)")
```

--------------------------------

### Render Binary Congruent To

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary congruent to relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \cong \beta$**)")
```

--------------------------------

### Render Binary Not Equal (Slash)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary not equal comparison (using a slash) between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \ne \beta$**)")
```

--------------------------------

### Render Binary Not Equal (Tilde)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary not equal comparison (using a tilde) between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \neq \beta$**)")
```

--------------------------------

### Render Binary Logical OR

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary logical OR operation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \vee \beta$**)")
```

--------------------------------

### Render Binary Equality

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary equality comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha = \beta$**)")
```

--------------------------------

### Render Binary Dot Product

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary dot product between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \cdot \beta$**)")
```

--------------------------------

### Render Binary Circle Composition

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary circle composition operation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \circ \beta$**)")
```

--------------------------------

### TeX Non-Scalable Parentheses

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for non-scalable parentheses, brackets, angle brackets, and floor/ceiling symbols.

```TeX
TeX(r"(**$\\lbrack a+b \\rbrack$**)")
```

```TeX
TeX(r"(**$\\langle a+b \\rangle$**)")
```

```TeX
TeX(r"(**$\\lceil a+b \\rceil$**)")
```

```TeX
TeX(r"(**$\\lfloor a+b \\rfloor$**)")
```

--------------------------------

### Render Binary Direct Sum

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary direct sum between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \oplus \beta$**)")
```

--------------------------------

### Rendering Custom Commands

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Illustrates how to define and use custom LaTeX commands within the TeX function. Allows for user-defined symbols or notations.

```R
TeX("$\newcommand{\R}{\mathbb{R}}\R^2$")
```

--------------------------------

### Render Binary Circle Minus (Division Slash)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary circle minus (division slash) operation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \oslash \beta$**)")
```

--------------------------------

### Render Binary Element Of

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary element of relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \in \beta$**)")
```

--------------------------------

### Rendering Text Formatting (Bold, Italic, Underline)

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Shows how to apply text formatting like bold, italic, and underline to text within LaTeX strings.

```R
TeX("$\textbf{bold text}$")
TeX("$\textit{italic text}$")
TeX("$\underline{underlined text}$")
```

--------------------------------

### Render Greek Letter Kappa (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Kappa using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Kappa$**)")
```

--------------------------------

### TeX Symbols

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for various symbols like square, integral, and ellipsis.

```TeX
TeX(r"(**$\\smblksquare$**)")
```

```TeX
TeX(r"(**$\\smallint$**)")
```

```TeX
TeX(r"(**$\\ell$**)")
```

```TeX
TeX(r"(**$\\house$**)")
```

```TeX
TeX(r"(**$\\dots$**)")
```

--------------------------------

### plot()

Source: https://www.stefanom.io/latex2exp/reference/index.html

Previews a LaTeX equation within the R environment.

```APIDOC
## plot(_<expression>_)

### Description
Previews a LaTeX equation.

### Parameters
* `_<expression>`: The LaTeX expression to preview.
```

--------------------------------

### render_latex()

Source: https://www.stefanom.io/latex2exp/reference/index.html

Renders a LaTeX abstract syntax tree (AST).

```APIDOC
## render_latex()

### Description
Renders a LaTeX tree.

### Returns
The rendered LaTeX output.
```

--------------------------------

### Render Binary Cross Product

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary cross product between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \times \beta$**)")
```

--------------------------------

### Render Greek Letter Kappa

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter kappa using the TeX function from the latex2exp package.

```R
TeX(r"(**$\kappa$**)")
```

--------------------------------

### Render Binary Greater Than

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary greater than comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha > \beta$**)")
```

--------------------------------

### Render Binary Division Symbol

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary division using the division symbol between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \div \beta$**)")
```

--------------------------------

### Render Arithmetic Division

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a simple arithmetic division expression using Greek letters alpha and beta.

```R
TeX(r"(**$\alpha / \beta$**)")
```

--------------------------------

### Render Binary Greater Than or Equal

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary greater than or equal to comparison between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \geq \beta$**)")
```

--------------------------------

### Render Greek Letter Iota (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Iota using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Iota$**)")
```

--------------------------------

### Render Greek Letter Iota

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter iota using the TeX function from the latex2exp package.

```R
TeX(r"(**$\iota$**)")
```

--------------------------------

### Render Arithmetic Subtraction

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a simple arithmetic subtraction expression using Greek letters alpha and beta.

```R
TeX(r"(**$\alpha - \beta$**)")
```

--------------------------------

### Render Greek Letter Beta (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Beta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Beta$**)")
```

--------------------------------

### Base Graphics Plot with LaTeX Labels

Source: https://www.stefanom.io/latex2exp/articles/using-latex2exp.html

Illustrates plotting in base R graphics, using LaTeX for axis labels, plot titles, and legend entries. Demonstrates dynamic generation of labels using sprintf.

```R
x <- seq(0, 4, length.out = 100)
alpha <- 1:5

plot(x, xlim = c(0, 4), ylim = c(0, 10), 
     xlab = 'x', ylab = TeX(r'($\alpha  x^\alpha$, where $\alpha \in \{1 \ldots 5\}$)'), 
     type = 'n', main = TeX(r'(Using $\LaTeX$ for plotting in base graphics!)', bold = TRUE))

for (a in alpha) {
  lines(x, a*x^a, col = a)
}

legend('topleft', 
       legend = TeX(sprintf(r'($\alpha = %d$)', alpha)), 
       lwd = 1, 
       col = alpha)
```

--------------------------------

### Render Binary Asterisk Operator

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary asterisk operator between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \ast \beta$**)")
```

--------------------------------

### Define Custom LaTeX Commands

Source: https://www.stefanom.io/latex2exp/reference/TeX.html

Shows how to define and use custom LaTeX commands within the TeX function by providing a list to the 'user_defined' argument. The template string uses special parameters like $arg1.

```R
# create a \variance command that takes a single argument
TeX("$\variance{X} = 10$",
    user_defined = list("\\variance" = "sigma[$arg1]^2"))
```

--------------------------------

### Render Greek Letter Beta

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter beta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\beta$**)")
```

--------------------------------

### Render Binary Perpendicular

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary perpendicular relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \perp \beta$**)")
```

--------------------------------

### Render Binary Angle

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary angle between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \angle \beta$**)")
```

--------------------------------

### Base Graphics Plot with LaTeX Labels

Source: https://www.stefanom.io/latex2exp/index.html

Demonstrates using latex2exp to create axis labels and a main title with LaTeX formatting in base R graphics.

```r
x <- seq(0, 4, length.out=100)
alpha <- 1:5

plot(x, xlim=c(0, 4), ylim=c(0, 10), 
     xlab='x', ylab=TeX(r'($\alpha  x^\alpha$, where $\alpha \in \{1 \ldots 5\}$)')', 
     type='n', main=TeX(r'(Using $\LaTeX$ for plotting in base graphics!)', bold=TRUE))

for (a in alpha) {
  lines(x, a*x^a, col=a)
}

legend('topleft', 
       legend=TeX(sprintf(r'($\alpha = %d$)', alpha)), 
       lwd=1, 
       col=alpha)
```

--------------------------------

### Render Binary Ellipsis (Dotted)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary ellipsis (dotted) between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \ldots \beta$**)")
```

--------------------------------

### latex2exp_supported

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_supported.html

Returns a data frame containing a table of supported LaTeX commands. Optionally, it can display a searchable table of symbols.

```APIDOC
## Function: latex2exp_supported

### Description
Returns the list of supported LaTeX commands. If `show` is TRUE, also shows a searchable table of symbols.

### Usage
```
latex2exp_supported(show = FALSE, ...)
```

### Arguments

* `show` (logical) - If TRUE, displays a searchable table of symbols.
* `...` - Other parameters (not used).

### Value
A data frame containing a table of supported LaTeX commands.
```

--------------------------------

### Rendering LaTeX String with Custom Font Size

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates how to control the font size of the rendered LaTeX string using the 'cex' argument.

```R
plot(1, 1, main = TeX("$\alpha = \beta \times \frac{1}{2}$", cex = 2))
```

--------------------------------

### Render Greek Letter Eta (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Eta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Eta$**)")
```

--------------------------------

### Render Greek Letter Epsilon (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Epsilon using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Epsilon$**)")
```

--------------------------------

### Render Arithmetic Multiplication

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a simple arithmetic multiplication expression using Greek letters alpha and beta.

```R
TeX(r"(**$\alpha * \beta$**)")
```

--------------------------------

### Render Binary Ellipsis (Three Dots)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary ellipsis (three dots) between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \cdots \beta$**)")
```

--------------------------------

### Render Binary Not Element Of

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary not element of relation between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \notin \beta$**)")
```

--------------------------------

### Render Greek Letter Pi

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter pi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\pi$**)")
```

--------------------------------

### Render Binary Bullet Operator

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a binary bullet operator between Greek letters alpha and beta.

```R
TeX(r"(**$\alpha \bullet \beta$**)")
```

--------------------------------

### Render Greek Letter Epsilon

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter epsilon using the TeX function from the latex2exp package.

```R
TeX(r"(**$\epsilon$**)")
```

--------------------------------

### Render Greek Letter Psi (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Psi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Psi$**)")
```

--------------------------------

### Render Greek Letter Pi (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Pi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Pi$**)")
```

--------------------------------

### Rendering Text within Math Mode

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Illustrates how to include plain text within a LaTeX math expression using \text{}. Useful for adding explanatory text.

```R
TeX("$\text{This is text within math mode}$")
```

--------------------------------

### Render Greek Letter Gamma

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter gamma using the TeX function from the latex2exp package.

```R
TeX(r"(**$\gamma$**)")
```

--------------------------------

### Render Greek Letter Zeta (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Zeta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Zeta$**)")
```

--------------------------------

### TeX Specials

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates TeX commands for special characters like comma and vertical bar.

```TeX
TeX(r"(**$,$**)")
```

```TeX
TeX(r"(**$|$**)")
```

--------------------------------

### Render Greek Letter Gamma (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Gamma using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Gamma$**)")
```

--------------------------------

### Render Greek Letter Phi (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Phi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Phi$**)")
```

--------------------------------

### Rendering Greek Letters and Symbols

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates rendering of common Greek letters and mathematical symbols. Useful for scientific and mathematical plots.

```R
TeX("$\alpha, \beta, \gamma, \delta, \epsilon, \zeta, \eta, \theta, \lambda, \mu, \nu, \pi, \rho, \sigma, \tau, \phi, \omega, \Omega, \infty, \forall, \exists, \nabla, \partial, \times, \div, \leq, \geq, \neq, \approx, \equiv, \subset, \supset, \cap, \cup, \int, \sum, \prod, \lim, \sin, \cos, \tan, \log, \exp, \sqrt{\alpha}")
```

--------------------------------

### Render Greek Letter Zeta

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter zeta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\zeta$**)")
```

--------------------------------

### Render Greek Letter Omega (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Omega using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Omega$**)")
```

--------------------------------

### Render Greek Letter Upsilon (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Upsilon using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Upsilon$**)")
```

--------------------------------

### Render Greek Letter Lambda (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Lambda using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Lambda$**)")
```

--------------------------------

### Render Greek Letter Sigma (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Sigma using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Sigma$**)")
```

--------------------------------

### Render Greek Letter Lambda

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter lambda using the TeX function from the latex2exp package.

```R
TeX(r"(**$\lambda$**)")
```

--------------------------------

### Render Greek Letter Omega

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter omega using the TeX function from the latex2exp package.

```R
TeX(r"(**$\omega$**)")
```

--------------------------------

### Render Greek Letter Eta

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter eta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\eta$**)")
```

--------------------------------

### Render Greek Letter Mu (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Mu using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Mu$**)")
```

--------------------------------

### Render Greek Letter Pi (Variant)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a variant of the Greek letter pi (varpi) using the TeX function from the latex2exp package.

```R
TeX(r"(**$\varpi$**)")
```

--------------------------------

### Render Greek Letter Sigma

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter sigma using the TeX function from the latex2exp package.

```R
TeX(r"(**$\sigma$**)")
```

--------------------------------

### Render Greek Letter Psi

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter psi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\psi$**)")
```

--------------------------------

### Rendering Arrows

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Demonstrates the rendering of various arrow symbols. Useful for indicating direction, implication, or relationships.

```R
TeX("$\rightarrow, \leftarrow, \uparrow, \downarrow, \Rightarrow, \Leftarrow, \Uparrow, \Downarrow, \leftrightarrow, \longleftarrow, \longrightarrow$")
```

--------------------------------

### Render Greek Letter Phi

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter phi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\phi$**)")
```

--------------------------------

### Render Greek Letter Chi

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter chi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\chi$**)")
```

--------------------------------

### Render Greek Letter Chi (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Chi using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Chi$**)")
```

--------------------------------

### Render LaTeX to Plotmath

Source: https://www.stefanom.io/latex2exp/reference/render_latex.html

Converts a LaTeX token tree into a string that can be parsed by R's plotmath.

```R
render_latex(tokens, user_defined = list(), hack_parentheses = FALSE)
```

--------------------------------

### Render Greek Letter Alpha

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter alpha using the TeX function from the latex2exp package.

```R
TeX(r"(**$\alpha$**)")
```

--------------------------------

### Rendering Accents and Special Characters

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Illustrates the use of accents and special characters within LaTeX strings. Useful for non-English characters or specific notations.

```R
TeX("$\acute{a}, \grave{a}, \breve{a}, \check{a}, \ddot{a}, \tilde{a}, \hat{a}, \bar{a}, \vec{a}, \dot{a}, \ddot{a}$")
```

--------------------------------

### Render Greek Letter Phi (Variant)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates rendering a variant of the Greek letter phi (varphi) using the TeX function from the latex2exp package.

```R
TeX(r"(**$\varphi$**)")
```

--------------------------------

### Rendering Multiple LaTeX Strings in a Plot

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

Shows how to use multiple LaTeX strings for different plot elements like titles and axis labels.

```R
plot(1:5, main = TeX("$\alpha = \beta \times \frac{1}{2}$"), xlab = TeX("$\text{X-axis label}$ (units)"), ylab = TeX("$\text{Y-axis label}$ (units)"))
```

--------------------------------

### Render Greek Letter Mu

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter mu using the TeX function from the latex2exp package.

```R
TeX(r"(**$\mu$**)")
```

--------------------------------

### Render Greek Letter Delta (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Delta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Delta$**)")
```

--------------------------------

### Render Greek Letter Delta

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter delta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\delta$**)")
```

--------------------------------

### Render Greek Letter Upsilon

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter upsilon using the TeX function from the latex2exp package.

```R
TeX(r"(**$\upsilon$**)")
```

--------------------------------

### Render Greek Letter Alpha (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Alpha using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Alpha$**)")
```

--------------------------------

### Rendering Basic Plot with LaTeX Label

Source: https://www.stefanom.io/latex2exp/reference/latex2exp_examples.html

A simple R plot demonstrating the use of a LaTeX string as a plot label using the TeX function.

```R
plot(1, 1, main = TeX("$\alpha = \beta \times \frac{1}{2}$"))
```

--------------------------------

### Render Greek Letter Nu (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Nu using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Nu$**)")
```

--------------------------------

### Render Greek Letter Omicron (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Omicron using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Omicron$**)")
```

--------------------------------

### Render Greek Letter Nu

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter nu using the TeX function from the latex2exp package.

```R
TeX(r"(**$\nu$**)")
```

--------------------------------

### Render Greek Letter Theta (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Theta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Theta$**)")
```

--------------------------------

### print() - AST

Source: https://www.stefanom.io/latex2exp/reference/index.html

Prints a parsed LaTeX object (AST) for debugging purposes.

```APIDOC
## print(_<latextoken2>_)

### Description
Prints out a parsed LaTeX object, as returned by TeX(..., output = 'ast'). This is primarily used for debugging.

### Parameters
* `_<latextoken2>`: A parsed LaTeX object (AST).
```

--------------------------------

### ggplot2 Plot with LaTeX Labels and Title

Source: https://www.stefanom.io/latex2exp/index.html

Demonstrates using latex2exp to create axis labels, a plot title, and legend labels with LaTeX formatting in ggplot2.

```r
x <- seq(0, 4, length.out=100)
alpha <- 1:5
data <- map_df(alpha, ~ tibble(v=.*x^., x=x, alpha=.))

p <- ggplot(data, aes(x=x, y=v, color=as.factor(alpha))) +
    geom_line() +
    ylab(TeX(r'($\alpha  x^\alpha$, where $\alpha \in 1\ldots 5$)')) +
    ggtitle(TeX(r'(Using $\LaTeX$ for plotting in ggplot2. I $\heartsuit$ ggplot!)')) +
    coord_cartesian(ylim=c(-1, 10)) +
    guides(color=guide_legend(title=NULL)) +
    scale_color_discrete(labels=lapply(sprintf(r'($\alpha = %d$)', alpha), TeX)) 
    # Note that ggplot2 legend labels must be lists of expressions, not vectors of expressions

print(p)
```

--------------------------------

### Preview a LaTeX Equation

Source: https://www.stefanom.io/latex2exp/reference/plot.expression.html

Use plot() with a TeX() expression to preview the rendered equation on the current graphical device. This function is part of the latex2exp package.

```R
plot(TeX("Example equation: $a \geq b$"))
```

--------------------------------

### Render Greek Letter Tau (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Tau using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Tau$**)")
```

--------------------------------

### Print Latextoken2 S3 Method Usage

Source: https://www.stefanom.io/latex2exp/reference/print.latextoken2.html

This snippet shows the basic usage of the print.latextoken2 S3 method. It is used to display the internal AST representation of a parsed LaTeX object for debugging purposes.

```R
print(x, depth = 0, ...)
```

--------------------------------

### Render Greek Letter Rho (Uppercase)

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the uppercase Greek letter Rho using the TeX function from the latex2exp package.

```R
TeX(r"(**$\Rho$**)")
```

--------------------------------

### Preview LaTeX Formula in a Plot

Source: https://www.stefanom.io/latex2exp/index.html

Quickly preview how a translated LaTeX string will appear in a plot using the plot function.

```r
plot(TeX(r'(A $\LaTeX$ formula: $\frac{2hc^2}{\lambda^5}\frac{1}{e^{\frac{hc}{\lambda k_B T}} - 1}$)'), cex=2, main="")
```

--------------------------------

### plot.expression

Source: https://www.stefanom.io/latex2exp/reference/plot.expression.html

Previews a LaTeX equation on the current graphical device. This is useful to preview the output before placing it on a plot.

```APIDOC
## plot(x, ..., main = NULL)

### Description
Plots the result of a call to [TeX] on the current graphical device. This is useful to preview the output before placing it on a plot.

### Method
S3 method for class 'expression'

### Parameters
#### Arguments
* **x** (expression) - A `plotmath` expression returned by `TeX`.
* **...** (any) - Parameters to be passed to the `text` function.
* **main** (character) - Title of the plot

### Examples
```R
plot(TeX("Example equation: $a \geq b$"))
```
```

--------------------------------

### Render Greek Letter Theta

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter theta using the TeX function from the latex2exp package.

```R
TeX(r"(**$\theta$**)")
```

--------------------------------

### TeX()

Source: https://www.stefanom.io/latex2exp/reference/index.html

Converts LaTeX expressions into R's plotmath expressions, enabling the use of LaTeX in R plots.

```APIDOC
## TeX()

### Description
Converts LaTeX to a `plotmath` expression.

### Parameters
* `...`: Arguments passed to the function.
* `output`: Specifies the output format (e.g., 'ast').

### Returns
An R plotmath expression or an abstract syntax tree (AST) depending on the `output` parameter.
```

--------------------------------

### Render Greek Letter Tau

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter tau using the TeX function from the latex2exp package.

```R
TeX(r"(**$\tau$**)")
```

--------------------------------

### Render Greek Letter Omicron

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter omicron using the TeX function from the latex2exp package.

```R
TeX(r"(**$\omicron$**)")
```

--------------------------------

### Render Greek Letter Rho

Source: https://www.stefanom.io/latex2exp/articles/supported-commands.html

Demonstrates how to render the lowercase Greek letter rho using the TeX function from the latex2exp package.

```R
TeX(r"(**$\rho$**)")
```

--------------------------------

### Deprecated latex2exp Function Usage

Source: https://www.stefanom.io/latex2exp/reference/latex2exp.html

This snippet shows the usage of the deprecated `latex2exp` function from the R package. It takes a LaTeX string and an output format as arguments.

```R
latex2exp(string, output = c("expression", "character", "ast"))
```

--------------------------------

### Basic LaTeX to Plotmath Conversion with Raw Strings

Source: https://www.stefanom.io/latex2exp/index.html

Converts a LaTeX string to a plotmath expression using raw string literals. This method is recommended for R versions 4.0 and later and avoids the need to escape backslashes.

```r
# Use raw strings, no need to escape backslashes.
TeX(r"(\textbf{Euler's identity} is $e^{i\pi} + 1 = 0$.")
```

--------------------------------

### Use TeX in Plot Labels

Source: https://www.stefanom.io/latex2exp/reference/TeX.html

Demonstrates using the TeX function to create custom labels for R plots, including Greek letters and exponents.

```R
a <- 1:100
plot(a, a^2, xlab = TeX("$\alpha$"), ylab = TeX("$\alpha^2$"))
```

--------------------------------

### render_latex

Source: https://www.stefanom.io/latex2exp/reference/render_latex.html

Renders a LaTeX tree into a plotmath expression string. This function is useful for converting parsed LaTeX content into a format compatible with R's plotmath.

```APIDOC
## render_latex

### Description
Renders a LaTeX tree into a plotmath expression string. This function takes a LaTeX token tree and converts it into a string that can be parsed as a plotmath expression. It supports custom command definitions and provides an option to handle mismatched parentheses.

### Arguments

* **tokens** (tree of tokens) - Required - The LaTeX token tree to render.
* **user_defined** (list) - Optional - Any custom definitions of commands passed to `TeX`.
* **hack_parentheses** (boolean) - Optional - If TRUE, render parentheses using `group('(', phantom(), '.')` and `group(')', phantom(), '.')`. This is useful to return valid expressions when the LaTeX source contains mismatched parentheses, but makes the returned expression much less tidy.

### Value

String that should be parseable as a valid plotmath expression.
```
Tokens:
Raw