The algorithmicx package

Szasz Janos
[email protected]
July 22, 2011

Abstract
The algorithmicx package provides many possibilities to customize
the layout of algorithms. You can use one of the predened layouts
(pseudocode, pascal and c and others), with or without modications,
or you can dene a completely new layout for your specic needs.

Contents
1 Introduction

2 General informations
2.1 The package . . . . . . . . . . . . . . .
2.2 The algorithmic block . . . . . . . . .
2.3 Simple lines . . . . . . . . . . . . . . .
2.4 Placing comments in sources . . . . .
2.5 Labels and references . . . . . . . . . .
2.6 Breaking up long algorithms . . . . . .
2.7 Multiple layouts in the same document

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

3
3
3
3
4
4
4
5

3 The predened layouts

3.1 The algpseudocode layout . .
3.1.1 The for block . . . . . .
3.1.2 The while block . . . .
3.1.3 The repeat block . . .
3.1.4 The if block . . . . . .
3.1.5 The procedure block .
3.1.6 The function block . .
3.1.7 The loop block . . . . .
3.1.8 Other commands in this
3.1.9 Package options . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

5
5
6
7
7
8
8
8
9
9
9

. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
layout
. . . .

This is the documentation for the version 1.2 of the package. This package is released
under LPPL.

3.2

3.3

3.1.10 Changing command names

The algpascal layout . . . . . . .
3.2.1 The begin . . . end block .
3.2.2 The for loop . . . . . . . .
3.2.3 The while loop . . . . . . .
3.2.4 The repeat. . . until block
3.2.5 The if command . . . . . .
3.2.6 The procedure command .
3.2.7 The function command . .
The algc layout . . . . . . . . . . .

4 Custom algorithmic blocks

4.1 Blocks and loops . . . . . .
4.2 Dening blocks . . . . . . .
4.3 Dening loops . . . . . . . .
4.4 Continuing blocks and loops
4.5 Even more customisation .
4.6 Parameters, custom text . .
4.7 The ONE dening macro .

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

10
11
11
11
12
12
12
12
12
13

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.

13
13
14
15
16
17
19
20

5 Examples
22
5.1 A full example using algpseudocode . . . . . . . . . . . . . . . 22
5.2 Breaking up an algorithm . . . . . . . . . . . . . . . . . . . . . . 24
5.3 Using multiple layouts . . . . . . . . . . . . . . . . . . . . . . . . 26
6 Bugs

28

Introduction

