This page contains the description of the following commands
\l,
\L,
\label,
\labelitemi,
\labelitemii,
\labelitemiii,
\labelitemiv,
\labelsep,
\labelwidth,
\lambda,
\Lambda,
\land,
\langle,
\language,
\large,
\Large,
\LARGE,
\latex,
\latexhtml,
\latextohtml,
\LaTeX,
\LaTeXe,
\lastbox,
\lastkern,
\lastpenalty,
\lastskip,
\lbrace,
\lbrack,
\lceil,
\lccode,
\ldots,
\le,
\leaders,
\leadsto,
\leavevmode,
\left,
\leftarrow,
\Leftarrow,
\leftarrowtail,
\leftarrowtriangle,
\leftharpoondown,
\leftharpoonup,
\lefthyphenmin,
\leftleftarrows,
\leftline,
\leftmargin,
\leftmargini,
\leftmarginii,
\leftmarginiii,
\leftmarginiv,
\leftmarginv,
\leftmarginvi,
\leftrightarrow,
\Leftrightarrow,
\leftrightarrows,
\leftrightarrowtriangle,
\leftrightharpoons,
\leftrightsquigarrow,
\leftskip,
\leftslice,
\leftslice,
\leftthreetimes,
\leq,
\leqno,
\leqq,
\leqslant,
\lessapprox,
\lessdot,
\lesseqgtr,
\lesseqqgtr,
\lessgtr,
\lesssim,
\let,
\lfloor,
\lfoot,
\lg,
\lgroup,
\lhd,
\lhead,
\lightning,
\lim,
\liminf,
\limits,
\limsup,
\line,
\linebreak,
\linepenalty,
\lineskip,
\lineskiplimit,
\linethickness,
\linewidth,
\listfiles,
\listoffigures,
\listoftables,
\listparindent,
\ll,
\llap,
\llbracket,
\Lleftarrow,
\lll,
\llless,
\llparenthesis,
\lmoustache,
\ln,
\lnapprox,
\lneq,
\lneqq,
\lnot,
\lnsim,
\LoadClass,
\LoadClassWithOptions,
\log,
\loggingoutput,
\long,
\longleftarrow,
\Longleftarrow,
\longleftrightarrow,
\Longleftrightarrow,
\longmapsfrom,
\Longmapsfrom,
\Longmapsto,
\longmapsto,
\longrightarrow,
\Longrightarrow,
\loop,
\looparrowleft,
\looparrowright,
\loosenes,
\lor,
\lower,
\lowercase,
\lozenge,
\lq,
\lsc,
\Lsh,
\ltimes,
\lvert,
\lVert,

and environments
latexonly,
LaTeXonly.

The `\l` command produces an l with a stroke,
(Unicode U+142, ł).
(See also
`\AA` or
*extended latin characters*).

The `\L` command produces a capital L with a stroke,
(Unicode U+141, Ł).
(see also *extended latin characters*).

The `\label` command can be used to put a label somewhere.
The anchor can be a sectioning command,
see the description of the `\part` command.
It can also be a figure, a table, a math formula, a footnote, an item in a
list. Here are some cases.

\paragraph{A} \label{pa} \ref{pa} \ref{pb} \ref{pc} \ref{pd} \ref{pe} \ref{pf} \paragraph{B} \label{pb} \begin{equation}x \label{pc} \end{equation} \begin{figure} \includegraphics{x}\label{pd} \end{figure} \begin{itemize} \item a \label{pe}\item b \label{pf} \end{itemize}

The XML code is the following

<div3 id-text='0.0.0.1 id='uid19'><head>A</head> <p><ref target='uid19'/> <ref target='uid20'/> <ref target='uid21'/> <ref target='uid22'/> <ref target='uid23'/> <ref target='uid24'/></p> </div3> <div3 id-text='0.0.0.2' id='uid20'><head>B</head> <formula id-text='1' id='uid21' type='display'><math xmlns='http://www.w3.org/1998/Math/MathML'><mi>x</mi></math></formula> <figure file='x' id-text='1' id='uid22'></figure> <list type='simple'> <item id-text='1' id='uid23'><p>a </p> </item> <item id-text='1' id='uid24'><p>b </p> </item></list> ... </div3>

The default value of an item label (case where `\item` is given
without optional argument) is defined by `\labelitemi`, a bullet.
In the case of nested lists, it is the value of `\labelitemii`,
`\labelitemiii`, or `\labelitemiv`. Not used by
*Tralics*.

Space between a label and the text that follows in an item.
Unused by *Tralics*.

The normal width of a box that contains the label in an item.
Unused by *Tralics*.

The `\lambda` command is valid only in math mode. It generates
a Greek letter:
`<mi>λ</mi>`
(Unicode U+3BB, λ).
(See description of the
`\alpha` command).

The `\Lambda` command is valid only in math mode. It generates
an uppercase Greek letter:
`<mi>Λ</mi>`
(Unicode U+39B, Λ).
(See description of the
`\alpha` command.)

