algorithm2e.sty — package for algorithms
release 5.2

boxed:

to have algorithms enclosed in a box.

boxruled:

surround algorithm by a box, puts caption above and add a line after caption.

ruled:

to have algorithms with a line at the top and the bottom. Note that the caption is not centered under the algorithm anymore but is set at the beginning of the algorithm.

algoruled:

as above but with extra spaces after the rules.

tworuled:

tworuled acts like ruled but doesn’t put a line after the title.

plain:

the default, with no feature.

algochapter:

algorithms are numbered within chapter numbers.

algosection:

(default) algorithms are numbered within section numbers.

algopart:

algorithms are numbered within part numbers.

procnumbered:

makes the procedure and function to be numbered as algorithm.

figure:

algorithms are put in classical figures and so are numbered as figures and putted in the $\backslash$listoffigures.

dotocloa

adds an entry in the toc for the list of algorithms. This option loads package tocbibind if not already done and so list of figures and list of tables are also added in the toc. If you want to control which ones of the lists will be added in the toc, please load package tocbibind before package algorithm and give it the options you want.

noalgohanging

By default, long statement are indented on subsequent lines (see to know how to control length of indentation); with this option you get old behavior and lines are no more indented.

hangingcomment

Comment that are alone on a line (not side comment) are not driven by algorithm hanging: subsequent lines of long comments are indented according to width of start comment marker. With this option, comment are indented like normal statement.

opthanginginout

As for comment, by default, in/out keywords and input keywords (defined by $\backslash$SetKwInOut or $\backslash$SetKwInput) are not indented by algorithm hangindent. They are indented according to width of input keyword. If you want that these keywords acts like other statements, use this option.

longend

the end keyword are longer and different for each macro. For example endif for a if-then-else macro.

shortend

the “end keyword” of the macros is just end (default).

noend

the “end keyword” of the macros is not printed.

scright (default)

right justified side comments (side comments are flushed to the right)

scleft

left justified side comments (side comments are put right after the code line)

fillcomment (default)

end mark of comment is flushed to the right so comments fill all the width of text

nofillcomment

end mark of comment is put right after the comment

linesnumbered:

lines of the algorithms are numbered except for comments and input/output (KwInput and KwInOut). You must use $\backslash$nllabel{label} to label thoses lines.

linesnumberedhidden:

lines of the algorithms are numbered as linesnumbered but numbers are not shown. $\backslash$ShowLn and $\backslash$ShowLnLabel{label} show the number on line they are put.

commentsnumbered:

makes comments be numbered if numbering is active.

inoutnumbered:

makes data input/output be numbered if numbering is active.

rightnl:

put lines numbers to the right of the algorithm instead of left.

resetcount

the line numbers are reset to 0 at the beginning of each algorithm (by default).

noresetcount

the contreverse of the precedent. To reset the line counter to 0 do:
$\backslash$setcounter{AlgoLine}{0}

algonl

the line numbers will be prefixed with the number of the current algorithm. Take care to set the caption of the algorithm at the beginning of the environnement, else you will have the precedent algorithm number as the current one.

titlenumbered:

$\backslash$TitleOfAlgo{title} prints Algorithm n: thetitle where n is the counter of the algo.
Beware: $\backslash$TitleOfAlgo don’t insert an entry in the list of algorithms. So do not use $\backslash$TitleOfAlgo with a caption. Both increment the counter of the algorithms.

titlenotnumbered (default)

the macro $\backslash$TitleOfAlgo{title} doesn’t number the algorithm.

Algorithm environment are float environment. So you can use classical $\backslash$caption, $\backslash$listofalgorithms{,} $\backslash$label. If you want a title but not a caption (for example to not add an enter in the list of algorithm) you have $\backslash$TitleOfAlgo{.} And if you want to name your algorithm and not number it, you can change the reference of it by using $\backslash$SetAlgoRefName{ref}:

$\backslash$caption{thetitle}

works as classical caption of figures. It inserts an entry in the list of algorithms. Should be the standard way to put title of algorithms.

$\backslash$TitleOfAlgo{thetitle}

