NAME¶
"LaTeXML::Post::MathML" - Post-Processing modules for converting math
to MathML.
SYNOPSIS¶
"LaTeXML::Post::MathML" is the abstract base class for the MathML
Postprocessor; "LaTeXML::Post::MathML::Presentation" and
"LaTeXML::Post::MathML::Content" convert XMath to either
Presentation or Content MathML, or with that format as the principle branch
for Parallel markup.
DESCRIPTION¶
The conversion is carried out primarly by a tree walk of the "XMath"
expression; appropriate handlers are selected and called depending on the
operators and forms encountered. Handlers can be defined on applications of
operators, or on tokens; when a token is applied, it's application handler
takes precedence over it's token handler
"DefMathML($key,$presentation,$content);"¶
Defines presentation and content handlers for $key. $key is of the form
"TYPE:ROLE:MEANING", where
TYPE : is one either C<Token> or C<Apply> (or C<Hint> ?)
ROLE : is a grammatical role (on XMath tokens)
MEANING : is the meaning attribute (on XMath tokens)
Any of these can be "?" to match any role or meaning; matches of both
are preferred, then match of meaning or role, or neither.
The subroutine handlers for presentation and content are given by $presentation
and $content, respectively. Either can be "undef", in which case
some other matching handler will be invoked.
For "Token" handlers, the arguments passed are the token node; for
"Apply" handler, the arguments passed are the operator node and any
arguments.
However, it looks like some "TOKEN" handlers are being defined to take
"$content,%attributes" being the string content of the token, and
the token's attributes!
Presentation Conversion Utilties¶
- "$mmlpost->pmml_top($node,$style);"
- This is the top-level converter applied to an "XMath" node. It
establishes a local context for font, style, size, etc. It generally does
the bulk of the work for a PresentationMathML's "translateNode",
although the latter wraps the actual "m:math" element around it.
("style" is display or text).
- "pmml($node)", "pmml_smaller($node)",
"pmml_scriptsizsize($node)"
- Converts the "XMath" $node to Presentation MathML. The latter
two are used when the context calls for smaller (eg. fraction parts) or
scriptsize (eg sub or superscript) size or style, so that the size encoded
within $node will be properly accounted for.
- "pmml_mi($node,%attributes)",
"pmml_mn($node,%attributes)",
"pmml_mo($node,%attributes)"
- These are "Token" handlers, to create "m:mi",
"m:mn" and "m:mo" elements, respectively. When called
as a handler, they will be supplied only with an "XMath" node
(typically an "XMTok"). For convenient reuse, these functions
may also be called on a 'virtual' token: with $node being a string (that
would have been the text content of the "XMTok"), and the
%attributes that would have been the token's attributes.
- "pmml_infix($op,@args)", "pmml_script($op,@args)",
"pmml_bigop($op,@args)"
- These are "Apply" handlers, for handling general infix, sub or
superscript, or bigop (eg. summations) constructs. They are called with
the operator token, followed by the arguments; all are "XMath"
elements.
- "pmml_row(@items)"
- This wraps an "m:mrow" around the already converted @items if
neeed; That is, if there is only a single item it is returned without the
"m:mrow".
- "pmml_unrow($pmml)"
- This perverse utility takes something that has already been converted to
Presentation MathML. If the argument is an "m:mrow", it returns
a list of the mathml elements within that row, otherwise it returns a list
containing the single element $pmml.
- "pmml_parenthesize($item,$open,$close)"
- This utility parenthesizes the (already converted MathML) $item with the
string delimiters $open and $close. These are converted to an
"m:mrow" with "m:mo" for the fences, unless the
"usemfenced" switch is set, in which case "m:mfenced"
is used.
- "pmml_punctuate($separators,@items) "
- This utility creates an "m:mrow" by interjecting the punctuation
between suceessive items in the list of already converted @items. If there
are more than one character in $separators the first is used between the
first pair, the next between the next pair; if the separators is
exhausted, the last is repeated between remaining pairs. $separators
defaults to (repeated) comma.
Content Conversion Utilties¶
- "$mmlpost-"cmml_top($node); >
- This is the top-level converter applied to an "XMath" node. It
establishes a local context for font, style, size, etc (were it needed).
It generally does the bulk of the work for a ContentMathML's
"translateNode", although the latter wraps the actual
"m:math" element around it.
- "cmml($node)"
- Converts the "XMath" $node to Content MathML.
- "cmml_ci($token)"
- Converts the "XMath" token to an "m:ci". (This may
evolve to generate a "m:csymbol", under appropriate
circumstances)
- "cmml_decoratedSymbol($item)"
- Similar to "cmml_ci", but used when an operator is itself,
apparently, an application. This converts $item to Presentation MathML to
use for the content of the "m:ci".
- "cmml_not($arg)"
- Construct the not of the argument $arg.
- "cmml_synth_not($op,@args)"
- Synthesize an operator by applying "m:not" to another operator
($op) applied to its @args ("XMath" elements that will be
converted to Content MathML). This is useful to define a handler for, eg.,
c<not-approximately-equals> in terms of c<m:approx>.
- "cmml_synth_complement($op,@args)"
- Synthesize an operator by applying a complementary operator ($op) to the
reverse of its @args ("XMath" elements that will be converted to
Content MathML). This is useful to define a handler for, eg.
"superset-of-or-equals" using "m:subset".
- "cmml_or_compose($operators,@args)"
- Synthesize an operator that stands for the "or" of several other
operators (eg. c<less-than-or-similar-to-or-approximately-equals>)
by composing it of the "m:or" of applying each of
"m:less" and "m:approx" to the arguments. The first
operator is applied to the converted arguments, while the rest are applied
to "m:share" elements referring to the previous ones.
- "cmml_share($node)"
- Converts the "XMath" $node to Content MathML, after assuring
that it has an id, so that it can be shared.
- "cmml_shared($node)"
- Generates a "m:share" element referting to $node, which should
have an id (such as after calling "cmml_share").
Math Processors, Generally.¶
We should probably formalize the idea of a Math Processor as an abstract class,
but let this description provide a starting overview. A MathProcessor follows
the API of "LaTeXML::Post" processors, by handling
"process", which invokes "processNode" on all
"Math" nodes; That latter inserts the result of either
"translateNode" or "translateParallel", applied to the
"XMath" representation, into the "Math" node.
Parallel translation is done whenever additional MathProcessors have been
specified, via the "setParallel" method; these are simply other
MathProcessors following the same API.