The `\land` command (logical and) is equivalent to
`\wedge` command:
`<mo>∧</mo>`
(Unicode U+2227, ∧).
(See also description of the
`\smallint` command.)

The `\langle` command is valid only in math mode.
It generates a delimiter (left angle):
`<mo>⟨</mo>`
(Unicode U+2329, 〈).
(See description of the
`\vert` command.)

When you say `\language=79`, the language number 79
is selected. *Tralics* knows the following languages: 0 for English,
1 for French, 2 for German, and 3 for the other one. More explanations
should be given...
(See *scanint* for details of argument scanning).

The `\large` command is a command that selects a large font.
For an example of fonts, see `\rm`.

The `\Large` command is a command that selects a large font.
For an example of fonts, see `\rm`.

The `\LARGE` command is a command that selects a large font.
For an example of fonts, see `\rm`.

In the case where the last item on the current list (XML tree)
is a box, the `\lastbox` takes it off the stack and returns it.
Otherwise, `\lastbox` returns an empty box. This does
not work in math mode.
Example

\def\dupbox{\setbox0=\lastbox \copy0 \box0 } \xbox{foo}{ok} and \dupbox; \xbox{bar}{ok}\dupbox.

Translation.

<foo>ok</foo><p>and ; <bar>ok</bar><bar>ok</bar>.</p>

The command `\lastkern` gives access to a read-only variable,
that contains a dimension. The location pointed to is never modified by
*Tralics*, so the `\the\lastkern` always expands to
`0pt`. On the other hand `\lastkern=3pt` provokes an
error before reading the equals sign.
See `\lastpenalty` below.

According to TeX:
You can't use `\lastpenalty' in vertical mode.
You can't use `\lastpenalty' in horizontal mode.
You can't use `\lastpenalty' in math mode.
In fact, you can only consult the value. If the last token on the current list
is a penalty token, `\the\lastpenalty` returns the value; otherwise
it returns 0. Since *Tralics* does not inserts penalties in
(the equivalent of) its current list, the result is always the integer `0`.

The command `\lastskip` gives access to a read-only variable,
that contains a glue. The location pointed to is never modified by
*Tralics*, so the `\the\lastskip` always expands to
`0pt`. On the other hand `\lastskip=3pt` provokes an
error before reading the equals sign.

See `\lastpenalty` above.

Translation of `\latex[foo]{bar}` is `foo`.

Translation of `\latex{foo}{bar}` is `foo`.

This is the logo of the latex2html interpreter, defined
as `\textup{\LaTeX2\texttt{HTML}}`.

The `\LaTeX` command translates to
`<LaTeX>`, and `\LaTeXe` is the same as
`\LaTeX2$\epsilon$`.

The environments `latexonly` and `htmlonly` are provided
by the html package as alternatives, when converting a document to dvi or
HTML. The first environment behaves like the identity, the second as a comment.
Example

