pseudocode in latex presentation

LaTeX/Algorithms

LaTeX has several packages for typesetting algorithms in form of " pseudocode ". They provide stylistic enhancements over a uniform style (i.e., all in typewriter font) so that constructs such as loops or conditionals are visually separated from other text. The pseudocode is usually put in an algorithm environment. For typesetting real code, written in a real programming language, consider the listings package described in Source Code Listings .

• 1.1 Typesetting using the algorithmic package
• 1.2 Typesetting using the algorithm2e package
• 1.3 Typesetting using the algorithmicx package
• 1.4 Typesetting using the program package
• 2.1 Algorithm numbering
• 2.2 List of algorithms
• 2.3 An example from the manual
• 3 References

Typesetting [ edit | edit source ]

There are four notable packages algorithmic , algorithm2e , algorithmicx , and program ,

Typesetting using the algorithmic package [ edit | edit source ]

The algorithmic package uses a different set of commands than the algorithmicx package. This is not compatible with revtex4-1 . Basic commands are:

Complete documentation is listed at [2] [ dead link ] . Most commands are similar to the algorithmicx equivalents, but with different capitalization. The package algorithms bundle at the ctan repository , dated 2009-08-24, describes both the algorithmic environment (for typesetting algorithms) and the algorithm floating wrapper (see below ) which is designed to wrap around the algorithmic environment.

The algorithmic package is suggested for IEEE journals as it is a part of their default style sheet. [1]

How to rename require/ensure to input/output:

Typesetting using the algorithm2e package [ edit | edit source ]

The algorithm2e package (first released 1995, latest updated July 2017 according to the v5.2 manual ) allows typesetting algorithms with a lot of customization. Like algorithmic , this package is also not compatible with Revtex-4.1. [2]

Unlike algorithmic , algorithm2e provides a relatively huge number of customization options to the algorithm suiting to the needs of various users. The CTAN-manual provides a comprehensible list of examples and full set of controls.

