Universe

This is a package inspired by the LaTeX algorithmicx package for Typst. It’s useful for writing pseudocode and typesetting it all nicely.

screenshot of the typst-algorithmic output, showing line numbers, automatic indentation, bolded keywords, and such

Example:

#import "@preview/algorithmic:1.0.0"
#import algorithmic: algorithm

#algorithm({
  import algorithmic: *
  Procedure(
    "Binary-Search",
    ("A", "n", "v"),
    {
      Comment[Initialize the search range]
      Assign[$l$][$1$]
      Assign[$r$][$n$]
      LineBreak
      While(
        $l <= r$,
        {
          Assign([mid], FnInline[floor][$(l + r) / 2$])
          IfElseChain(
            $A ["mid"] < v$,
            {
              Assign[$l$][$m + 1$]
            },
            [$A ["mid"] > v$],
            {
              Assign[$r$][$m - 1$]
            },
            Return[$m$],
          )
        },
      )
      Return[*null*]
    },
  )
})

This DSL is implemented using the same trick as CeTZ uses: a code block of arrays gets those arrays joined together.

Reference

Documentation

algorithm(inset: 0.2em, ..bits)

This is the main function of the package. It takes a list of arrays and returns a typesetting of the algorithm. You can modify the inset between lines with the inset parameter.

#algorithm(
  inset: 1em, // more spacing between lines
  { // provide an array
    import algorithmic: * // import all names in the array
    Assign[$x$][$y$]
  },
  { // provide another array
    import algorithmic: *
    Assign[$y$][$x$]
  },
  { // provide a third array
    import algorithmic: *
    Assign[$z$][$x + y$]
  }
)

algorithm-figure(title, supplement: "Algorithm", inset: 0.2em, ..bits)

The algorithm-figure function is a wrapper around algorithm that returns a figure element of the algorithm. It takes the same parameters as algorithm, but also takes a title and a supplement parameter for the figure.

#let algorithm-figure(title, supplement: "Algorithm", inset: 0.2em, ..bits) = {
  return figure(
    supplement: supplement,
    kind: "algorithm", // the kind of figure
    caption: title,
    placement: none,
    algorithm(inset: inset, ..bits),
  )
}

In order to use the algorithm-figure function, you need to style the figure with the style-algorithm show rule.

#import algorithmic: algorithm-figure, style-algorithm
#show: style-algorithm // Do not forget!
#algorithm-figure(
  "Variable Assignement",
  {
    import algorithmic: *
    Assign[$x$][$y$]
  },
)

Control flow

Algorithmic provides basic control flow statements: If, While, For, Else, ElseIf, and a IfElseChain utility.

Statement Description Usage Example
If If(condition: content, ..bits) 
If($x < y$, {
  Assign[$x$][$y$]
})
image of an if statement with condition x < y and conditional statement assign y to x
ElseIf ElseIf(condition: content, ..bits) 
ElseIf($x > y$, {
  Assign[$y$][$x$]
})
image of an elseif statement with condition x > y and conditional statement assign x to y
Else Else(..bits) 
Else({
  Return[$y$]
})
image of an else statement with conditional statement return y
While While(condition: content, ..bits) 
While($i < 10$, {
  Assign[$i$][$i + 1$]
})
image of a while statement with condition i < 10 and conditional statement assign i + 1 to i
For For(condition: content, ..bits) 
For($i <= 10$, {
  Assign[$x_i$][$i$]
})
image of a for loop with condition i <= 10 and conditional statement assign i to x_i
IfElseChain IfElseChain(..bits) 
IfElseChain( // Alternating content and bits
  $x < y$, // If: content 1 (condition)
  { // Then: bits 1
    Assign[$x$][$y$]
  },
  [$x > y$], // ElseIf: content 2 (condition)
  { // Then: bits 2
    Assign[$y$][$x$]
  },
  Return[$y$], // Else: content 3 (no more bits afterwards)
)
image of an ifelsechain statement with condition x < y and conditional statement assign y to x, then condition x

Commands

The package provides a few commands: Function, Procedure, Assign, Return, Terminate and Break.

Users can also define their own commands using both Call(..args) and Fn(..args) and their inline versions CallInline and FnInline.

#import "../../algorithmic.typ"
#import algorithmic: algorithm
#set page(margin: .1cm, width: 4cm, height: auto)
#algorithm({
  import algorithmic: *
  let Solve = Call.with("Solve")
  let mean = Fn.with("mean")
  Assign($x$, Solve[$A$, $b$])
  Assign($y$, mean[$x$])
})

image of a custom call "Solve" given parameters "A" and "b" and a custom function "mean" given parameter "x" in the algorithmic environment. The call "Solve" is rendered in smallcaps and the function "mean" is rendered in a strong emphasis.

Comments

There are three kinds of comments: Comment, CommentInline, and LineComment.

  1. Comment is a block comment that takes up a whole line.
  2. CommentInline is an inline comment that returns content on the same line.
  3. LineComment places a comment on the same line as a line of code to the right.
Command Description Usage Example
Function Function(name, args, ..bits) 
Function("Add", ($a$, $b$), {
Assign[$a$][$b$]
})
image of a function definition with name 'Add' and arguments 'a' and 'b' with body 'return a+b'
Procedure Procedure(name, args, ..bits) 
Procedure("Add", ("a", "b"), {
Assign[$a$][$a+b$]
})
image of a procedure definition with name 'Add' and arguments 'a' and 'b' with body 'assign a+b to a'
Assign Assign(var, value) 
Assign[$x$][$y$]
image of an assignment statement assigning y to x
Return Return(value) 
Return[$x$]
image of a return statement returning x
Terminate Terminate(value) 
Terminate[$x$]
image of a terminate statement terminating x
Break Break() 
Break()
image of a break statement
Comment Description Usage Example
Comment Comment(content) 
Comment[This is a comment]
image of a block comment with text 'This is a comment'
CommentInline CommentInline(content) 
CommentInline[This is a comment]
image of an inline comment with text 'This is a comment'
LineComment LineComment(line, comment) 
LineComment(Assign[a][1], [Initialize $a$ to 1])
image of a line comment with text 'Initialize a to 1'