\def\ok{4} \leavevmode \begin{rawxml} 1 \end{rawxml} \begin{latexonly}\def\ok{2}\ok\end{latexonly} \begin{htmlonly} \def\ok{ ? \end{htmlonly} \begin{comment} \def\ok{ ? \end{comment} \begin{rawhtml} <p>\def\ok{ ?</p> \end{rawhtml} \begin{LaTeXonly} \def\ok{ ? \end{LaTeXonly} \begin{xmlonly}\def\ok{3}\ok\end{xmlonly} \ok

The translation should be equivalent to `1 2 3 4`
(the digit one being written as `1`).

The `LaTeXonly` environment is opposed to the `xmlonly`
environment. Since the translator produces XML, the content of
the `LaTeXonly` environment is ignored. This environment behaves
like the `comment` environment.

For an example, see the description of the
`latexonly` environment.

The `\lbrack` command is equivalent to (in fact, expands to)
an opening bracket `[`.

See also description of the
`\vert` command.

The `\lbrace` command is equivalent to an opening brace `\{`.

See also description of the
`\vert` command.

When you say `\lccode13 12`, you change the lowercase code
of the character number 13 to the value 12.
Both integers must be valid character codes.
TeX uses
this for its hyphenation algorithm: a letter is part of a word, only if
its `\lccode` is not zero. On the other hand, the
`\lowercase` command replaces, in the token list given as argument,
every character X by the character Y, provided that `\lccode X` is
Y, and Y is not zero; all other tokens are left unchanged.

A character code is an integer between 0 and N-1, where N=256 in TeX and in
old versions of *Tralics*; it is now 65536.
In *Tralics*, `\lccode` and `\uccode` are defined for
all letters of iso-8859-1 (with, and without accents), these are characters
with code less than 256 (for all other characters, `\lccode`
and `\uccode` are zero).

See *scanint* for details of how
numbers are read.
See `\uppercase`.
for examples of use.

The `\lceil` (left ceiling) command is valid only in math mode.
It can be used as a delimiter:
`<mo>⌈</mo>`,
(Unicode U+2308, ⌈).
See also description of the
`\vert` command.

The `\ldots` command is valid in math mode.
It generates a miscellaneous symbol:
`<mo>...</mo>`.
*Tralics* recognizes the following miscellaneous symbols.

$\ldots \prime \exists \Diamond \top \bot \mho \cdots \forall \nabla \imath \flat \clubsuit \Re \vdots \infty \surd \jmath \natural \diamondsuit \Im \ddots \hbar \square \ell \sharp \heartsuit \angle \aleph \emptyset \triangle \neg \wp \spadesuit \partial$

The XML result is *shown here*.
All these operators are from Table 8.7 of the Latex Companion.
The `\Box` command is not yet implemented (but `\square`
produces the same effect).
(see also here).

The `\ldots` command is also valid outside math mode, see
the `\qquad` command.

The `\le` command is valid only in math mode.
It generates a relation symbol:
`<mo>≤</mo>`.
*Tralics* recognizes the following relations:

$\le \leq \succ \simeq \parallel \subseteq \sqsubset \doteq \ge \geq \sim \mid \subset \subseteq \ne \neq \frown \vdash \equiv \perp \ll \supset \cong \smile \in \dashv \models \preceq \gg \approx \Join \sqsubseteq \ni \prec \succeq \asymp \bowtie \sqsupseteq \propto$

The XML result is *shown here*.
All these operators are from Table 8.5 of the Latex Companion.
(see also here).

The `\leaders` commands reads a box and names it `leaders'.
See \xleaders for details.

The `\leadsto` command is valid only in math mode.
It generates
`<mo>⇝</mo>`,
(Unicode U+21DD, ⇝).

The effect of this command is to leave vertical mode, and to enter horizontal
mode. Thus, if the mode is vmode (typically, outside any paragraph),
a new paragraph is started. This paragraph may be flushed left, flushed right,
or centered; but if nothing special has been said, a
`noindent='true'` slot is added to the attribute list of the
`<p>` element.

This command is followed by a delim, then
math mode material,
then `\right` and delim; it is used
inside a math formula. A group is started,
the math mode material (the longest list,
balanced wrt braces and groups, including \left/\right)
is translated, the result is put in a
`<mfence>` element, that has as attributes
`open' and `close' the values of the first and last delimiter.

Here delim is a
filler (optional space or `\relax`)
followed by `\delimiter` 27-bit number or
letter or
otherchar (a character of
catcode 11 or 12 whose 24-bit `\delcode` value will be used).
From these numbers two pairs *(a,f)* and *(b,g)* consisting of
a 8-bit character number and a 4-bit family number are created. These are
used to construct a variable-size character. Note that commands
like `\overwithdelims` also read
two delim, so
`$a\abovewithdelims\relax.\relax..2ptb$` is a valid math formula
translated by *Tralics* as `$a\above.2ptb$`

For instance `\lbrace` is defined as
`\delimiter"4266308`
which gives a first pair: character 102 for
family 2, and a second pair: character 8 in family 3.
Now, font cmex10 (`\texfont3` in PlainTeX) contains a character
at position O10 (read: octal-10),
that has a nextlarger at O156, that has a nextlarger at O32,
that has a nextlarger at O50, that has a nextlarger at O70,
that is defined to be a varchar top=O70,
mid=O74, bot=O72 and rep=O76 (a varchar is a character of variable height,
formed by a top, a rep, a mid, a rep and a bot; instead of a single rep, a
variable number of reps can be used).

This mechanism is not implemented in *Tralics*.
In particular `\delimiter` provokes an error and reads a number.
You may use the following characters: `()[]|<>`
or the following commands:`\rbrace \lbrace \{ \} \rangle \langle
\rceil \lceil \rfloor \lfloor \vert \Vert`. These are defined
by PlainTeX. A dot means an empty delimiter.

You can also use
`\lmoustache \rmoustache \uparrow \downarrow \updownarraow
\Uparrow \Downarrow \Updownarrow \backslash \lgroup \rgroup `.
These were not implemented in earlier *Tralics* versions:
`\arrowvert \Arrowvert \bracevert / \backslash`.

For an example, see the `\vert`
command. Here is another example:

\def\kernel{\frac{x^1_2}{y^3_4}} \def\test{ \left\lmoustache\left\uparrow\left\Uparrow\left\updownarrow\left\lgroup \kernel \right\rgroup\right\Updownarrow\right\Downarrow\right\downarrow\right\rmoustache} $\test$ $\let\left\relax\let\right\relax \test$ $\def\kernel{\int_0^{\frac{x^1_2}{y^3_4}}} \test$

The translatiton is

<formula type='inline'> <math xmlns='http://www.w3.org/1998/Math/MathML'> <mfenced open='⎰' close='⎱'> <mfenced open='↑' close='↓'> <mfenced open='⇑' close='⇓'> <mfenced open='↕' close='⇕'> <mfenced open='〔' close='〕'> <mfrac> <msubsup><mi>x</mi> <mn>2</mn> <mn>1</mn> </msubsup> <msubsup><mi>y</mi> <mn>4</mn> <mn>3</mn> </msubsup> </mfrac> </mfenced> </mfenced> </mfenced> </mfenced> </mfenced> </math> </formula> <formula type='inline'> <math xmlns='http://www.w3.org/1998/Math/MathML'> <mrow> <mo>⎰</mo><mo>↑</mo><mo>⇑</mo> <mo>↕</mo><mo>〔</mo> <mfrac> <msubsup><mi>x</mi> <mn>2</mn> <mn>1</mn> </msubsup> <msubsup><mi>y</mi> <mn>4</mn> <mn>3</mn> </msubsup> </mfrac> <mo>〕</mo><mo>⇕</mo><mo>⇓</mo> <mo>↓</mo><mo>⎱</mo> </mrow> </math> </formula> <formula type='inline'> <math xmlns='http://www.w3.org/1998/Math/MathML'> <mfenced open='⎰' close='⎱'> <mfenced open='↑' close='↓'> <mfenced open='⇑' close='⇓'> <mfenced open='↕' close='⇕'> <mfenced open='〔' close='〕'> <msubsup><mo>∫</mo> <mn>0</mn> <mfrac> <msubsup><mi>x</mi> <mn>2</mn> <mn>1</mn> </msubsup> <msubsup><mi>y</mi> <mn>4</mn> <mn>3</mn> </msubsup> </mfrac> </msubsup> </mfenced> </mfenced> </mfenced> </mfenced> </mfenced> </math> </formula>

Preview: (see also here)

The `\leftarrow` command is valid only in math mode.
It generates an arrow pointing to the left:
`<mo>←</mo>`.
(Unicode U+2190, ←)
*Tralics* recognizes the following arrows:

$\leftarrow\longleftarrow \Leftarrow \Longleftarrow \rightarrow \longrightarrow \Rightarrow \Longrightarrow \leftrightarrow \Leftrightarrow \longleftrightarrow\Longleftrightarrow \mapsto \longmapsto \hookleftarrow \hookrightarrow \leftharpoondown \leftharpoonup \rightharpoondown \rightharpoonup \uparrow \Uparrow \updownarrow \Updownarrow \downarrow \Downarrow \nearrow \searrow \swarrow \nwarrow $

The XML result is *shown here*.
All these operators are from Table 8.6 of the Latex Companion.
(see also here)

The `\Leftarrow` command is valid only in math mode.
It generates an double-stroke arrow pointing to the left:
`<mo>⇐</mo>`
(Unicode U+21D0, ⇐).
See description of the `\leftarrow` command.

The `\leftarrowtail` command is valid only in math mode.
It generates
`<mo>↢</mo>`
(Unicode U+21A2, ↢)

The `\leftarrowtriangle` command is valid only in math mode.
It generates `<mo>⇽</mo>`
(Unicode U+21FD, ⇽).

The `\leftharpoondown` command is valid only in math mode.
It generates an arrow that points to the left, with only lower part of the arrow-point:
`<mo>↽</mo>`
(Unicode U+21BD, ↽).
See description of the `\leftarrow` command.

The `\leftharpoonup` command is valid only in math mode.
It generates an arrow pointing to the left, with only the upper part of the arrow-point:
`<mo>↼</mo>`
(Unicode U+21BC, ↼).
See description of the `\leftarrow` command.

When you say `\lefthyphenmin=77`,
then TeX accepts to hyphenate a word only if there
are at least 77 characters to the left of the hyphen.
*Tralics* hyphenates nothing.

(See *scanint* for details of argument scanning).

The `\leftleftarrows` command is valid only in math mode.
It generates
`<mo>⇇</mo>`
(Unicode U+21C7, ⇇)

Translation of `\leftline{foo}` is
`<line rend='left'>foo</line>`.

See also description of the `\centerline` command.

This contains the value of the left margin. Not used by *Tralics*.

This command contains the value that should be put into
`\leftmargin` inside a list environment (at level 1, 2, 3, 4, 5,
and 6, respectively). Not used by *Tralics*.

The `\leftrightarrow` command is valid only in math mode.
It generates an arrow that points to the left and the right:
`<mo>↔</mo>`
(Unicode U+2194, ↔).
See description of the `\leftarrow` command.

The `\Leftrightarrow` command is valid only in math mode.
It generates an arrow:
`<mo>⇔</mo>`
(Unicode U+21D4, ⇔).
See description of the `\leftarrow` command.

The `\leftrightarrows` command is valid only in math mode.
It generates
`<mo>⇆</mo>`
(Unicode U+21C6, ⇆).

The `\leftrightarrowtriangle` command is valid only in math mode.
It generates
`<mo>⇿</mo>`
(Unicode U+21FF, ⇿).

The `\leftrightharpoons` command is valid only in math mode.
It generates
`<mo>⇋</mo>`
(Unicode U+21CB, ⇋).

The `\leftrightsquigarrow` command is valid only in math mode.
It generates
`<mo>↭</mo>`
(Unicode U+21AD, ↭).

You can say `\leftskip=10pt plus 2pt minus 3pt`.
This explains to TeX that it should put
10pt (maybe up to 2pt more, maybe up to 3pt less) of glue on the
start of each line. Unused by *Tralics* (you should use
environments like `quote` or `center` instead).

(See *scanglue* for details of argument scanning).

The `\leftslice` command is valid only in math mode.
It generates
`<mo>⪦</mo>`
(Unicode U+2AA6, ⪦).

The `\leftthreetimes` command is valid only in math mode.
It generates
`<mo>⋋</mo>`
(Unicode U+22CB, ⋋).

Inside an if-then-else construct, you can use a test like
`\lengthtest{\parindent<1cm}`. This yields true if
the current value of `\parindent` is less than one cm.

See `\ifthenelse` for details.

The `\leq` command is valid only in math mode.
It is equivalent to `\le`.
It generates a relation symbol:
`<mo>≤</mo>`
(Unicode U+2264, ≤).
See description of the `\le` command.

Produces an equation number on the left.
See `\eqno`.

The `\leqq` is valid only in math mode; it produces
`<mo>≦</mo>`
(Unicode U+2266, ≦).

The `\leqslant` is valid only in math mode; it is a variant
of the less-or-equal symbol:
`<mo>⩽</mo>`
(Unicode U+2A7D, ⩽).
See also description of the
`\smallint` command.

The `\lessapprox` is valid only in math mode; it produces
`<mo>⪅</mo>`
(Unicode U+2A85, ⪅).

The `\lessdot` is valid only in math mode; it produces
`<mo>⋖</mo>`
(Unicode U+22D6, ⋖).

The `\lesseqgtr` is valid only in math mode; it produces
`<mo>⋚</mo>`
(Unicode U+22DA, ⋚).

The `\lesseqqgtr` is valid only in math mode; it produces
`<mo>⪋</mo>`
(Unicode U+2A8B, ⪋).

The `\lessgtr` is valid only in math mode; it produces
`<mo>≶</mo>`
(Unicode U+2276, ≶).

The `\lesssim` is valid only in math mode; it produces
`<mo>≲</mo>`
(Unicode U+2272, ≲).

After `\let`, there is a control
sequence followed by equals
followed by one optional space
followed by token (see
*here* the syntax).
The effect of `\let\foo\bar` (or `\let\foo= \bar`)
is to make `\foo` equivalent to `\bar`, concerning
evaluation. Instead of `\foo`, an active character is allowed.
If the token is a control sequence or
an active character, its value is copied into the first token. For
instance, since `\bar` is valid in math mode only,
then `\foo` becomes a math-mode only command. An
assignment like `\let\foo\undefined` makes
probably `\foo` undefined.
Example:

{\def\B#1{a} \let \A\B \show\A} {\catcode `A=13 \def A{b} \let\A A \show\A} {\catcode `A=13 \def\B#1{c} \let A\B \showA} {\catcode `A=13 \let A~ \showA}

You will see this on the terminal:

\A=macro: #1->a. \A=macro: ->b. A=macro: #1->c. A=macro: ->\nobreakspace .

In the case where `\let\foo` is followed by a character,
then `\foo` will act like this character (same catcode, same value).
Example:

{\catcode `A=13 \letA=1 \showA} {\let\sp=^ \show\sp} {\let\egroup=} \show\egroup}

You will see this:

A=the character 1. \sp=superscript character ^. \egroup=end-group character }.

Note the following facts: In the example above, A is an active
character, but cannot be expanded. Thus `\count0=0A1` will put 0
in the counter, and `\showA` is a list of two tokens.
On the other hand, `\sp` is always interpreted as superscript
character (but `\sp\sp ab` is not the same as `^^ab`).
And `\egroup` is evaluated like a closing brace
(a token list contains always as many open braces as close braces,
but you can put any number of `\egroup` tokens as you like;
it is only when the token is evaluated that its value is considered;
exception: when arguments are read, the value of each token is considered
to see if it is an `\outer` token, so a token can be
non-outer when read and outer when evaluated).

You can say `\global\let`, this makes the assignment global
(it is local otherwise)
(unless `\globaldefs` is strange).

The `\lfloor` (left floor) command is valid only in math mode.
It can be used as a delimiter
`<mo>⌊</mo>`,
(Unicode U+230A, ⌊).
See also description of the
`\vert` command.

The `\lfoot` command is valid only if the fancyvrb
package is loaded. It takes an optional argument A, and a required argument B
(the default value of A is B). The effect is to define the left part of the
page footer to A for even pages, to B for odd pages.

For more information, see documentation of
`\fancyhf`.

The `\lg` command is valid only in math mode. Its translation is
a math operator of the same name:
`<mo form='prefix'>lg</mo>`.

For an example see the
`\log` command.

The `\lgroup` (left group) command is valid only in math mode.
It can be used as a delimiter
`<mo>〔</mo>`,
(Unicode U+3014, 〔).

The `\lhd` command is valid only in math mode.
It produces
`<mo>⊲</mo>`,
(Unicode U+22B2, ⊲).

The `\lhead` command is valid only if the
fancyvrb
package is loaded. It takes an optional argument A, and a required argument B
(the default value of A is B). The effect is to define the left part of the
page header to A for even pages, to B for odd pages.

For more information, see documentation of
`\fancyhf`.

The `\lightning` command is valid only in math mode.
It produces
`<mo>☇</mo>`,
(Unicode U+2607, ☇).

The `\lim` command is valid only in math mode. Its translation is
a math operator of the same name:
`<mo form='prefix' movablelimits='true'>lim</mo>`.
For an example see the
`\log` command.

The `\liminf` command is valid only in math mode. Its translation is
a math operator of the same name:
`<mo form='prefix' movablelimits='true'>lim inf</mo>`.
For an example see the
`\log` command.

The `\limits` command is valid only in math mode.
It describes how indices should be positioned.
See `\nolimits` for details.
For details see `\mathord`.

The `\limsup` command is valid only in math mode. Its translation is
a math operator of the same name:
`<mo form='prefix' movablelimits='true'>lim sup</mo>`.
For an example see the
`\log` command.

You say `\line(dx,dy){length}` in order to put a straight line
into a picture. In general,
the `\line` is the argument of a `\put(x,y){}` command,
and the `(x,y)` position indicated the starting point of the line
segment. Quantities `dx` and `dy` should be small
integers (at most six in magnitude) and coprime (in fact, *Tralics* really
does not care). If `dx=0`, then `length` is the length
of the line; otherwise, `length` is the length of the horizontal
projection of the line.

See description of the
`picture` environment for the syntax of the
`(dx,dy)` part, and some examples.

The `\linebreak` command takes an optional argument.
It is used to favor a line break at this position in the paragraph.
This command is ignored in *Tralics*.

When you say `\linepenalty=13`, then TeX will use
13 for the line penalty when it computes demerits. This parameter is not used
in *Tralics*.

(See *scanint* for details of argument scanning).

You can say `\lineskip=10pt plus 2pt minus 3pt`.
This explains to TeX that it should put
10pt (maybe up to 2pt more, maybe up to 3pt less) of glue between
two consecutive lines in a paragraph.
(if`\lineskiplimit` says so).
Unused by *Tralics*.

(See *scanglue* for details of argument scanning).

You can say `\lineskiplimit=1.5in`, after that TeX
computes the vertical skip between two lines of text as follows:
the baselines of the boxes are separated by `\baselineskip`,
but is this would make the distance between the bottom of one box and the
top of the other less than \`lineskiplimit`, then `\lineskip` is used as interline glue.
Ignored by *Tralics*. Typical values in LaTeX are:
`\baselineskip=12pt`, `\lineskip=1pt`,
`lineskiplimit=0pt`.

(See *scandimen* for details of argument scanning).

The translation of `\linethickness{0.7mm}` could be
`<pic-linethickness size='0.7mm'/>`.

For an example of use, see
\arc.

This dimension is unused by *Tralics*.
Initial value is 427pt in *Tralics* (nearly 15cm), the same as `\textwidth`.

Using `\listfiles` has as side effect that, at the end of the
run, *Tralics* will print some information about all files (gathered by
`\ProvidesClass`, `\ProvidesPackage` and
`\ProvidesFile`) to the terminal and transcript file,
for instance

*File List* article.clt 2006/08/19 v1.0 article document class for Tralics std.clt 2006/08/19 v1.0 Standard LaTeX document class, for Tralics comma.plt 2007/12/29 v1.0 Insert commas every three digits (DPC) checkend.plt 2007/12/14 v1.0 Checks for end environments bbding.plt 2007/12/14 v1.0 Dingbats symbols abstract.plt 2007/12/09 v1.1 configurable abstracts keyval.plt 2007/12/08 v1.1 key=value parser for Tralics (DPC) html.plt 2007/12/05 v1.0 Hypertext commands for latex2html nopageno.plt 2007/12/31 v1.0 no page numbers dummy.xml_in 2007/12/23 v1.0 Dummy file for Tralics ***********

These two commands terminate the current paragraph
and insert a `<listoffigures/>` or
a `<listoftables/>` element. For an example
see `\tableofcontents` command.

Quantity used by LaTeX, for paragraph indentation of all paragraphs in a
list that do not start with `\item`; unused by *Tralics*.

The `\ll` command is valid only in math mode.
It generates a relation symbol:
`<mo>≪</mo>`
(Unicode U+226A, ≪).
See description of the `\le` command.

Translation of `\llap{foo}` is
`<line rend='llap'>foo</line>`

See also description of the `\centerline` command.

The `\llbracket` command is valid only in math mode. Its translation is
`<mo>⟦</mo>`.
(Unicode U+310A, 〚).

The `\Lleftarrow` command is valid only in math mode.
It generates an arrow pointing to the left:
`<mo>⇚</mo>`.
(Unicode U+21DA, ⇚)

The `\lll` command is valid only in math mode. Its translation is
`<mo>⋘</mo>`.
(Unicode U+22D8, ⋘).

The `\llless` command is valid only in math mode. Its translation is
`<mo>⋘</mo>`.
(Unicode U+22D8, ⋘).

The `\llparenthesis` command is valid only in math mode. Its translation is
`<mo>⦇</mo>`.
(Unicode U+2987, ⦇).

The `\lmoustache` command is valid only in math mode. Its translation is
`<mo>⎰</mo>`.
(Unicode U+23B0, ⎰).

The `\ln` command is valid only in math mode. Its translation is
a math operator of the same name:
`<mo form='prefix'>ln</mo>`.

For an example see the
`\log` command.

The `\lnapprox` command is valid only in math mode. Its translation is
`<mo>⪉</mo>`.
(Unicode U+2A89, ⪉).

The `\lneq` command is valid only in math mode. Its translation is
`<mo>⪇</mo>`.
(Unicode U+2A87, ⪇).

The `\lneqq` command is valid only in math mode. Its translation is
`<mo>≨</mo>`.
(Unicode U+2268, ≨).

The `\lnot` command (logical not) is equivalent to
`\neg` command.
(Unicode U+AC, ¬).

See also description of the
`\smallint` command.

The `\lnsim` command is valid only in math mode. Its translation is
`<mo>⋦</mo>`.
(Unicode U+22E6, ⋦).

This is like
`\documentclass`,
except that in can be used anywhere (in general from a class file), can be
used more than once, and unused options do not become global options.

This is like
`\RequirePackageWithOptions`, but is used in a class rather
than a package. It loads the class file defined by the argument, using current
options.

The `\log` command is valid only in math mode. Its translation is
a math operator of the same name
`<mo form='prefix'>log</mo>`.
Here is the list of all log-like operators:

```
$$\arccos^2 (x),\, \arcsin^2(x),\, \arctan^2(x),\, \arg^2(x),\,
\cos^2(x),\, \cosh^2(x) ,\, \cot^2(x)$$
$$\coth^2(x),\, \csc^2(x),\, \deg^2(x),\, \dim^2(x),\, \exp^2(x),\,
\hom^2(x),\, \ker^2(x) ,\, \lg^2(x)$$
$$\ln^2(x),\, \log^2(x),\, \Pr^2(x),\, \sec^2(x),\, \sin^2(x)
,\,\sinh^2(x),\, \tan^2(x),\, \tanh^2(x) $$
$$ %These are declared m
\det_{x=1},\, \gcd_{x=1},\, \inf_{x=1},\, \injlim_{x=1},\, \lim_{x=1},\,
\liminf_{x=1},\,\limsup_{x=1},\,\max_{x=1},\, \min_{x=1},\,
\projlim_{x=1},\, \sup_{x=1}
$$
```

The XML result is *shown here*.
(see also here).
All commands are listed in Table 8.9 of the Latex Companion.

This command is ignored by *Tralics*; in LaTeX it is a piece
of `\tracingall`, in particular it sets all parameters so that
boxes are fully displayed when printed.
You should say `\tracingall` in *Tralics*.

You can say `\long\def\foo{...}`. This defines the `\foo`
command to be `\long`, said otherwise, `\par` tokens
are allowed inside the argument. In the case of
`\newcommand\foo{...}` the result is a `\long` command,
and `\newcommand*\foo{...}` produces a non-`\long` one.
A test done by `\ifx` is false if one command is `\long`
and the other is not.
In old versions *Tralics*, the behavior of the commands did not depend on the flag.
If the source file contains

\def\tla#1{#1} \long\def\tlb#1{#1} \outer\def\tlc#1{#1} \long\outer\def\tld#1{#1} \newcommand\tle[1]{#1} \newcommand*\tlf[1]{#1} \show\tla \show\tlb \show\tlc \show\tld \show\tle \show\tlf

then *Tralics* will print this

\tla=macro: #1->#1. \tlb=\long macro: #1->#1. \tlc=\outer macro: #1->#1. \tld=\long\outer macro: #1->#1. \tle=\long macro: #1->#1. \tlf=macro: #1->#1.

The next example shows the difference between a \long and a non-\long command.

> \newcommand\foo[1]{} \foo{\par} > \renewcommand*\foo[1]{} \foo{\par} Error signaled at line 5: Runaway argument? Paragraph ended while scanning an argument of \foo.

The `\longleftarrow` command is valid only in math mode.
It generates an arrow pointing to the left:
`<mo>⟵</mo>`
(Unicode U+27F5, ⟵).
See description of the `\leftarrow` command.

The `\Longleftarrow` command is valid only in math mode.
It generates a double stroke long arrow pointing to the left:
`<mo>⟸</mo>`
(Unicode U+27F8, ⟸).
See description of the `\leftarrow` command.

The `\longleftrightarrow` command is valid only in math mode.
It generates an arrow pointing to the left and the right:
`<mo>⟷</mo>`
(Unicode U+27F7, ⟷).
See description of the `\leftarrow` command.

The `\Longleftrightarrow` command is valid only in math mode.
It generates a long doublestroke arrow pointing to the left and the right:
`<mo>⟺</mo>`
(Unicode U+27FA, ⟺).
See description of the `\leftarrow` command.

The `\longmapsfrom` command is valid only in math mode.
It generates an arrow:
`<mo>⟻</mo>`
(Unicode U+27FB, ⟻).

The `\Longmapsfrom` command is valid only in math mode.
It generates an arrow:
`<mo>⟽</mo>`
(Unicode U+27FD, ⟽).

The `\Longmapsto` command is valid only in math mode.
It generates an arrow:
`<mo>⟾</mo>`
(Unicode U+27FE, ⟾).

The `\longmapsto` command is valid only in math mode.
It generates an arrow:
`<mo>⟼</mo>`
(Unicode U+27FC, ⟼).
See description of the `\leftarrow` command.

The `\longrightarrow` command is valid only in math mode.
It generates a long arrow pointing to the right:
`<mo>⟶</mo>`
(Unicode U+27F6, ⟶).
See description of the `\leftarrow` command.

The `\Longrightarrow` command is valid only in math mode.
It generates a long double stroke arrow pointing to the right:
`<mo>⟹</mo>`
(Unicode U+27F9, ⟹)
See description of the `\leftarrow` command.

The `\loop` command can be defined as

% Plain tex definition \def\loop#1\repeat{\def\body{#1}\iterate} \def\iterate{\body \let\next\iterate \else\let\next\relax\fi \next} \let\repeat=\fi % this makes \loop...\if...\repeat skippable % Latex definition \def\loop#1\repeat{\def\iterate{#1\relax\expandafter\iterate\fi}% \iterate \let\iterate\relax} \let\repeat\fi

The definition of *Tralics* is the same as the definition of
LaTeX, but the `\iterate` token used is
private (different from all commands that the user can enter).

You say `\loop alpha \if... beta \repeat`, where
`alpha` and `beta` are any sequences of commands
(if they contain a `\repeat` token, it must be hidden in braces)
and where `\if...` is any conditional test, without a matching
`\fi`. TeX will first do `alpha`,
then if the condition is true, TeX will do `beta`
and repeat the whole process again starting with `alpha`.
If the condition ever turns out to be false, the loop will stop.

Consider

\def\looptest#1#2#3{\count0=#1\relax \loop #2\advance\count0by-1 \ifnum\count0>0 #3\repeat}

Here the first argument of `\looptest` will be put in count
register 0,
the third argument is `beta`,
the condition is `\ifnum\count0>0 `
the `alpha` is formed of the second argument and
a piece of code that decrements the counter. Said otherwise, if the first
argument is 5, then the second argument will be executed 5 times, and the
third argument 4 times. Example:

```
\def\looptest#1#2#3{\count0=#1\relax \loop #2\advance\count0by-1
\ifnum\count0>0 #3\repeat}
\def\res{}
\looptest5{\edef\res{\the\count0 a\res}}{\edef\res{b\res}}
\testeq\res{1ab2ab3ab4ab5a}%The command \testeq checks that its arguments are equal
```

See also *commented example*.

The `\looparrowleft`
command is valid only in math mode. It generates
`<mo>↫</mo>`
(Unicode U+21AB, ↫).

The `\looparrowright`
command is valid only in math mode. It generates
`<mo>↬</mo>`
(Unicode U+21AC, ↬).

When you say `\looseness=90`, then TeX will
try to make the current paragraph 90 lines longer than its optimum length;
the badness of each individual line cannot exceed the given tolerance.
Unused by *Tralics*.

(See *scanint* for details of argument scanning).

The `\lor` command (logical or) is equivalent to
`\vee` command:
`<mo>∨</mo>`
(Unicode U+2228, ∨).
See also description of the
`\smallint` command.

This lowers a box.
See `\moveleft`.

The `\lowercase` command converts its argument to lowercase.
For instance `\lowercase{Foo+\Bar}` is equivalent to
`foo+\Bar`.
(See `\uppercase`.)
(see scantoks for the syntax.)

The `\lozenge` command is valid in math mode only;
it produces the symbol `<mo>◊</mo>`
(Unicode U+25CA, ◊).

The `\lq` command expands to a left quote (back-quote).
You can say ``\lq\foo\rq'` or ```\foo''`,
the result is the same.

This command is defined by compatibility with the french package.
The translation of `\lsc{Abc}` is
`<hi rend='sc'>Abc</hi>`

The `\Lsh` command is valid in math mode only;
it produces the symbol `<mo>↰</mo>`
(Unicode U+21B0, ↰).

The `\ltimes` command is valid in math mode only;
it produces the symbol `<mo>⋉</mo>`
(Unicode U+22C9, ⋉).

The `\lvert` command is valid in math mode only;
it is a left delimiter associated to
`\vert`;
it produces
the symbol `<mo>|</mo>`
(Unicode U+7C, |).

The `\lVert` command is valid in math mode only;
it is a left delimiter associated to
`\Vert`;
it produces
the symbol `<mo>∥</mo>`
(Unicode U+2225, ∥).

back to home page © INRIA 2003-2005, 2006 Last modified $Date: 2015/12/01 17:24:42 $