Typically, the usage between \begin{algorithm} and \end{algorithm} would be 1. Declaring a set of keywords(to typeset as functions/operators), layout controls, caption, title, header text (which appears before the algorithm's main steps e.g.: Input,Output) 2. Writing the main steps of the algorithm, with each step ending with a \; This may be taken in analogy with writing a latex-preamble before we start the actual document.

The package is loaded like

and a simple example, taken from the v4.01 manual, is

which produces

More details are in the manual hosted on the ctan website .

Typesetting using the algorithmicx package [ edit | edit source ]

The algorithmicx package provides a number of popular constructs for algorithm designs. Put \usepackage{algpseudocode} in the preamble to use the algorithmic environment to write algorithm pseudocode ( \begin{algorithmic}...\end{algorithmic} ). You might want to use the algorithm environment ( \usepackage{algorithm} ) to wrap your algorithmic code in an algorithm environment ( \begin{algorithm}...\end{algorithm} ) to produce a floating environment with numbered algorithms.

The command \begin{algorithmic} can be given the optional argument of a positive integer, which if given will cause line numbering to occur at multiples of that integer. E.g. \begin{algorithmic}[5] will enter the algorithmic environment and number every fifth line.

Below is an example of typesetting a basic algorithm using the algorithmicx package (remember to add the \usepackage{algpseudocode} statement to your document preamble):

The LaTeX source can be written to a format familiar to programmers so that it is easy to read. This will not, however, affect the final layout in the document.

Basic commands have the following syntax:

Statement (\State causes a new line, can also be used in front of other commands)

Three forms of if-statements:

The third form accepts as many \ElsIf{} clauses as required. Note that it is \ElsIf and not \ElseIf .

Pre- and postcondition:

This command will usually be used in conjunction with a \State command as follows:

Note to users who switched from the old algorithmic package: comments may be placed everywhere in the source; there are no limitations as in the old algorithmic package.

The algorithmicx package allows you to define your own environments.

To define blocks beginning with a starting command and ending with an ending command, use

This defines two commands \<start> and \<end> which have no parameters. The text displayed by them is \textbf{<start>} and \textbf{<end>} .

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 the n-th parameter is referenced by #n .

More advanced customization and other constructions are described in the algorithmicx manual: http://mirror.ctan.org/macros/latex/contrib/algorithmicx/algorithmicx.pdf

Typesetting using the program package [ edit | edit source ]

The program package provides macros for typesetting algorithms. Each line is set in math mode, so all the indentation and spacing is done automatically. The notation |variable_name| can be used within normal text, maths expressions or programs to indicate a variable name. Use \origbar to get a normal | symbol in a program. The commands \A , \B , \P , \Q , \R , \S , \T and \Z typeset the corresponding bold letter with the next object as a subscript (eg \S1 typesets {\bf S$_1$} etc). Primes work normally, eg \S‘‘ .

Below is an example of typesetting a basic algorithm using the program package (remember to add the \usepackage{program} statement to your document preamble):

The commands \( and \) are redefined to typeset an algorithm in a minipage, so an algorithm can appear as a single box in a formula. For example, to state that a particular action system is equivalent to a WHILE loop you can write:

Dijkstra conditionals and loops:

Loops with multiple exits:

A Reverse Engineering Example.

Here's the original program:

And here's the transformed and corrected version:

The package also provides a macro for typesetting a set like this: \set{x \in N | x > 0} .

Lines can be numbered by setting \NumberProgramstrue and numbering turned off with \NumberProgramsfalse

Package page

Package documentation

The algorithm environment [ edit | edit source ]

It is often useful for the algorithm produced by algorithmic to be "floated" to the optimal point in the document to avoid it being split across pages. The algorithm environment provides this and a few other useful features. Include it by adding the \usepackage{algorithm} to your document's preamble. It is entered into by

Algorithm numbering [ edit | edit source ]

The default numbering system for the algorithm package is to number algorithms sequentially. This is often not desirable, particularly in large documents where numbering according to chapter is more appropriate. The numbering of algorithms can be influenced by providing the name of the document component within which numbering should be recommenced. The legal values for this option are: part, chapter, section, subsection, subsubsection or nothing (default). For example:

List of algorithms [ edit | edit source ]

When you use figures or tables, you can add a list of them close to the table of contents; the algorithm package provides a similar command. Just put

anywhere in the document, and LaTeX will print a list of the "algorithm" environments in the document with the corresponding page and the caption.

An example from the manual [ edit | edit source ]

This is an example taken from the manual ( official manual, p.14 )

References [ edit | edit source ]

• ↑ http://tex.stackexchange.com/questions/70181/revtex4-1-and-algorithm2e-indentation-clash
• The official manual for the algorithms package, Rogério Brito (2009), http://mirrors.ctan.org/macros/latex/contrib/algorithms/algorithms.pdf

• Wikibooks pages with to-do lists

Navigation menu

Frequently Asked Question List for TeX

Typesetting pseudocode in LaTeX

There is no consensus on the “right” way to typeset pseudocode. Consequently, there are a variety of LaTeX packages to choose from for producing æsthetically pleasing pseudocode listings.

Pseudocode differs from actual program listings in that it lacks strict syntax and semantics. Also, because pseudocode is supposed to be a clear expression of an algorithm it may need to incorporate mathematical notation, figures, tables, and other LaTeX features that do not appear in conventional programming languages. Typesetting program listings is described elsewhere.

You can certainly create your own environment for typesetting pseudocode using, for example, the tabbing or list environments — it’s not difficult, but it may prove boring. So it’s worth trying the following packages, all designed specifically for typesetting pseudocode.

The algorithms bundle (which contains packages algorithm and algorithmic , both of which are needed for ordinary use) has a simple interface and produces fairly nice output. It provides primitives for statements, which can contain arbitrary LaTeX commands, comments, and a set of iterative and conditional constructs. These primitives can easily be redefined to produce different text in the output. However, there is no support for adding new primitives. Typesetting the pseudocode itself is performed in algorithmic ; the algorithms package uses the facilities of the float package to number algorithms sequentially, enable algorithms to float like figures or tables, and support including a List of Algorithms in a document’s front matter.

Packages in the algorithmicx bundle are similar both in concept and output form to algorithmic but additionally provide support for adding new keywords and altering the formatting. It provides the algpseudocode package which is (almost) a drop-in replacement for algorithmic . Another package in the bundle, algpascal , uses Pascal-like keywords, indents differently from algpseudocode , and puts command arguments in maths mode instead of text mode. There is no floating environment but algorithmicx , like algorithmic , is compatible with the algorithm package. (There have been reports of difficulty defining new commands to fit with the package; unfortunately, the author is not available to comment.)

The alg package, like algorithms , offers a floating algorithm environment with all of the ensuing niceties. alg , however, can caption its floats in a variety of (natural) languages. In addition, alg unlike algorithms , makes it easy to add new constructs.

The newalg package has a somewhat similar interface to algorithms , but its output is designed to mimic the rather pleasant typesetting used in the book “ Introduction to Algorithms ” by Corman, Leiserson, Rivest and Stein. Unfortunately, newalg does not support a floating environment or any customisation of the output.

“ Bona fide ” use of the style of “Introduction to Algorithms” may be achieved with Cormen’s own clrscode : this is the package as used in the second edition of the book.

Similarly, the style of “ Combinatorial Algorithms: Generation, Enumeration and Search ” is supported by the pseudocode package, written by the authors of the book. It has the common “Pascal-like” style, and has some interesting constructs for what one thinks of as Pascal blocks.

The algorithm2e is of very long standing, and is widely used and recommended. It loads the float package to provide the option of floating algorithm descriptions, but you can always use the H option of float to have the algorithm appear “where you write it”.

The usage of the program package is a little different from that of the other packages. It typesets programs in maths mode instead of text mode; and linebreaks are significant. program lacks a floating environment but does number algorithms like alg and algorithms . Customisation and extension are not supported. Documentation of the program package (such as it is) appears in a file program.msg in the distribution.

None of the above are perfect. The factors that should influence your choice of package include the output style you prefer, how much you need to extend or modify the set of keywords, and whether you require algorithms to float like figures and tables.

FAQ ID: Q-algorithms

404 Not found

How to Write Algorithm Pseudo Code in LaTeX

In this post, I want to summarize what I have learned about creating algorithmic pseudo code in LaTeX.

In LaTeX, there are several packages which can help you to write pseudo code, notably algorithmicx and algorithm2e . It seems that algorithm2e is more actively maintained 1 . I decided to give algorithm2e a try. The end result is shown in the title image. The code to create the title image is:

Now I am going to explain the code in detail.

Controlling the algorithm style #

There are certain options for the algorithm2e package which control the algorithm style. They can be specified when you import the package:

The meaning of these options are list below:

• ruled : display algorithm like three-line table.
• lined : display indentation line so that you can clearly see the indentation level.
• linenumbered : number the statement line.
• commentnumbered : number the comment line.
• longend : used end for to end for loop and use end if to end if condition.

Keyword input, output and function #

Define keyword input and output #.

First we need to specify the input and output of the algorithm. algorithm2e provides \KwIn and \KwOut command for input and output respectively:

These keyword parameters are not aligned in its : symbol. If you prefer an aligned keyword, you need to define the input and output keyword yourself like the following code:

In the above code, we redefine the \KwIn and \KwOut command with \SetKwInOut . \SetKwInOut will make sure that the defined keyword command will algin at the : character.

Define keyword function #

You can define a keyword function via \SetKwFunction{COMMAND}{TEXT} command.

COMMAND is used to define the keyword function command, and TEXT is the text that will be shown when you invoke the command, for example:

Then you can invoke the command via \isOddNumber .

By default, the comment used by algorithm2e has its default style (font size, character color, etc.). If you are not satisfied with comment style, you can change it via \SetCommentSty{} command. For example, the following code, we change the comment font size, font style and color:

Algorithm2e provides \tcc and \tcp command to create multi-line and single line C-style comments respectively.

For example, you can use \tcc to create a multi-line comment:

The created comment looks like:

You can use \tcp to create single line comment. You can put \tcp{} command on a separate line to the statement you want to comment:

The produced comment is like:

When you want to put \tcp in the same line with the statement, there is also a stared version \tcp*[OPTION] {} with options. The options is used to change the comment style slightly. For example, the following code:

will create inline comment shown below.

References #

• Create pseudo code in LaTeX .
• How to un-align keyword commands .
• Remove end in if block .

More discussions about different packages to produce pseudo in LaTeX can be found here and here .  ↩︎

Frequently Asked Question List for TeX

Typesetting pseudocode in LaTeX

There is no consensus on the “right” way to typeset pseudocode. Consequently, there are a variety of LaTeX packages to choose from for producing æsthetically pleasing pseudocode listings.

Pseudocode differs from actual program listings in that it lacks strict syntax and semantics. Also, because pseudocode is supposed to be a clear expression of an algorithm it may need to incorporate mathematical notation, figures, tables, and other LaTeX features that do not appear in conventional programming languages. Typesetting program listings is described elsewhere.

You can certainly create your own environment for typesetting pseudocode using, for example, the tabbing or list environments — it’s not difficult, but it may prove boring. So it’s worth trying the following packages, all designed specifically for typesetting pseudocode.

The algorithms bundle (which contains packages algorithm and algorithmic , both of which are needed for ordinary use) has a simple interface and produces fairly nice output. It provides primitives for statements, which can contain arbitrary LaTeX commands, comments, and a set of iterative and conditional constructs. These primitives can easily be redefined to produce different text in the output. However, there is no support for adding new primitives. Typesetting the pseudocode itself is performed in algorithmic ; the algorithms package uses the facilities of the float package to number algorithms sequentially, enable algorithms to float like figures or tables, and support including a List of Algorithms in a document’s front matter.

Packages in the algorithmicx bundle are similar both in concept and output form to algorithmic but additionally provide support for adding new keywords and altering the formatting. It provides the algpseudocode package which is (almost) a drop-in replacement for algorithmic . Another package in the bundle, algpascal , uses Pascal-like keywords, indents differently from algpseudocode , and puts command arguments in maths mode instead of text mode. There is no floating environment but algorithmicx , like algorithmic , is compatible with the algorithm package. (There have been reports of difficulty defining new commands to fit with the package; unfortunately, the author is not available to comment.)

The alg package, like algorithms , offers a floating algorithm environment with all of the ensuing niceties. alg , however, can caption its floats in a variety of (natural) languages. In addition, alg unlike algorithms , makes it easy to add new constructs.

The newalg package has a somewhat similar interface to algorithms , but its output is designed to mimic the rather pleasant typesetting used in the book “ Introduction to Algorithms ” by Cormen, Leiserson, Rivest and Stein. Unfortunately, newalg does not support a floating environment or any customisation of the output.

“ Bona fide ” use of the style of “Introduction to Algorithms” may be achieved with Cormen’s own clrscode : this is the package as used in the second edition of the book.

Similarly, the style of “ Combinatorial Algorithms: Generation, Enumeration and Search ” is supported by the pseudocode package, written by the authors of the book. It has the common “Pascal-like” style, and has some interesting constructs for what one thinks of as Pascal blocks.

The algorithm2e is of very long standing, and is widely used and recommended. It loads the float package to provide the option of floating algorithm descriptions, but you can always use the H option of float to have the algorithm appear “where you write it”.

The usage of the program package is a little different from that of the other packages. It typesets programs in maths mode instead of text mode; and linebreaks are significant. program lacks a floating environment but does number algorithms like alg and algorithms . Customisation and extension are not supported. Documentation of the program package is short, but a demo file, program-demo.tex , is provided in the distribution and shows a lot more examples.

None of the above are perfect. The factors that should influence your choice of package include the output style you prefer, how much you need to extend or modify the set of keywords, and whether you require algorithms to float like figures and tables.

FAQ ID: Q-algorithms

No Search Results

• Code listing
• 1 Introduction
• 2 The verbatim environment
• 3 Using listings to highlight code
• 4 Importing code from a file
• 5 Code styles and colours
• 6 Captions and the list of Listings
• 7 Sample Overleaf project
• 8.1 Supported languages
• 8.2 Options to customize code listing styles
• 9 Further reading

Introduction

L a T e X is widely used in science and programming has become an important aspect in several areas of science, hence the need for a tool that properly displays code. This article explains how to use the standard verbatim environment as well as the package listings , which provide more advanced code-formatting features. This separate article discusses the minted package, which performs syntax-highlighting using Python's pygmentize library.

The verbatim environment

The default tool to display code in L a T e X is verbatim , which generates an output in monospaced font.

 Open this example on Overleaf

The code above produces the following output:

Just as in the example at the introduction, all text is printed keeping line breaks and white spaces. There's a starred version of this command whose output is slightly different.

In this case spaces are emphasized with a special "visible-space" character: ␣ .

Verbatim-like text can also be used in a paragraph by means of the \verb command.

The command \verb|C:\Windows\system32| prints the text inside the delimiters | in verbatim format. Any character, except letters and * , can be used as delimiter. For instance \verb+\ldots+ uses + as delimiter.

Using listings to highlight code

To use the lstlisting environment you have to add the following line to the preamble of your document:

Here's an example of using the lstlisting environment from the listings package:

 Open this listings example on Overleaf

In this example, the output ignores all L a T e X commands and the text is printed keeping all the line breaks and white spaces typed. Let's see a second example:

The additional parameter inside brackets [language=Python] enables code highlighting for this particular programming language (Python), special words are in boldface font and comments are italicized. See the reference guide for a complete list of supported programming languages.

Importing code from a file

Code is usually stored in a source file, therefore a command that automatically pulls code from a file becomes very handy.

The command \lstinputlisting[language=Octave]{BitXorMatrix.m} imports the code from the file BitXorMatrix.m , the additional parameter in between brackets enables language highlighting for the Octave programming language. If you need to import only part of the file you can specify two comma-separated parameters inside the brackets. For instance, to import the code from the line 2 to the line 12, the previous command becomes

If firstline or lastline is omitted, it's assumed that the values are the beginning of the file, or the bottom of the file, respectively.

Code styles and colours

Code formatting with the listing package is highly customisable. Let's see an example

As you see, the code colouring and styling greatly improves readability.

In this example the package xcolor is imported and then the command \definecolor{}{}{} is used to define new colours in rgb format that will later be used. For more information see: using colours in L a T e X

There are essentially two commands that generate the style for this example:

Captions and the list of Listings

Just like in floats ( tables and figures ), captions can be added to a listing for a more clear presentation.

Adding the comma-separated parameter caption=Python example inside the brackets, enables the caption. This caption can be later used in the list of Listings.

Sample Overleaf project

Open this link to  try out the listings package example on Overleaf.

Reference guide

Supported languages.

supported languages (and its dialects if possible, dialects are specified in brackets and default dialects are italized):

Options to customize code listing styles

• backgroundcolor - colour for the background. External color or xcolor package needed.
• commentstyle - style of comments in source language.
• basicstyle - font size/family/etc. for source (e.g. basicstyle=\ttfamily\small )
• keywordstyle - style of keywords in source language (e.g. keywordstyle=\color{red} )
• numberstyle - style used for line-numbers
• numbersep - distance of line-numbers from the code
• stringstyle - style of strings in source language
• showspaces - emphasize spaces in code (true/false)
• showstringspaces - emphasize spaces in strings (true/false)
• showtabs - emphasize tabulators in code (true/false)
• numbers - position of line numbers (left/right/none, i.e. no line numbers)
• prebreak - displaying mark on the end of breaking line (e.g. prebreak=\raisebox{0ex}[0ex][0ex]{\ensuremath{\hookleftarrow}} )
• captionpos - position of caption (t/b)
• frame - showing frame outside code (none/leftline/topline/bottomline/lines/single/shadowbox)
• breakatwhitespace - sets if automatic breaks should only happen at whitespaces
• breaklines - automatic line-breaking
• keepspaces - keep spaces in the code, useful for indetation
• tabsize - default tabsize
• escapeinside - specify characters to escape from source code to L a T e X (e.g. escapeinside={\%*}{*)} )
• rulecolor - Specify the colour of the frame-box

