Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
LaTeXML::Post::MathML(User Contributed Perl DocumentatLaTeXML::Post::MathML(3)

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_leaf($token)"
	   Converts the	"XMath"	token to an "m:ci", "m:cn" or "m:csymbol",
	   under appropriate circumstances.

       "cmml_decoratedSymbol($item)"
	   Similar to "cmml_leaf", 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.

perl v5.32.1			  2020-11-09	      LaTeXML::Post::MathML(3)

NAME | SYNOPSIS | DESCRIPTION | Math Processors, Generally.

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=LaTeXML::Post::MathML&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help