All this has begun in my last year at the university. The only thing that I knew
of LATEX was that it exists, and that it is good. I started using it, but I needed
to typeset some algorithms. So I begun searching for a good algorithmic style,
and I have found the algorithmic package. It was a great joy for me, and I
started to use it. . . Well. . . Everything went nice, until I needed some block
that wasnt dened in there. What to do? I was no LATEX guru, in fact I only
knew the few basic macros. But there was no other way, so I opened the style
le, and I copied one existing block, renamed a few things, and voil`a! This (and
some other small changes) where enough for me. . .
One year later for one good soul I had to make some really big changes
on the style. And there on a sunny day came the idea. What if I would write
some macros to let others create blocks automatically? And so I did! Since then
the style was completely rewritten. . . several times. . .
I had fun writing it, may you have fun using it! I am still no LATEX guru, so
if you are, and you nd something really ugly in the style, please mail me! All
ideas for improvements are welcome!

Thanks go to Benedek Zsuzsa, Ionescu Clara, Szocs Zoltan, Cseke Botond,

Kanoc and many-many others. Without them I would have never started or
continued algorithmicx.

General informations

2.1

The package

The package algorithmicx itself doesnt dene any algorithmic commands,

but gives a set of macros to dene such a command set. You may use only
algorithmicx, and dene the commands yourself, or you may use one of the
predened command sets.
These predened command sets (layouts) are:
algpseudocode has the same look1 as the one dened in the algorithmic
package. The main dierence is that while the algorithmic package
doesnt allow you to modify predened structures, or to create new ones,
the algorithmicx package gives you full control over the denitions (ok,
there are some limitations you can not send mail with a, say, \For
command).
algcompatible is fully compatible with the algorithmic package, it should
be used only in old documents.
algpascal aims to create a formatted pascal program, it performs automatic
indentation (!), so you can transform a pascal program into an algpascal
algorithm description with some basic substitution rules.
algc yeah, just like the algpascal. . . but for c. . . This layout is incomplete.
To create oating algorithms you will need algorithm.sty. This le may or
may not be included in the algorithmicx package. You can nd it on CTAN,
in the algorithmic package.

2.2

The algorithmic block

Each algorithm begins with the \begin{algorithmic}[lines] command, the

optional lines controls the line numbering: 0 means no line numbering, 1
means number every line, and means number lines , 2, 3. . . until the
\end{algorithmic} command, witch ends the algorithm.

2.3

Simple lines

A simple line of text is beginned with \State. This macro marks the begin
of every line. You dont need to use \State before a command dened in the
package, since these commands use automatically a new line.
1 almost

:-)

To obtain a line that is not numbered, and not counted when counting the
lines for line numbering (in case you choose to number lines), use the Statex
macro. This macro jumps into a new line, the line gets no number, and any
label will point to the previous numbered line.
We will call stataments the lines starting with \State. The \Statex lines
are not stataments.

2.4

Placing comments in sources

Comments may be placed everywhere in the source using the \Comment macro
(there are no limitations like those in the algorithmic package), feel the freedom! If you would like to change the form in witch comments are displayed,
just change the \algorithmiccomment macro:
\algrenewcommand{\algorithmiccomment}[1]{\hskip3em$\rightarrow$ #1}
will result:
1:

+1

2.5

Here is the new comment

Labels and references

Use the \label macro, as usual to label a line. When you use \ref to reference
the line, the \ref will be subtitued with the corresponding line number. When
using the algorithmicx package togedher with the algorithm package, then
you can label both the algorithm and the line, and use the \algref macro to
reference a given line from a given algorithm:
\algref{<algorithm>}{<line>}
The \textbf{while} in algorithm The while in algorithm 1 ends in line 7,
\ref{euclid} ends in line
so 1.7 is the line we seek.
\ref{euclidendwhile}, so
\algref{euclid}{euclidendwhile}
is the line we seek.

2.6

Breaking up long algorithms

Sometimes you have a long algorithm that needs to be broken into parts, each
on a separate oat. For this you can use the following:
\algstore{<savename>} saves the line number, indentation, open blocks of
the current algorithm and closes all blocks. If used, then this must be the
last command before closing the algorithmic block. Each saved algorithm
must be continued later in the document.
\algstore*{<savename>} Like the above, but the algorithm must not be continued.
4

\algrestore{<savename>} restores the state of the algorithm saved under

<savename> in this algorithmic block. If used, then this must be the rst
command in an algorithmic block. A save is deleted while restoring.
\algrestore*{<savename>} Like the above, but the save will not be deleted,
so it can be restored again.
See example in the Examples section.

2.7

Multiple layouts in the same document

You can load multiple algorithmicx layouts in the same document. You can
switch between the layouts using the \alglanguage{<layoutname>} command.
After this command all new algorithmic environments will use the given layout
until the layout is changed again.

The predened layouts

3.1

The algpseudocode layout

If you are familiar with the algorithmic package, then youll nd it easy to
switch. You can use the old algorithms with the algcompatible layout, but
please use the algpseudocode layout for new algorithms.
To use algpseudocode, simply load algpseudocode.sty:
\usepackage{algpseudocode}
You dont need to manually load the algorithmicx package, as this is done
by algpseudocode.
The rst algorithm one should write is the rst algorithm ever (ok, an improved version), Euclids algorithm:
Algorithm 1 Euclids algorithm
1: procedure Euclid(, )
2:
mod
3:
while = 0 do
4:

5:

6:
mod
7:
end while
8:
return
9: end procedure

The g.c.d. of a and b

We have the answer if r is 0

The gcd is b

Created with the following source:

\begin{algorithm}
\caption{Euclids algorithm}\label{euclid}
\begin{algorithmic}[1]
\Procedure{Euclid}{$a,b$}\Comment{The g.c.d. of a and b}
\State $r\gets a\bmod b$
\While{$r\not=0$}\Comment{We have the answer if r is 0}
\State $a\gets b$
\State $b\gets r$
\State $r\gets a\bmod b$
\EndWhile\label{euclidendwhile}
\State \textbf{return} $b$\Comment{The gcd is b}
\EndProcedure
\end{algorithmic}
\end{algorithm}
The \State stands at the beginning of each simple statement; the respective
statement is put in a new line, with the needed indentation. The \Procedure
. . . \EndProcedure and \While . . . \EndWhile blocks (like any block dened in
the algpseudocode layout) automatically indent their content. The indentation of the source doesnt matter, so
\begin{algorithmic}[1]
\Repeat
\Comment{forever}
\State this\Until{you die.}
\end{algorithmic}

repeat
this
3: until you die.

1:
2:

forever

But, generally, it is a good idea to keep the source indented, since you will
nd errors much easier. And your tex le looks better!
All examples and syntax descriptions will be shown as the previous example
the left side shows the LATEX input, and the right side the algorithm, as it
appears in your document. Im cheating! Dont look in the algorithmicx.tex
le! Believe what the examples state! I may use some undocumented and dirty
stu to create all these examples. You might be more confused after opening
algorithmicx.tex as you was before.
In the case of syntax descriptions the text between < and > is symbolic,
so if you type what you see on the left side, you will not get the algorithm on
the right side. But if you replace the text between < > with a proper piece of
algorithm, then you will probably get what you want. The parts between [ and
] are optional.
3.1.1

The for block

The for block may have one of the forms:

\For{<text>}
<body>
\EndFor

1:
2:
3:

for <text> do
<body>
end for

\ForAll{<text>}
<body>
\EndFor

2:
3:

for all <text> do

<body>
end for

1:
2:
3:
4:

0
for 1, do
+
end for

1:
2:
3:

while <text> do
<body>
end while

1:
2:
3:
4:
5:
6:

0
1
while do
+
+1
end while

1:
2:
3:

repeat
<body>
until <text>

1:

Example:
\begin{algorithmic}[1]
\State $sum\gets 0$
\For{$i\gets 1, n$}
\State $sum\gets sum+i$
\EndFor
\end{algorithmic}
3.1.2

The while block

The while block has the form:

\While{<text>}
<body>
\EndWhile
Example:
\begin{algorithmic}[1]
\State $sum\gets 0$
\State $i\gets 1$
\While{$i\le n$}
\State $sum\gets sum+i$
\State $i\gets i+1$
\EndWhile
\end{algorithmic}
3.1.3

The repeat block

The repeat block has the form:

\Repeat
<body>
\Until{<text>}
Example:
\begin{algorithmic}[1]
\State $sum\gets 0$
\State $i\gets 1$
\Repeat
\State $sum\gets sum+i$
\State $i\gets i+1$
\Until{$i>n$}
\end{algorithmic}

0
1
repeat
4:
+
5:
+1
6: until >
1:
2:
3:

3.1.4

The if block

The if block has the form:

\If{<text>}
<body>
[
\ElsIf{<text>}
<body>
...
]
[
\Else
<body>
]
\EndIf

1:
2:
3:
4:

5:
6:
7:

if <text> then
<body>
[
else if <text> then
<body>
...
]
[
else
<body>
]
end if

Example:
\begin{algorithmic}[1]
\If{$quality\ge 9$}
\State $a\gets perfect$
\ElsIf{$quality\ge 7$}
\State $a\gets good$
\ElsIf{$quality\ge 5$}
\State $a\gets medium$
\ElsIf{$quality\ge 3$}
\State $a\gets bad$
\Else
\State $a\gets unusable$
\EndIf
\end{algorithmic}
3.1.5

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

if 9 then

else if 7 then

else if 5 then

else if 3 then

else

end if

The procedure block

The procedure block has the form:

\Procedure{<name>}{<params>}
<body>
\EndProcedure

1:
2:
3:

procedure <name>(<params>)
<body>
end procedure

Example: See Euclids algorithm on page 5.

3.1.6

The function block

The function block has the same syntax as the procedure block:

\Function{<name>}{<params>}
<body>
\EndFunction
3.1.7

1:
2:
3:

function <name>(<params>)
<body>
end function

1:
2:
3:

loop
<body>
end loop

The loop block

The loop block has the form:

\Loop
<body>
\EndLoop
3.1.8

Other commands in this layout

The starting conditions for the algorithm can be described with the require
instruction, and its result with the ensure instruction.
A procedure call can be formatted with \Call.
\Require something
\Ensure something
\Statex
\State \Call{Create}{10}

Require: something
Ensure: something
1:

Create(10)

Example:
\begin{algorithmic}[1]
\Require $x\ge5$
\Ensure $x\le-5$
\Statex
\While{$x>-5$}
\State $x\gets x-1$
\EndWhile
\end{algorithmic}
3.1.9

Require: 5
Ensure: 5
1:
2:
3:

while > 5 do
1
end while

Package options

The algpseudocode package supports the following options:

compatible/noncompatible Obsolote, use the algcompatible layout instead.
If you would like to use old algorithms, written with the algorithmic
package without (too much) modication, then use the compatible option. This option denes the uppercase version of the commands. Note
that you still need to remove the [...] comments (these comments appeared due to some limitations in the algorithmic package, these limitations and comments are gone now). The default noncompatible does
not dene the all uppercase commands.

noend/end
With noend specied all end . . . lines are omitted. You get a somewhat
smaller algorithm, and the ugly feeling, that something is missing. . . The
end value is the default, it means, that all end . . . lines are in their right
place.
3.1.10

Changing command names

One common thing for a pseudocode is to change the command names. Many
people use many dierent kind of pseudocode command names. In algpseudocode all keywords are declared as \algorithmic<keyword>. You can change
them to output the text you need:
\algrenewcommand\algorithmicwhile{\textbf{am\\i g}}
\algrenewcommand\algorithmicdo{\textbf{v\egezd el}}
\algrenewcommand\algorithmicend{\textbf{v\ege}}
\begin{algorithmic}[1]
1: 1
\State $x \gets 1$
2: am
g < 10 v
egezd el
\While{$x < 10$}
3:
+1
\State $x \gets x + 1$
4: v
ege amg
\EndWhile
\end{algorithmic}
In some cases you may need to change even more (in the above example
amg and v
ege should be interchanged in the \EndWhile text). Maybe the
number of the parameters taken by some commands must be changed too. this
can be done with the command text customizing macros (see section 4.6). Here
Ill give only some examples of the most common usage:
\algrenewcommand\algorithmicwhile{\textbf{am\\i g}}
\algrenewcommand\algorithmicdo{\textbf{v\egezd el}}
\algrenewcommand\algorithmicend{\textbf{v\ege}}
\algrenewtext{EndWhile}{\algorithmicwhile\ \algorithmicend}
\begin{algorithmic}[1]
\State $x \gets 1$
1: 1
\While{$x < 10$}
2: am
g < 10 v
egezd el
\State $x \gets x - 1$
3:
1
\EndWhile
4: am
g v
ege
\end{algorithmic}

10

\algnewcommand\algorithmicto{\textbf{to}}
\algrenewtext{For}[3]%
{\algorithmicfor\ #1 \gets #2 \algorithmicto\ #3 \algorithmicdo}
\begin{algorithmic}[1]
\State $p \gets 1$
1: 1
\For{i}{1}{n}
2: for 1 to do
3:

\State $p \gets p * i$
4: end for
\EndFor
\end{algorithmic}
You could create a translation package, that included after the algpseudocode package translates the keywords to the language you need.

3.2

The algpascal layout

The most important feature of the algpascal layout is that it performs automatically the block indentation. In section 4 you will see how to dene such
automatically indented loops. Here is an example to demonstrate this feature:
\begin{algorithmic}[1]
\Begin
\State $sum:=0$;
\For{i=1}{n}\Comment{sum(i)}
\State $sum:=sum+i$;
\State writeln($sum$);
\End.
\end{algorithmic}

begin
:= 0;
for = 1 to do
:= + ;
writeln();
6: end.
1:
2:
3:
4:
5:

{sum(i)}

Note, that the \For is not closed explicitly, its end is detected automatically.
Again, the indentation in the source doesnt aect the output. In this layout
every parameter passed to a command is put in mathematical mode.
3.2.1

The begin . . . end block

\Begin
<body>
\End

1:
2:
3:

begin
<body>
end

The \Begin . . . \End block and the \Repeat . . . \Until block are the
only blocks in the algpascal style (instead of \Begin you may write \Asm).
This means, that every other loop is ended automatically after the following
command (another loop, or a block).
3.2.2

The for loop

\For{<assign>}{<expr>}
<command>

1:
2:

11

for <> to <> do

<command>

The For loop (as all other loops) ends after the following command (a block
counts also as a single command).
\begin{algorithmic}[1]
\Begin
\State $sum:=0$;
\State $prod:=1$;
\For{i:=1}{10}
\Begin
\State $sum:=sum+i$;
\State $prod:=prod*i$;
\End
\End.
\end{algorithmic}
3.2.3

1:
2:
3:
4:
5:
6:
7:
8:
9:

The while loop

\While{<expression>}
<command>
3.2.4

begin
:= 0;
:= 1;
for := 1 to 10 do
begin
:= + ;
:= ;
end
end.

2:

while <> do
<command>

1:
2:
3:

repeat
<body>
until <>

1:
2:

if <> then
<command>

3:
4:

else
<command>

1:

The repeat. . . until block

\Repeat
<body>
\Until{<expression>}
3.2.5 The if command
\If{<expression>}
<command>
[
\Else
<command>
]

Every \Else matches the nearest \If.

3.2.6

The procedure command

\Procedure <some text>

1:

procedure <some text>

\Procedure just writes the procedure word on a new line... You will
probably put a \Begin. . . \End block after it.
3.2.7

The function command

\Function<some text>

1:

Just like Procedure.

12

function <some text>

3.3

The algc layout

Sorry, the algc layout is unnished. The commands dened are:

\{. . . \} block
\For with 3 params
\If with 1 param
\Else with no params
\While with 1 param
\Do with no params
\Function with 3 params
\Return with no params

4
4.1

Custom algorithmic blocks

Blocks and loops

Most of the environments dened in the standard layouts (and most probably
the ones you will dene) are divided in two categories:
Blocks are the environments witch contain an arbitrary number of commands
or nested blocks. Each block has a name, begins with a starting command
and ends with an ending command. The commands in a block are indented
by \algorithmicindent (or another amount).
If your algorithm ends without closing all blocks, the algorithmicx package gives you a nice error. So be good, and close them all!
Blocks are all the environments dened in the algpseudocode package,
the \Begin . . . \End block in the algpascal package, and some other ones.
Loops (Let us call them loops. . . ) The loops are environments that include
only one command, loop or block; a loop is closed automatically after this
command. So loops have no ending commands. If your algorithm (or a
block) ends before the single command of a loop, then this is considered
an empty command, and the loop is closed. Feel free to leave open loops
at the end of blocks!
Loops are most of the environments in the algpascal and algc packages.
For some rare constructions you can create mixtures of the two environments
(see section 4.5). Each block and loop may be continued with another one (like
the If with Else).

13

4.2

Dening blocks

There are several commands to dene blocks. The dierence is in what is dened
beyond the block. The macro \algblock denes a new block with starting and
ending entity.
\algblock[<block>]{<start>}{<end>}
The dened commands have no parameters, and the text displayed by them
is \textbf{<start>} and \textbf{<end>}. You can change these texts later
(4.6).
With \algblockdefx you can give the text to be output by the starting and
ending command and the number of parameters for these commands. In the
text reference with # to the parameter number . Observe that the text is
given in the form you dene or redene macros, and really, this is what happens.
\algblockdefx[<block>]{<start>}{<end>}
[<startparamcount>][<default value>]{<start text>}
[<endparamcount>][<default value>]{<end text>}
This denes a new block called <block>, <start> opens the block, <end>
closes the block, <start> displays <start text>, and has <startparamcount>
parameters, <end> displays <end text>, and has <endparamcount> parameters. For both <start> and <end>, if <default value> is given, then the rst
parameter is optional, and its default value is <default value>.
If you want to display dierent text (and to have a dierent number of parameters) for <end> at the end of dierent blocks, then use the \algblockx macro.
Note that it is not possible to display dierent starting texts, since it is not possible to start dierent blocks with the same command. The <start text> dened
with \algblockx has the same behavior as if dened with \algblockdefx. All
ending commands not dened with \algblockx will display the same text, and
the ones dened with this macro will display the dierent texts you specied.
\algblockx[<block>]{<start>}{<end>}
[<startparamcount>][<default value>]{<start text>}
[<endparamcount>][<default value>]{<end text>}
If in the above denitions the <block> is missing, then the name of the
starting command is used as block name. If a block with the given name already
exists, these macros dont dene a new block, instead this it will be used the
dened block. If <start> or <end> is empty, then the denition does not dene
a new starting/ending command for the block, and then the respective text
must be missing from the denition. You may have more starting and ending
commands for one block. If the block name is missing, then a starting command
must be given.

14

\algblock[Name]{Start}{End}
\algblockdefx[NAME]{START}{END}%
[2][Unknown]{Start #1(#2)}%
{Ending}
\algblockdefx[NAME]{}{OTHEREND}%
[1]{Until (#1)}
\begin{algorithmic}[1]
1: Start
\Start
2:
Start
\Start
3:
Start One(x)
\START[One]{x}
4:
Ending
\END
5:
Start Unknown(0)
\START{0}
\OTHEREND{\texttt{True}}
6:
Until (True)
7:
End
\End
8:
Start
\Start
9:
End
\End
10: End
\End
\end{algorithmic}

4.3

Dening loops

The loop dening macros are similar to the block dening macros. A loop has
no ending command and ends after the rst state, block or loop that follows the
loop. Since loops have no ending command, the macro \algloopx would not
have mutch sense. The loop dening macros are:
\algloop[<loop>]{<start>}
\algloopdefx[<loop>]{<start>}
[<startparamcount>][<default value>]{<start text>}
Both create a loop named <loop> with the starting command <start>. The
second also sets the number of parameters, and the text displayed by the starting
command.

15

\algloop{For}
\algloopdefx{If}[1]{\textbf{If} #1 \textbf{then}}
\algblock{Begin}{End}
\begin{algorithmic}[1]
1: For
\For
2:
Begin
\Begin
3:
If < then
\If{$a < b$}
4:
For
\For
5:
Begin
\Begin
6:
End
\End
7:
Begin
\Begin
8:
End
\End
\End
9:
End
\end{algorithmic}

4.4

Continuing blocks and loops

For each block/loop you may give commands that close the block or loop and
open another block or loop. A good example for this is the if . . . then . . . else
construct. The new block or loop can be closed or continued, as any other blocks
and loops.
To create a continuing block use one of the following:
\algcblock[<new block>]{<old block>}{<continue>}{<end>}
\algcblockdefx[<new block>]{<old block>}{<continue>}{<end>}
[<continueparamcount>][<default value>]{<continue text>}
[<endparamcount>][<default value>]{<end text>}
\algcblockx[<new block>]{<old block>}{<continue>}{<end>}
[<continueparamcount>][<default value>]{<continue text>}
[<endparamcount>][<default value>]{<end text>}
All three macros dene a new block named <new block>. If <new block>
is not given, then <continue> is used as the new block name. It is not allowed
to have both <new block> missing, and <continue> empty. The <continue>
command ends the <old block> block/loop and opens the <new block> block.
Since <continue> may end dierent blocks and loops, it can have dierent text
at the end of the dierent blocks/loops. If the <continue> command doesnt
nd an <old block> to close, then an error is reported.
Create continuing loops with the followings:
\algcloop[<new loop>]{<old block>}{<continue>}
\algcloopdefx[<new loop>]{<old block>}{<continue>}
[<continueparamcount>][<default value>]{<continue text>}

16

\algcloopx[<new loop>]{<old block>}{<continue>}

[<continueparamcount>][<default value>]{<continue text>}
These macros create a continuing loop, the <continue> closes the <old block>
block/loop, and opens a <new loop> loop.
\algblock{If}{EndIf}
\algcblock[If]{If}{ElsIf}{EndIf}
\algcblock{If}{Else}{EndIf}
\algcblockdefx[Strange]{If}{Eeee}{Oooo}
[1]{\textbf{Eeee} "#1"}
{\textbf{Wuuuups\dots}}
\begin{algorithmic}[1]
1: If
\If
2:
If
\If
3:
ElsIf
\ElsIf
4:
ElsIf
\ElsIf
5:
If
\If
6:
ElsIf
\ElsIf
7:
Else
\Else
8:
EndIf
\EndIf
9:
EndIf
\EndIf
10:
If
\If
11:
EndIf
\EndIf
12: Eeee Creep
\Eeee{Creep}
13: Wuuuups. . .
\Oooo
\end{algorithmic}
\algloop{If}
\algcloop{If}{Else}
\algblock{Begin}{End}
\begin{algorithmic}[1]
\If
\Begin
\End
\Else
\If
\Begin
\End
\end{algorithmic}

4.5

1:
2:
3:
4:
5:
6:
7:

If
Begin
End
Else
If
Begin
End

Even more customisation

With the following macros you can give the indentation used by the new block
(or loop), and the number of stataments after that the block is automatically
17

closed. This value is for blocks, 1 for loops, and 0 for stataments. There is a
special value, 65535, meaning that the dened block does not end automatically, but if it is enclosed in a block, then the ending command of the block
closes this block as well.
\algsetblock[<block>]{<start>}{<end>}
{<lifetime>}{<indent>}
\algsetblockdefx[<block>]{<start>}{<end>}
{<lifetime>}{<indent>}
[<startparamcount>][<default value>]{<start text>}
[<endparamcount>][<default value>]{<end text>}
\algsetblockx[<block>]{<start>}{<end>}
{<lifetime>}{<indent>}
[<startparamcount>][<default value>]{<start text>}
[<endparamcount>][<default value>]{<end text>}
\algcsetblock[<new block>]{<old block>}{<continue>}{<end>}
{<lifetime>}{<indent>}
\algcsetblockdefx[<new block>]{<old block>}{<continue>}{<stop>}
{<lifetime>}{<indent>}
[<continueparamcount>][<default value>]{<continue text>}
[<endparamcount>][<default value>]{<end text>}
\algcsetblockx[<new block>]{<old block>}{<continue>}{<stop>}
{<lifetime>}{<indent>}
[<continueparamcount>][<default value>]{<continue text>}
[<endparamcount>][<default value>]{<end text>}
The <lifetime> is the number of stataments after that the block is closed.
An empty <lifetime> eld means . The <indent> gives the indentation of
the block. Leave this eld empty for the default indentation. The rest of the
parameters has the same function as for the previous macros.

18

\algsetblock[Name]{Start}{Stop}{3}{1cm}
\algsetcblock[CName]{Name}{CStart}{CStop}{2}{2cm}
\begin{algorithmic}[1]
1: Start
\Start
2:
1
\State 1
3:
2
\State 2
4:
3
\State 3
5: 4
\State 4
6: Start
\Start
7:
1
\State 1
8: Stop
\Stop
9: 2
\State 2
10: Start
\Start
11:
1
\State 1
12: CStart
\CStart
13:
1
\State 1
14:
2
\State 2
15: 3
\State 3
16: Start
\Start
17:
1
\State 1
18: CStart
\CStart
19:
1
\State 1
20: CStop
\CStop
\end{algorithmic}
The created environments behave as follows:
It starts with \Start. The nested environments are indented by 1 cm.
If it is followed by at least 3 environments (stataments), then it closes
automatically after the third one.
If you put a \Stop before the automatic closure, then this \Stop closes
the environment. CStart closes a block called Name and opens a new one
called CName and having an indentaion of 2 cm.
CName can be closed with CStop or it is closed automatically after 2 environments.

4.6

Parameters, custom text

With \algrenewtext you can change the number of parameters, and the text
displayed by the commands. With algnotext you can makes the vole output
line disappear, but it works only for ending commands, for beginning commands
you will get an incorrect output.
\algrenewcommand[<block>]{<command>}
[<paramcount>][<default value>]{<text>}
19

\algnotext[<block>]{<ending command>}
If <block> is missing, then the default text is changed, and if <block> is
given, then the text displayed at the end of <block> is changed.
To make a command output the default text at the end of a block (say, you
have changed the text for this block), use \algdefaulttext.
\algdefaulttext[<block>]{<command>}
If the <block> is missing, than the default text itself will be set to the default
value (this is \textbf{<command>}).

4.7

The ONE dening macro

All block and loop dening macros call the same macro. You may use this macro
to gain a better acces to what will be dened. This macro is \algdef.
\algdef{<flags>}...
Depending on the ags the macro can have many forms.
Flag
s
S
c
C
xC
e
E
xE
N
xN
b
l
L
i

Meaning
starting command, without text
starting command with text
continuing command, without text
continuing command, with default text
continuing command, with block specic text
ending command, without text
continuing command, with default text
continuing command, with block specic text
ending command, with default no text
ending command, with no text for this block
block(default)
loop
loop closes after the given number of stataments
indentation specied

The <new block> may be given for any combination of ags, and it is not
allowed to have <new block> missing and <start> missing/empty. For c, C,
xC an old block is expected. For s, S, c, C, xC the <start> must be given.
For e, E, xE, N, xN the <end> must be given. For L the <lifetime> must be
given. For i the <indent> must be given. For S, C, xC the starting text and
related infos must be given. For E, xE the ending text must be given. For each
combination of ags give only the needed parameters, in the following order:

20

\algdef{<flags>}[<new block>]{<old block>}{<start>}{<end>}

{<lifetime>}{<indent>}
[<startparamcount>][<default value>]{<start text>}
[<endparamcount>][<default value>]{<end text>}
The block and loop dening macros call \algdef with the following ags:
Macro
\algblock
\algcblock
\algloop
\algcloop
\algsetblock
\algsetcblock
\algblockx
\algblockdefx
\algcblockx
\algcblockdefx
\algsetblockx
\algsetblockdefx
\algsetcblockx
\algsetcblockdefx
\algloopdefx
\algcloopx
\algcloopdefx

21

Meaning
\algdef{se}
\algdef{ce}
\algdef{sl}
\algdef{cl}
\algdef{seLi}
\algdef{ceLi}
\algdef{SxE}
\algdef{SE}
\algdef{CxE}
\algdef{CE}
\algdef{SxELi}
\algdef{SELi}
\algdef{CxELi}
\algdef{CELi}
\algdef{Sl}
\algdef{Cxl}
\algdef{Cl}

5
5.1

Examples
A full example using algpseudocode

\documentclass{article}
\usepackage{algorithm}
\usepackage{algpseudocode}
\begin{document}
\begin{algorithm}
\caption{The Bellman-Kalaba algorithm}
\begin{algorithmic}[1]
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
\ForAll {$v \in V(G)$}
\State $l(v) \leftarrow \infty$
\EndFor
\State $l(u) \leftarrow 0$
\Repeat
\For {$i \leftarrow 1, n$}
\State $min \leftarrow l(v_i)$
\For {$j \leftarrow 1, n$}
\If {$min > e(v_i, v_j) + l(v_j)$}
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
\State $p(i) \leftarrow v_j$
\EndIf
\EndFor
\State $l(i) \leftarrow min$
\EndFor
\State $changed \leftarrow l \not= l$
\State $l \leftarrow l$
\Until{$\neg changed$}
\EndProcedure
\Statex
\Procedure {FindPathBK}{$v$, $u$, $p$}
\If {$v = u$}
\State \textbf{Write} $v$
\Else
\State $w \leftarrow v$
\While {$w \not= u$}
\State \textbf{Write} $w$
\State $w \leftarrow p(w)$
\EndWhile
\EndIf
\EndProcedure
\end{algorithmic}
\end{algorithm}
\end{document}

22

Algorithm 2 The Bellman-Kalaba algorithm

1: procedure BellmanKalaba(, , , )
2:
for all () do
3:
()
4:
end for
5:
() 0
6:
repeat
7:
for 1, do
8:
( )
9:
for 1, do
10:
if > ( , ) + ( ) then
11:
( , ) + ( )
12:
()
13:
end if
14:
end for
15:
()
16:
end for
17:
=
18:

19:
until
20: end procedure
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

procedure FindPathBK(, , )
if = then
Write
else

while = do
Write
()
end while
end if
end procedure

23

5.2

Breaking up an algorithm

\documentclass{article}
\usepackage{algorithm}
\usepackage{algpseudocode}
\begin{document}
\begin{algorithm}
\caption{Part 1}
\begin{algorithmic}[1]
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
\ForAll {$v \in V(G)$}
\State $l(v) \leftarrow \infty$
\EndFor
\State $l(u) \leftarrow 0$
\Repeat
\For {$i \leftarrow 1, n$}
\State $min \leftarrow l(v_i)$
\For {$j \leftarrow 1, n$}
\If {$min > e(v_i, v_j) + l(v_j)$}
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
\State \Comment For some reason we need to break here!
\algstore{bkbreak}
\end{algorithmic}
\end{algorithm}
And we need to put some additional text between\dots
\begin{algorithm}[h]
\caption{Part 2}
\begin{algorithmic}[1]
\algrestore{bkbreak}
\State $p(i) \leftarrow v_j$
\EndIf
\EndFor
\State $l(i) \leftarrow min$
\EndFor
\State $changed \leftarrow l \not= l$
\State $l \leftarrow l$
\Until{$\neg changed$}
\EndProcedure
\end{algorithmic}
\end{algorithm}
\end{document}

24

Algorithm 3 Part 1
1: procedure BellmanKalaba(, , , )
2:
for all () do
3:
()
4:
end for
5:
() 0
6:
repeat
7:
for 1, do
8:
( )
9:
for 1, do
10:
if > ( , ) + ( ) then
11:
( , ) + ( )
12:
For some reason we need to break here!
And we need to put some additional text between. . .
Algorithm 4 Part 2
13:
()
14:
end if
15:
end for
16:
()
17:
end for
18:
=
19:

20:
until
21: end procedure

25

5.3

Using multiple layouts

\documentclass{article}
\usepackage{algorithm}
\usepackage{algpseudocode}
\usepackage{algpascal}
\begin{document}
\alglanguage{pseudocode}
\begin{algorithm}
\caption{A small pseudocode}
\begin{algorithmic}[1]
\State $s \gets 0$
\State $p \gets 0$
\For{$i \gets 1,\, 10$}
\State $s \gets s + i$
\State $p \gets p + s$
\EndFor
\end{algorithmic}
\end{algorithm}
\alglanguage{pascal}
\begin{algorithm}
\caption{The pascal version}
\begin{algorithmic}[1]
\State $s := 0$
\State $p := 0$
\For{i = 1}{10}
\Begin
\State $s := s + i$
\State $p := p + s$
\End
\end{algorithmic}
\end{algorithm}
\end{document}

26

Algorithm 5 A small pseudocode

1: 0
2: 0
3: for 1, 10 do
4:
+
5:
+
6: end for

Algorithm 6 The pascal version

1: := 0
2: := 0
3: for = 1 to 10 do
4:
begin
5:
:= +
6:
:= +
7:
end

27

Bugs

If you have a question or nd a bug you can contact me on:

[email protected]
If possible, please create a small LATEX example related to your problem.

28