prints: “Algorithm n^∘: thetitle” in the typography and size defined by $\backslash$SetTitleSty. Puts a vertical space below.
Beware: $\backslash$TitleOfAlgo doesn’t insert an entry in the list of algorithms. So don’t use $\backslash$TitleOfAlgo with $\backslash$caption. Both increment the counter of the algorithms.
note:with the french option prints Algorithme n^∘:

$\backslash$listofalgorithms

inserts the list of all algorithms having a caption.

$\backslash$SetAlgoRefName{ref}

which changes the default ref (number of the algorithm) by the name given in parameter. For example $\backslash$SetAlgoRefName{QXY} sets reference of the algorithm to QXY. If you label your algorithm and reference it, you will get QXY. On the same manner, entry in the list of algorithm will name it QXY.

$\backslash$SetAlgoRefRelativeSize{relative integer}

which sets the output size of reference in list of algorithms for references set by $\backslash$SetAlgoRefName. The default is $\backslash$SetAlgoRefRelativeSize{-2}.

The following commands help you to define the style and the layout of the caption:

$\backslash$SetAlgoCaptionSeparator{sep}

which sets the separator between title of algorithms (Algorithm 1) and the name of the algorithm. By default it’s ’:’ and caption looks like ”Algorithm 2: name” but now you can change it by using for example which will give ”Algorithm 3. name”.

$\backslash$SetCustomAlgoRuledWidth{length}

set a custom ruled width of ruled and algoruled options ; note that by the moment you use this macro, rules will have this fixed length: this can cause strange behavior in multicolumn mode or other layout that change the line width.

$\backslash$AlCapSkip

is the dimension of the distance between algorithm body and caption in plain and boxed mode. You can change by hands or by using $\backslash$SetAlCapSkip{0ex}.

$\backslash$SetAlCapSkip{length}

sets the lenght of $\backslash$AlCapSkip) dimension between algorithm body and caption.

$\backslash$SetAlCapHSkip{length}

sets the horizontal skip before Algorithm: in caption when used in ruled algorithm.

$\backslash$SetTitleSty{type style}{type size}

sets the typography and size of the titles defined with the macro $\backslash$TitleOfAlgo{} (not with $\backslash$caption).

$\backslash$NoCaptionOfAlgo

doesn’t print Algorithm and its number in the caption. This macros is ONLY active for “algoruled” or “ruled” algorithms and for the next algorithm. For example, it is useful when the algorithm just describes a function and you only want to display the name of the function in the caption.

$\backslash$RestoreCaptionOfAlgo

restores correct captions that was corrupted by a $\backslash$NoCaptionOfAlgo macro.

$\backslash$SetAlgoCaptionLayout{style}

sets global style of the caption; style must be the name of a macro taking one argument (the text of the caption). Examples below show how to use it:

• •

  $\backslash$SetAlgoCaptionLayout{centerline} to have centered caption;

• •

  $\backslash$SetAlgoCaptionLayout{textbf} to have bold caption.

If you want to apply two styles in the same time, such as centered bold, you have to define you own macro and then use $\backslash$SetAlgoCaptionLayout with its name. $\backslash$AlCapFnt and $\backslash$AlCapNameFnt can change the font used in caption, beware of interactions between this three commands.

Note that two length control the layout of ruled, algoruled, boxruled algorithms caption. $\backslash$interspacetitleruled and $\backslash$interspacetitleboxruled are described section 9.6.

AlgoLine is the counter used to number the lines. It’s a standard counter, so LaTeXcommands works with it.

linesnumbered, linesnumberedhidden and commentsnumbered (see above section 7) are the options controlling auto-numbering of lines. You can also control this feature manually and precisely with the following commands:

$\backslash$LinesNumbered

makes lines of the following algorithms be auto-numbered. This command corresponds to linesnumbered option.

$\backslash$LinesNumberedHidden

makes lines of the following algorithms be auto-numbered, but numbers stay hidden. You have to use $\backslash$ShowLn and $\backslash$ShowLnLabel to see them. This command corresponds to linesnumberedhidden option.

$\backslash$LinesNotNumbered

makes lines of the following algorithms no be auto-numbered.

