dynprog - Domain-specific language for specifying dynamic programming computations

The dynprog package implements a small domain-specific language for specifying dynamic programming algorithms. It allows you to specify a computation as a recursion and it will then use this recursion to fill out a table and return it to you.

As a very simple example, you can specify a dynamic programming computation of Fibonnaci numbers using

fibs <- {
    F[1] <- 1
    F[2] <- 1
    F[n] <- F[n - 1] + F[n - 2]
} %where% {
    n <- 1:10
}

fibs
#>  [1]  1  1  2  3  5  8 13 21 34 55

As shown in the example, the expression consists of two parts, the first, before the %where% operator, describes a recursion and the second, after the %where% operator, the range the variable n should iterate over.

Formally, a dynprog expression is on the form

DYNPROG_EXPR ::= RECURSIONS '%where%' RANGES
RECURSIONS ::= '{' PATTERN_ASSIGNMENTS '}'
RANGES ::= '{' RANGES_ASSIGNMENTS '}'

where PATTERN_ASSIGNMENTS describe the recursion and RANGES_ASSIGNMENTS the variables to recurse over and the values those variables should take.

Ranges are the simplest of the two.

RANGES_ASSIGNMENTS ::= RANGES_ASSIGNMENT
                    |  RANGES_ASSIGNMENT ';' RANGES_ASSIGNMENTS
RANGES_ASSIGNMENT ::= RANGE_INDEX '<-' RANGE_EXPRESSION

where RANGE_INDEX is just a variable and RANGE_EXPRESSION an expression that should evaluate to a list or vector. You can specify more than one variable if these are separated by ; or newlines (the grammar only says ; but I am not too formal here). An example with two range variables, of computing the edit distance between two strings, is shown below.

The actual recursions are specified in PATTERN_ASSIGNMENTS:

PATTERN_ASSIGNMENTS ::= PATTERN_ASSIGNMENT
                     |  PATTERN_ASSIGNMENT ';' PATTERN_ASSIGNMENTS

where

PATTERN_ASSIGNMENT ::= PATTERN '<-' RECURSION
                    |  PATTERN '<-' RECURSION '?' CONDITION

PATTERN ::= TABLE '[' INDICES ']'

Here, TABLE is just a variable and INDICES should be a comma-separated lists of values/expressions or variables. When recursions are evaluated, the range variables are tested against the patterns. If a pattern contains a range variable as a variable, the variable is free to take any value, but if it takes on a value, the range variable must have that value.

To the right of the assignment in PATTERN_ASSIGNMENTS we have RECURSION, which cna be any R expression and an optional CONDITION, which should be an R expression that evaluates to a boolean value.

The semantics of the recursions are that the patterns are tested in the order they are provided, and if both the patterns match the range variables and the condition evaluates to TRUE, then the entry in the table will get assigned the result of evaluating RECURSION.

For more information, see

Mailund, T. (2018) Domain-Specific Languages in R, Apress. ISBN 1484235878

Installation

You can install the released version of dynprog from CRAN with:

install.packages("dynprog")

and the development version from GitHub with:

# install.packages("devtools")
devtools::install_github("mailund/dynprog")

Example

You can compute the edit-distance between two strings like this:

x <- c("a", "b", "c")
y <- c("a", "b", "b", "c")
edit <- {
  E[1,j] <- j - 1
  E[i,1] <- i - 1
  E[i,j] <- min(
      E[i - 1,j] + 1,
      E[i,j - 1] + 1,
      E[i - 1,j - 1] + (x[i - 1] != y[j - 1])
 )
} %where% {
    i <- 1:(length(x) + 1)
    j <- 1:(length(y) + 1)
}

edit
#>      [,1] [,2] [,3] [,4] [,5]
#> [1,]    0    1    2    3    4
#> [2,]    1    0    1    2    3
#> [3,]    2    1    0    1    2
#> [4,]    3    2    1    1    1