Latexify.jl

Latexify.jl uses a recursive algorithm to traverse Julia expression trees (Expr type) to generate LaTeX strings. The process relies on two core internal methods:

1. latexraw(ex::Expr): This method recurses through the expression tree. It identifies the structure of the expression by looking at its arguments (ex.args).
2. latexoperation(ex::Expr, prevOp::AbstractArray): When the recursion reaches an expression that contains only symbols or strings (no further nested expressions), it calls latexoperation. This method identifies the mathematical operation and converts that specific node into a formatted LaTeX string (e.g., converting / to \frac{...}{...}).

The recursive results are bubbled back up the tree until the entire expression is transformed into a single LaTeX string.

ex = :(x + y/z)
# The process: 
# 1. latexraw(ex) sees :(x + (y/z))
# 2. latexraw recurses into (y/z)
# 3. latexoperation converts (y/z) to "\\frac{y}{z}"
# 4. latexraw returns "x + \\frac{y}{z}"
print(latexraw(ex)) # "x + \frac{y}{z}"

You can convert ReactionNetwork models generated by Catalyst.jl into LaTeX equations using latexify().

By default, latexify will attempt to render the chemical reaction notation. You can specify the mathematical form of the output using the form keyword argument:

• form=:ode: Generates the Ordinary Differential Equations (ODEs) representing the system.
• form=:sde: Generates the Stochastic Differential Equations (SDEs) representing the chemical Langevin equations (Note: SDE generation is currently reported as broken in the current version).

To use this, ensure both Catalyst and Latexify are loaded.

using Catalyst
using Latexify

# Define a reaction network
@reaction_network begin
  hill2(y, v_x, k_x), 0 --> x
  p_y, 0 --> y
  (d_x, d_y), (x, y) --> 0
  (r_b, r_u), x ↔ y
end

# Generate ODEs
latexify(rn; form=:ode)

# Generate SDEs
latexify(rn; form=:sde)

The @latexrecipe macro allows you to extend latexify to support custom types or types from other packages. It defines how an argument type should be pre-processed before being passed to the standard latexify function.

Key Requirements:

• Type Signature: The function passed to the macro must have a specific type signature (e.g., f(x::MyType)). The function name itself is unimportant.
• Explicit Return: You must use an explicit return statement. The returned value must be a type that latexify already supports (e.g., Array, Tuple, Number, Symbol, or String). You cannot rely on Julia's implicit return of the last expression.
• Scope: Recipes defined within a module work automatically without needing to be exported.

Warning: Do not use @latexrecipe to redefine how an already supported type is interpreted, as this can break functionality for other packages.

using Latexify

struct MyType 
   vector::Vector
end

@latexrecipe function f(x::MyType; reverse=false)
    vec = x.vector
    if reverse
        vec = vec[end:-1:1]
    end

    # Set default keyword arguments (can be overridden by user)
    env --> :array
    transpose --> true

    # Set fixed keyword arguments (cannot be overridden by user)
    fmt := "%.2f"

    return vec
end

mytype = MyType([1, 2, 3])
latexify(mytype; reverse=true)

To embed math results directly within Markdown text in a notebook, use Markdown.parse.

Note: Do not use the md""" literal for this purpose, as the dollar signs used for math mode will clash with Julia's string interpolation syntax. Instead, use Markdown.parse and interpolate the latexify results directly into the string.

When using Markdown.parse, you may need to escape special characters like backslashes, though Latexify typically minimizes this need. For manual control over the environment, you can use env=:raw combined with manual dollar signs.

Markdown.parse("""
## Results

With the previously calculated 
$(@latexdefine x), we can use
$(@latexify x = v*t) to calculate
$(@latexrun v = x/10), giving a final
velocity of $(latexify(v)).

If we want more manual control, we can
combine manual dollar signs with
`env=:raw`: \$ \hat{v} =
$(latexify(v, env=:raw));\, \mathrm{m}/\mathrm{s} $
""")