$\backslash$nllabel{label}

macro for labelling lines when auto-numbering is active.

$\backslash$nl

numbers the line: must begin the line. You can use $\backslash$label to label the line and reference it further.

$\backslash$lnl{label}

numbers and labels the line : must begin the line. Do a Beware this has changed from release 3$\backslash$nl$\backslash$label{label} in one time. Prefer to use a classical $\backslash$label as it is more readable.

$\backslash$nlset{text}

works as $\backslash$nl except that the additional argument is the text to put at the beginning of the line. This text becomes the reference if you label it and $\backslash$ref will print it instead of classical number.

$\backslash$lnlset{text}{label}

works for $\backslash$nlset as $\backslash$lnl for $\backslash$nl. Prefer to use a classical $\backslash$label as it is more readable.

$\backslash$ShowLn

shows number of the line when linesnumberedhidden is activated.

$\backslash$ShowLn{label}

same as precedent but with a label. Prefer to use $\backslash$ShowLn with a classical $\backslash$label.

The following command allows you to change the way line numbers are printed:

$\backslash$SetNlSty{$<$font$>$}{$<$txt before$>$}{$<$txt after$>$}

defines how to print line numbers:
will print {$<$font$>$ $<$txt bef$>$ thelinenumber $<$txt aft$>$}.
By default $\backslash$SetNlSty{textbf}{}{}.

$\backslash$SetNlSkip{length}

sets the value of the space between the line numbers and the text, by default 1em.

$\backslash$SetAlgoNLRelativeSize{number}

sets the relative size of line numbers. By default, line numbers are two size smaller than algorithm text. Use this macro to change this behavior. For example, $\backslash$SetAlgoNlRelativeSize{$0$} sets it to the same size, $\backslash$SetAlgoNlRelativeSize{$-1$} to one size smaller and $\backslash$SetAlgoNlRelativeSize{$1$} to one size bigger.

Example below shows use of these macros:

Almost every text in algorithm has his own style that can be customized. The following commands correspond to the different styles used by the package. They can be customized by using corresponding “$\backslash$Set commands” (see section 9.5.3)

$\backslash$AlFnt

is used at the beginning of the body of algorithm in order to define the fonts used for typesetting algorithms. You can use it elsewhere you want to typeset text as algorithm
For example you can do to have algorithms typeset in small sf font. Default is nothing so algorithm is typeset as the text of the document.

$\backslash$KwSty{$<$text$>$}

sets $<$text$>$ in keyword type style.

$\backslash$FuncSty{$<$text$>$}

sets $<$text$>$ in function type style.

$\backslash$FuncArgSty{$<$text$>$}

sets $<$text$>$ in function argument type style.

$\backslash$ProgSty{$<$text$>$}

sets $<$text$>$ in programm (KwProg) type style.

$\backslash$ArgSty{$<$text$>$}

sets $<$text$>$ in argument type style.

$\backslash$DataSty{$<$text$>$}

sets $<$text$>$ in data typography.

$\backslash$CommentSty{$<$text$>$}

sets $<$text$>$ in comment typography.

$\backslash$NlSty{$<$text$>$}

sets $<$text$>$ in number line typography.

$\backslash$ProcNameSty{$<$text$>$}

sets $<$text$>$ in procedure style of procedure and function environment (by default the same as $\backslash$AlCapSty{)}. (see section 9.5.2 for more explanations and details)

$\backslash$ProcFnt{$<$text$>$}

sets $<$text$>$ in procedure typography of procedure and function environment (by default the same as $\backslash$AlCapFnt{)}. (see section 9.5.2 for more explanations and details)

$\backslash$ProcArgSty{$<$text$>$}

sets $<$text$>$ in argument style of procedure and function environment (by default the same as $\backslash$AlCapNameSty{)}. (see section 9.5.2 for more explanations and details)

$\backslash$ProcArgFnt{$<$text$>$}

sets $<$text$>$ in argument typography of procedure and function environment (by default the same as $\backslash$AlCapNameFnt{)}. (see section 9.5.2 for more explanations and details)

$\backslash$BlockMarkersSty{$<$text$>$}

