pseudocode in latex presentation

• How to Write Algorithm Pseudo Code in LaTeX /

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 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

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Beautiful pseudocode in latex

esneider/latex-pseudocode

Folders and files, repository files navigation, latex-pseudocode.

Based on package clrscode3e , written by Thomas H. Cormen:

Package for producing pseudocode in the style of Cormen, Leiserson, Rivest, and Stein, Introduction to Algorithms, Third edition.

Documentation

Each pseudocode procedure is typeset within a codebox environment,

Procedure name

Normally, the first line within the codebox environment is a \Procedure command (optional). The first argument is the procedure name, and the optional second argument is a comma separated list of parameters, each optionally with a description of the parameter (after an equal sign). Example:

Format commands

To typeset a procedure in small caps, use:

To typeset a constant in small caps, use:

To typeset an identifier in italics, use:

To typeset a fixed function in roman, use:

To typeset a keyword in boldface, use:

To typeset an object attribute with dot syntax, use:

To typeset an array element with square brackets syntax, use:

All these commands not only use the correct font, but they also perform the important service of interpreting a dash as a hyphen, rather than as a minus sign. These commands may be used either in or out of math mode.

To typeset subarray ranges, use:

Line numbering

Other than the \Procedure line, all lines begin with either \li (for a numbered line) or \zi (for an unnumbered line).

Keywords and indentation

The following commands are provided for typesetting keywords and handling automatic indentation:

• Loops: \For , \To , \By , \Downto , \Do , \While , \Repeat , \Until
• Selection: \If , \Then , \Else , \ElseIf , \ElseNoIf
• Jumps: \Return , \Error , \Goto
• Multithreading: \Spawn , \Sync , \Parfor
• Comments: \Comment , \RComment , \CommentSymbol
• Indentation: \Indentmore , \Startalign , \Stopalign

\label commands appearing in or after the first numbered line in a codebox resolve to the number of the most recent numbered line.

This package works only if each procedure has at most 99 numbered lines of code.

Code for the example

404 Not found

algpseudocodex

Package for typesetting pseudocode

This package allows typesetting pseudocode in LaTeX. It is based on algpseudocode from the algorithmicx package and uses the same syntax, but adds several new features and improvements. Notable features include customizable indent guide lines and the ability to draw boxes around parts of the code for highlighting differences. This package also has better support for long code lines spanning several lines and improved comments.

• Browse files
• Back to package list

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

CodePython - A Comprehensive Guide for Beginners

Python to latex pseudocode: simplify algorithm presentation.

CodePython.me - In this article, we will explore the concept of converting Python code to LaTeX pseudocode. LaTeX is a popular typesetting system used for creating professional-looking documents, and pseudocode is a language-independent way of representing algorithms. By converting Python code to LaTeX pseudocode, you can simplify the presentation of algorithms and make them more accessible. So, let's dive in and learn how to effectively convert Python code to LaTeX pseudocode.

1. Introduction

Python is a powerful programming language known for its simplicity and readability. However, when presenting complex algorithms or code snippets in technical documents or research papers, it can be challenging to maintain clarity and consistency. LaTeX, on the other hand, is a typesetting system that allows you to create professional-looking documents with mathematical symbols, equations, and advanced formatting. By converting Python code to LaTeX pseudocode, you can simplify the representation of algorithms and enhance their visual appeal.

2. Understanding Pseudocode and LaTeX

Pseudocode is a high-level, language-independent representation of an algorithm. It uses a combination of natural language and simple programming constructs to describe the logic of an algorithm without focusing on specific programming syntax. On the other hand, LaTeX is a typesetting system widely used in academia and technical fields to create documents with complex mathematical equations, tables, and figures. It provides a powerful toolset for creating professional documents with precise control over formatting and layout.

3. Benefits of Converting Python Code to LaTeX Pseudocode

Converting Python code to LaTeX pseudocode offers several benefits:

• Clarity and Readability : LaTeX pseudocode provides a clear and concise representation of algorithms, making them easier to understand for readers.
• Consistency : By using LaTeX pseudocode, you can maintain a consistent style and formatting throughout your document, ensuring a professional look and feel.
• Mathematical Symbols and Equations : LaTeX allows you to seamlessly integrate mathematical symbols and equations into your pseudocode, making it suitable for presenting algorithms with complex mathematical operations.
• Easy Integration : LaTeX pseudocode can be easily integrated into LaTeX documents, allowing you to combine pseudocode with other elements such as text, equations, and figures.

4. Guidelines for Converting Python Code to LaTeX Pseudocode

When converting Python code to LaTeX pseudocode, consider the following guidelines:

• Indentation and Syntax : Use consistent indentation to represent code blocks and logical structure. Remove specific Python syntax elements such as colons and semicolons.
• Variables and Data Types : Describe variables and their data types using natural language without including specific Python syntax.
• Control Structures : Represent control structures like loops and conditionals using intuitive and descriptive pseudocode constructs.
• Comments and Explanations : Include comments or explanations in the pseudocode to provide additional clarity or insights into the algorithm's functioning.
• Error Handling : If necessary, describe error handling or exception handling mechanisms in the pseudocode to address potential errors or edge cases.

5. Example: Converting Python Code to LaTeX Pseudocode

Let's consider an example to illustrate how to convert Python code to LaTeX pseudocode. Suppose we have the following Python code that calculates the factorial of a number:

Now, let's convert this Python code to LaTeX pseudocode:

In the above LaTeX pseudocode, we have replaced the function definition with \Procedure , used \State for each line of code, and employed the \For loop construct.

6. Conclusion

Converting Python code to LaTeX pseudocode can significantly simplify the presentation of algorithms and improve the clarity and readability of technical documents. By following the guidelines mentioned in this article, you can effectively convert Python code to LaTeX pseudocode while maintaining consistency and readability. So, next time you need to present an algorithm in a document, consider using LaTeX pseudocode to enhance its visual appeal and comprehensibility.