[Tex/LaTex] Print programs with its proper syntax

codeminipagespacing

I have defined my own language whose syntax is very close to the one of Pascal. I would like to type the following program for instance. Many people use the packages algorithmicx or algorithm2e to print programs, but it seems that we have to use their specific keywords of its syntax like procedure, end while.

I just want to indent spaces when needed, and bold some words when I want (sorry that I could not bold letters in the following figure). Do I have to use
texttt for each line? Also, with verbatim, I could not bold words…

Also, as the program is not large, I would need to put it on the left side of the page, and leave space for some explanasion text on its right hand side. So I guss I need to get them all together, and use multicols.

Could anyone help?

program test                                      some text here
var
  i : integer;                                    ... 
  b : boolean;
begin
   i := 1;                                        ...
   b := true;
   while i < 15 do
      i := i  + 1;
      b := not b                                  some text here
   od
end

Edit1: Following @Werner's tabbing solution, I have made the code a minipage:

\begin{minipage}[t]{0.48\linewidth}%
\begin{tabbing}
Werner's solution
\end{tabbing}
\end{minipage}\hfill
\begin{minipage}[t]{0.48\linewidth}
a paragraph
\end{minipage}

Actually as the code shows, I want the texts to be another separated minipage on the right hand side of the code. I have then 2 questions:

is it reasonable to make 0.48\linewidth instead of 0.5\linewidth? 0.48\linewidth is a conventional choice?
is it possible to make a frame around the code, and use \caption and \label to make it a reference (I prefer figures)?

Best Answer

`algorithmicx`

You can define your own keywords when using the algorithmicx package. Section 3.1.10 Changing command names of the package documentation discusses the use of \algnewcommand/\algrenewcommand that you can use to create a new command/change existing formatting. The following two images are taken directly from the package documentation:

$Algorithmicx \algnewcommand$

$Algorithmicx \algrenewcommand$

`algorithm2e`

You can also define your own keywords using the algorithm2e package. Section 10 To define your own language keywords of the package documentation discusses this in detail. Specifically, you use commands like

\SetKwInput and \SetKwOutput for algorithm input / output definition
\SetKw for keyword definitions
\SetKwBlock for block definitions
\SetKwFunction for function / procedure definitions
\SetKwComment for comment definitions
\SetKwIf for if-statement definitions
\SetKwSwitch for multiple condition selection definitions
\SetKwFor for for loop definitions
\SetKwRepeat for repeat / while definitions

`listings`

Then there's the listings package that allows just as much modification. Keyword definitions are specified via styles and/or languages. Read the highly detailed package documentation for more information on this.

`tabbing`

The above use some rich programming directives from package that probably require a lot of reading. In the special case where you "just want to write a couple of lines of code and format stuff your own way", you could use the tabbing environment. This is either provided by LaTeX (as default) or by the tabbing package. The tabbing package documentation gives some motivation for using it, but that's up to you.

A typical tabbing environment would resemble

\begin{tabbing}
  <space> \= <space> \= <space> \= <space> \= \kill
  no indent \> \> more text \\
  \> one indent \> \\
  ....
  ....
\end{tabbing}

where the tab stops a indicated by \= and jumped to by using \>. It is best to put empty spacing in the first row (via \hspace{<space>}, \quad, \qquad or \phantom{<stuff>}), since a first-line \kill is provided (as opposed to \\[-\baselineskip]) to prevent the first line from being typeset. This ensures that the actual tabbing typesetting starts in the first row.

The advantage here is that you can format your code the way you want, without any special package "interrupting" your style or other preferences. Given your example, here is what I would do (without using \multicol):

\documentclass{article}
\usepackage{calc}% For length calculations
\begin{document}

\newlength{\mylen}%
\setlength{\mylen}{\linewidth-2\fboxsep-2\fboxrule}%

\fbox{\begin{minipage}{\mylen}
  \begin{tabbing}
    \quad \= \quad \= \quad \= \hspace{5cm} \= \kill
    \textbf{program} test \> \> \> \> \texttt{some text here} \\
    \textbf{var} \\
    \> $i$ : \textbf{integer}; \> \> \> \texttt{...} \\
    \> $b$ : \textbf{boolean}; \\
    \textbf{begin} \\
    \> $i:=1$; \> \> \> \texttt{...} \\
    \> $b:=\texttt{true}$; \\
    \> \textbf{while} $i<15$ \textbf{do} \\
    \> \> $i:=i+1$; \\
    \> \> $b:=\textbf{not}\ b$; \> \> \texttt{some text here} \\
    \> \textbf{od} \\
    \textbf{end}
  \end{tabbing}
\end{minipage}}