sets $<$text$>$ in block markers typography (by default the same as $\backslash$KwSty{)} (see section 9.6 for more explanations and details on block markers).

$\backslash$AlCapSty, $\backslash$AlCapNameSty, $\backslash$AlCapFnt, $\backslash$AlCapNameFnt, $\backslash$ProcSty, $\backslash$ProcFnt, $\backslash$ProcNameSty, $\backslash$ProcNameFnt, $\backslash$ProgArgSty, $\backslash$ProgArgFnt and corresponding “$\backslash$Set commands” (see section 9.5.4) $\backslash$SetAlCapSty, $\backslash$SetAlCapNameSty, $\backslash$SetAlCapFnt, $\backslash$SetAlCapNameFnt, $\backslash$SetProcSty, $\backslash$SetProcFnt, $\backslash$SetProcNameSty, $\backslash$SetProcNameFnt, $\backslash$SetProgArgSty, $\backslash$SetProgArgFnt control the way caption of algorithm and procedure/function environment are printed.

$\backslash$AlCapSty and $\backslash$AlCapFnt are used to define style and font shape of “Algorithm #:” in caption. $\backslash$AlCapNameSty and $\backslash$AlCapNameFnt are used to define style and font shape of the caption text. In fact a caption $\backslash$caption{my algorithm} is printed as follow :

By default, $\backslash$AlCapSty is textbf and $\backslash$AlCapFnt is nothing. $\backslash$AlCapNameSty keeps text as it is, and $\backslash$AlCapNameFnt do nothing.

$\backslash$ProcSty and $\backslash$ProcFnt are used to define style and font shape of “Procedure” in caption of procedure and function environment. $\backslash$ProcNameSty and $\backslash$ProcNameFnt are used to define style and font shape of the procedure or function name. $\backslash$ProcArgSty and $\backslash$ProgArgFnt are used to define style and font shape of arguments in procedure/function environment. In fact a caption $\backslash$caption{Proc(int i)} of procedure/function environment is printed as follow :

By default, $\backslash$ProcSty is $\backslash$AlCapSty and $\backslash$ProcFnt is $\backslash$AlCapFnt. $\backslash$ProcNameSty keeps text as it is, and $\backslash$ProcNameFnt do nothing.

$\backslash$AlCapSty{$<$text$>$}