Further reading

For more information see:

• Code Highlighting with minted
• Using colours in LaTeX
• Table of contents
• Management in a large project
• Multi-file LaTeX projects
• Font sizes, families, and styles
• Font typefaces
• listings package documentation
• listings CTAN website
• Documentation Home
• Learn LaTeX in 30 minutes

Overleaf guides

• Creating a document in Overleaf
• Uploading a project
• Copying a project
• Creating a project from a template
• Using the Overleaf project menu
• Including images in Overleaf
• Exporting your work from Overleaf
• Working offline in Overleaf
• Using Track Changes in Overleaf
• Using bibliographies in Overleaf
• Sharing your work with others
• Using the History feature
• Debugging Compilation timeout errors
• How-to guides
• Guide to Overleaf’s premium features

LaTeX Basics

• Creating your first LaTeX document
• Choosing a LaTeX Compiler
• Paragraphs and new lines
• Bold, italics and underlining

Mathematics

• Mathematical expressions
• Subscripts and superscripts
• Brackets and Parentheses
• Fractions and Binomials
• Aligning equations
• Spacing in math mode
• Integrals, sums and limits
• Display style in math mode
• List of Greek letters and math symbols
• Mathematical fonts
• Using the Symbol Palette in Overleaf

Figures and tables

• Inserting Images
• Positioning Images and Tables
• Lists of Tables and Figures
• Drawing Diagrams Directly in LaTeX
• TikZ package