\end{document}

LaTeX tabbing example

`verbatim`

The verbatim environment is a paragraph-making environment that gets LaTeX to print exactly what you type in. It turns LaTeX into a typewriter with carriage returns and blanks having the same effect that they would on a typewriter. The output looks exactly as it looks in the input file. Typical typesetting in verbatim would resemble

\begin{verbatim}
  <stuff> 
\end{verbatim}

\begin{verbatim*}
  <stuff>
\end{verbatim*}

where the difference between verbatim and verbatim* is that the latter prints spaces as "visual" spaces, i.e., a short, squat "u". Inline verbatim is also possible using

\verb char literal_text char

\verb*char literal_text char

with a similar meaning as before for the unstarred and starred versions. There may be no space between \verb or \verb* and char (space is shown here only for clarity). Here char denotes the \verb delimiters and should match at the start and end. char can be anything except a space (or a * for the \verb form).

Related Solutions

[Tex/LaTex] \footnotemark and \footnotetext in minipage

Footnotes within minipage environments are printed with small letters. The definition in latex.ltx is

\def\thempfootnote{{\itshape\@alph\c@mpfootnote}}

You could redefine it. A quick way would be:

\let\thempfootnote\thefootnote

Afterwards the footnote symbols within a minipage will be an arabic number as well.

[Tex/LaTex] How to place a program and a text side by side

I assume that your program/code does not have to float around in your text, although it is also possible to construct something to that effect that floats in your document.

You can use the multicol package to generate a 2-column environment, placing your program/code on the left in a minipage environment. This sample code

\documentclass{article}
\usepackage[margin=25mm]{geometry}
\usepackage{algpseudocode}
\usepackage{multicol}
\begin{document}

\begin{multicols}{2}% 2-column layout
  \begin{minipage}{0.45\textwidth}
    \begin{algorithmic}[1]% Taken from the algorithmicx package documentation
      \Procedure{Euclid}{$a,b$}
      \State $r\gets a\bmod b$
      \While{$r\not=0$}
        \State $a\gets b$
        \State $b\gets r$
        \State $r\gets a\bmod b$
      \EndWhile\label{euclidendwhile}
      \State \textbf{return} $b$
      \EndProcedure
    \end{algorithmic}
  \end{minipage}
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum venenatis facilisis arcu, a malesuada elit vulputate quis. Duis et interdum eros. Maecenas ac sem at elit rutrum vehicula eu et elit. In convallis justo in arcu condimentum a adipiscing tortor auctor. Nam adipiscing ante sed ante vehicula tincidunt. Morbi volutpat purus tortor, a venenatis turpis. Vestibulum tristique augue ut dui cursus a aliquam velit volutpat.
\end{multicols}

\end{document}

produces

Program code on left|decription on right

Here you have to be careful that the description length does not exceed the program code. The program code above was produced using algpseudocode from the algorithmicx package. The look of the algorithm can be changed in many ways, as suggested in the package documentation. For instance, here is a different line numbering style (producing l1, l2,...,l9):

\algrenewcommand{\alglinenumber}[1]{\footnotesize\texttt{l}#1:}% l1, l2, ...

Algorithmicx showing a different line numbering style (<10 lines)

As you can see, this works well for pseudocode that has less than 10 lines. To accommodate for more lines, you could use:

\algrenewcommand{\alglinenumber}[1]{\footnotesize\texttt{l}\ifnum#1<10 \phantom{0}\fi #1:}% l 1, l 2, ... l 9, l10, l11, ...

Algorithmicx showing a different line numbering style (<99 lines)

Alternatively, placing the two respective components (program/code and description) in a minipage each would allow you to deviate from the length restriction, just like in @xport's answer. The listings package is used to import and format the code.

None of these approaches allow the program/code and description components to flow across pages, since the minipage environment does not break across pages.

Best Answer

algorithmicx

algorithm2e

listings

tabbing

verbatim