sets $<$text$>$ in caption title typography, that is the same used, together with $\backslash$AlCapFnt, to print Algorithm #:, more precisely it is printed as follow:
$\backslash$AlCapSty{$\backslash$AlCapFnt Algorithm #:}
which gives actually “Algorithm #:”. By default $\backslash$AlCapSty is textbf.

$\backslash$AlCapNameSty{$<$text$>$}

sets $<$text$>$ in caption name typography, that is the same used, together with $\backslash$AlCapNameFnt to print the name of caption you set by calling $\backslash$caption{name}. More precisely it is printed as follow:
$\backslash$AlCapNameSty{$\backslash$AlCapNameFnt name}
which gives “name”. By default $\backslash$AlCapNameSty is textnormal which means print in standard text.

$\backslash$AlCapFnt{$<$text$>$}

sets $<$text$>$ in font shape of caption title, that is the same used, together with $\backslash$AlCapSty, to print Algorithm #:, more precisely it is printed as follow:
$\backslash$AlCapSty{$\backslash$AlCapFnt Algorithm #:}
which gives actually “Algorithm #:”. By default $\backslash$AlCapFnt is $\backslash$relax which means keep text as it is.

$\backslash$AlCapNameFnt{$<$text$>$}

sets $<$text$>$ in caption name typography, that is the same used, together with $\backslash$AlCapNameSty to print the name of caption you set by calling $\backslash$caption{name}. More precisely it is printed as follow:
$\backslash$AlCapNameSty{$\backslash$AlCapNameFnt name}
which gives “name”. By default $\backslash$AlCapNameFnt is $\backslash$relax which means keep text as it is.

$\backslash$ProcSty{$<$text$>$}

sets $<$text$>$ in procedure/function caption title typography, that is the same used, together with $\backslash$ProcFnt, to print Procedure, more precisely it is printed as follow:
$\backslash$ProcSty{$\backslash$ProcFnt Procedure}
which gives actually “Procedure”. By default $\backslash$ProcSty is $\backslash$AlCapSty.

$\backslash$ProcNameSty{$<$text$>$}

sets $<$text$>$ in procedure name typography, that is the same used, together with $\backslash$ProcNameFnt to print the name of caption you set by calling $\backslash$caption{Proc(int i)}. More precisely it is printed as follow:
$\backslash$ProcNameSty{$\backslash$ProcNameFnt Proc(}
which gives “Proc(”. By default $\backslash$ProcNameSty is $\backslash$AlCapNameSty which means print in standard text.

$\backslash$ProcArgSty{$<$text$>$}

sets $<$text$>$ in argument of procedure/function typography, that is the same used, together with $\backslash$ProcArgFnt, to print int i if $\backslash$caption{Proc(int i)} was called. More precisely it is printed as follow:
$\backslash$ProcArgSty{$\backslash$ProcArgFnt int i}
which gives actually “int i”. By default $\backslash$ProcArgSty is $\backslash$AlCapNameSty;

$\backslash$ProcFnt{$<$text$>$}

sets $<$text$>$ in font shape of caption title, that is the same used, together with $\backslash$ProcSty, to print Procedure, more precisely it is printed as follow:
$\backslash$ProcSty{$\backslash$ProcFnt Procedure}
which gives actually “Procedure”. By default $\backslash$ProcFnt is $\backslash$relax which means keep text as it is.

$\backslash$ProcNameFnt{$<$text$>$}

sets $<$text$>$ in procedure/function name typography, that is the same used, together with $\backslash$ProcNameSty to print the name of caption you set by calling $\backslash$caption{Proc(int i)}. More precisely it is printed as follow:
$\backslash$ProcNameSty{$\backslash$ProcNameFnt Proc(}
which gives “Proc(”. By default $\backslash$ProcNameFnt is $\backslash$relax which means keep text as it is.

$\backslash$ProcArgFnt{$<$text$>$}

sets $<$text$>$ in font shape of argument of procedure/environment caption, that is the same used, together with $\backslash$ProcArgSty, to print int i if $\backslash$caption{int i} was called. More precisely it is printed as follow:
$\backslash$ProcArgSty{$\backslash$ProcFnt int i}
which gives actually “int i”. By default $\backslash$ProcArgFnt do nothing.

$\backslash$AlTitleSty{$<$text$>$}

is used to typeset “Algorithm #:” in title, together with $\backslash$AlTitleFnt. You can use it to have text as your titles. Precisely, titles are typeset as follow:
$\backslash$AlTitleSty{$\backslash$AlTitleFnt{Algorithm #:}}.

$\backslash$AlTitleFnt{$<$text$>$}

is used to typeset “Algorithm #:” in title, together with $\backslash$AlTitleSty. You can use it to have text as your titles. Precisely, titles are typeset as follow:
$\backslash$AlTitleSty{$\backslash$AlTitleFnt{Algorithm #:}}.

With the following commands you can customize the style and have the look you want for your algorithms:

$\backslash$SetAlFnt{$<$font$>$}

define the fonts used for typesetting algorithms.

You have to give commands to set the font in argument. You can use it elsewhere you want to typeset text as algorithm. For example you can do $\backslash$SetAlFnt{$\backslash$small$\backslash$sf} to have algorithms typeset in small sf font.

The next ones require to give in parameter name of a macro (whithout $\backslash$) which takes one argument. For example, $\backslash$SetAlCapFnt{textbf} (see section 9.2.2) defines the default behaviour of $\backslash$AlCapFnt. If you want to do more complicated thing, you should define your own macro and give it to $\backslash$SetAlCapFnt or $\backslash$SetAlCapNameFnt. Here are two examples:

• •

  $\backslash$newcommand{$\backslash$mycapfn}[1]{$\backslash$tiny #1}$\backslash$SetAlCapNameFnt{mycapfnt}

• •

  $\backslash$newcommand{$\backslash$mycapfn}[1]{$\backslash$textsl{$\backslash$small #1}}$\backslash$SetAlCapNameFnt{mycapfnt}

Here is the complete list of these macros:

$\backslash$SetKwSty{$<$font$>$}

sets the Kw typography to $<$font$>$ (by default: textbf).

$\backslash$SetFuncSty{$<$font$>$}

sets the function typography (by default: texttt).

$\backslash$SetFuncArgSty{$<$font$>$}

sets the typography of function argument (by default: emph).

$\backslash$SetProgSty{$<$font$>$}

sets the KwProg typography to $<$font$>$ (by default: emph).

$\backslash$SetArgSty{$<$font$>$}

sets the argument typography (by default: emph).

$\backslash$SetDataSty{$<$font$>$}

sets the data typography (by default: textsf).

$\backslash$SetCommentSty{$<$font$>$}

sets the comment text typography (by default: texttt).

$\backslash$SetNlSty{$<$font$>$}

sets the number line typography (by default: $\backslash$relsize{-2})

$\backslash$SetProcNameSty{$<$font$>$}

sets caption typography of procedure and function environment (by default the same as $\backslash$AlCapSty{)}.

$\backslash$SetProcArgSty{$<$font$>$}

sets argument typography of procedure and function environment (by default the same as $\backslash$AlCapNameSty{)}.

$\backslash$SetBlockMarkersSty{$<$font$>$}

sets block markers typography (by default the same as $\backslash$KwSty{)}.

The following commands allow to redefine Fnt macros. This ones requires to give directly commands that define the font shape you want. They works as $\backslash$SetAlFnt{d}escribed above. For example you can do $\backslash$SetAlCapFnt{$\backslash$large$\backslash$color{red}} to have Algorithm #: in caption printed in large red font.

$\backslash$SetAlCapFnt{$<$font$>$}

sets the font used for {algorithm: } in caption of algorithm (default is set to $\backslash$relax).

$\backslash$SetAlCapNameFnt{$<$font$>$}

sets the font used by caption text. Default is $\backslash$relax and text is kept as it is.

$\backslash$SetAlTitleFnt{$<$font$>$}

sets the font used in $\backslash$TitleOfAlgo command (default is set to $\backslash$relax, so text is kept as it is).

The next commands allow to redefine Sty macros for caption or title. As “$\backslash$Set commands” of basic font style (see section 9.5.3), they require a name of a command in argument, this command have to take one argument, the text to be typeset. They should be combined with previous commands to redefine display of caption or title. Examples of use:

• •

  $\backslash$newcommand{$\backslash$mycapsty}[1]{$\backslash$textbf{$\backslash$emph{#1}}}$\backslash$SetAlCapNameSty{mycapsty}
  caption will be print emphased and in bold face.

• •

  $\backslash$SetAlCapNameFnt{$\backslash$tiny} set font to tiny size.

• •

  if you combine $\backslash$SetAlCapNameSty{mycapsty} and $\backslash$SetAlCapNameFnt{$\backslash$tiny} will give tiny bold empased caption.

Now the commands:

$\backslash$SetAlCapSty{$<$commandname$>$}:

sets the command that will be used by $\backslash$AlCapSty to define style of Algorithm #: in caption. The argument is a name of a command (without $\backslash$). This command have to take one argument, the text to be formatted. Default is set to: $\backslash$SetAlCapSty{textbf}.

$\backslash$SetAlCapNameSty{$<$commandname$>$}:

sets the command that will be used by $\backslash$AlCapNameSty to define style of caption text. The argument is a name of a command (without $\backslash$). This command have to take one argument, the text to be formatted. Default is set to: $\backslash$SetAlCapSty{textnormal}.

$\backslash$SetAlTitleSty{$<$commandname$>$}

sets the command that will be used by $\backslash$AlTitleSty to define style of algorithm title given by $\backslash$TitleOfAlgo (default is set to $\backslash$SetAlTitleSty{textbf}).

Note that by combining Fnt and Sty macros you can define almost all styles easily. For example, the last example above can be define in a simplier way that previously presented by doing:

• •

  $\backslash$SetAlCapNameSty{textsl}$\backslash$SetAlCapNameFnt{$\backslash$small}