References and Citations

• Bibliography management with bibtex
• Bibliography management with natbib
• Bibliography management with biblatex
• Bibtex bibliography styles
• Natbib bibliography styles
• Natbib citation styles
• Biblatex bibliography styles
• Biblatex citation styles
• Multilingual typesetting on Overleaf using polyglossia and fontspec
• Multilingual typesetting on Overleaf using babel and fontspec
• International language support
• Quotations and quotation marks

Document structure

• Sections and chapters
• Cross referencing sections, equations and floats
• Nomenclatures
• Lengths in L a T e X
• Headers and footers
• Page numbering
• Paragraph formatting
• Line breaks and blank spaces
• Text alignment
• Page size and margins
• Single sided and double sided documents
• Multiple columns
• Margin notes
• Supporting modern fonts with X Ǝ L a T e X

Presentations

• Environments

Field specific

• Theorems and proofs
• Chemistry formulae
• Feynman diagrams
• Molecular orbital diagrams
• Chess notation
• Knitting patterns
• CircuiTikz package
• Pgfplots package
• Typesetting exams in LaTeX
• Attribute Value Matrices

Class files

• Understanding packages and class files
• List of packages and class files
• Writing your own package
• Writing your own class

Advanced TeX/LaTeX

• In-depth technical articles on TeX/LaTeX

Get in touch

Have you checked our knowledge base ?

Message sent! Our team will review it and reply by email.

Email: