Step 5: Add constraints

Recall that constraints could be thought of as rules that need to be followed while building the optmization model. The business rules that are used for the purpose of this article are as follows.
1. Each staff can only work one shift per day.
2. Every shift must have at least one person staffed.
3. Each staff works for a maximum of 5 days a week.
4. Each shift must have at least one person staffed from each of the three skills.

The R code to deploy these constraints uses the function add_constraint() to apply a constraint. Within this function is nested another function sum_expr() that helps in formulating the constraint mathematically. Although this article provides relatively simpler set of constraints, understanding the sum_expr() function will help one to add many more complex constraints.

At the time of publishing this article, the official documentation of the sum_expr() function is very minimal as given below.

#Usage
sum_expr(expr, ...)
Arguments
expr an expression that can be expanded to a sum
... bind variables in expr using dots. See examples.
Value
the expanded sum as an AST

The author offers the following perspective in an attempt to help readers understand the usage of this function. It must be noted that this perspective is more of an opinion and may not reflect the actual functioning of the underlying code.

The function in its nested form i.e. add_constraint(sum_expr()) could be understood as follows.

add_constraint(sum_expr(<set_of_variables>, <aggregate_variable(s)>)<equality/inequality><constant/variable>, <group_by_variables>)

The above code in terms of an SQL sense could be understood roughly as follows.

select sum(<aggregate_variable(s)>)
from <set_of_variables>
where <equality/inequality><constant/variable>
group by <group_by_variables>

This representation could be understood further with the help of an example. The first constraint i.e. each staff can only work one shift per day is represented as follows.

#each staff can work a maximum of 1 shift a day
add_constraint(sum_expr(x[i,j,k], k = 1:numOfShifts) <= 1, i = 1:numOfStaff, j = 1:numOfDays)

The above representation can be understood as follows

1. Consider the variables `x[i,j,k]`. Note that with 6 staff, 7 days and 3 shifts, these variables are 126 in total.

2. Of these variables, for every combination of `i = 1:numOfStaff, j = 1:numOfDays` i.e. for a given staff on a given day, the sum of `k = 1:numOfShifts` must be `<= 1`.

3. To summarize, the constraint states that for any given staff on any given day, the number of shifts that they can be staffed are at best one shift.

4. Additionally, it must be noted that the `<=1` need not be a constant but a variable or an expression. This means that one could have another `sum_expr()` function in place of the `1`.

The understanding so far is expected to help the readers understand the rest of the constraints relatively easily.
5. The next constraint each shift must have at least one person staffed is represented as follows. It means that for any given day and shift, there is 1 or more staff scheduled.

#each shift each day must have at least 1 staff
add_constraint(sum_expr(x[i,j,k], i = 1:numOfStaff) >= 1, j = 1:numOfDays, k = 1:numOfShifts) %>%

6. The next constraint each staff works for a maximum of 5 days a week is represented as follows. It means that for any given staff, the days and shifts they are scheduled is 5 or less.

#each staff can work a maximum of 5 days a week
add_constraint(sum_expr(x[i,j,k], j = 1:numOfDays, k = 1:numOfShifts) <= 5, i = 1:numOfStaff) %>%

The next 3 constraints namely each shift must have at least one person staffed from each of the three skills is represented as follows. The code is similar across the 3 skills and the author explains only one example for brevity.

#ensure that each day has at least 1 staff from skill "a"
add_constraint(sum_expr(checkSkill(staff = i, skill = "a") * x[i,j,k], i = 1:numOfStaff) >= 1, j = 1:numOfDays, k = 1:numOfShifts) %>% 

7. The first step in understanding these three constraints is the function checkSkill() which is built as follows.

checkSkill <- function(staff, skill)
{
#if the staff has the skill then, return 1 else 0
skillPresence <- nrow(skillMix[skillMix$staffId == staff & skillMix$skill == skill,])
return(skillPresence)
}

This function takes the staffId and skill as inputs and returns 1 if the given staffId has the given skill otherwise, it returns zero. Since checkSkill(staff = i, skill = “a”) is multiplied with x[i,j,k] , the outcome will be at least 1 only if the staff has the given skill. Thus, for any given day and shift, there will be at least one staff with the given skill. These steps are repeated for each of the skill.

8. The final step is to run the optimization and source the results. This is accomplished with the following code.

#solve integer programming model
result <- solve_model(model, with_ROI(solver = "glpk", verbose = TRUE))

If the optimal solution is not found, the model will throw an error glp_intopt: optimal basis to initial LP relaxation not provided. In such cases, one could change the constraints or add more variables to arrive at an optimal solution. It must be noted that although the author used the glpk solver, there are other solvers available with the package.

In order to use the model results in an interpretable manner, one could use the following steps.

1. Use the function get_solution() to retrieve the staff(i), day(j), shift(k) and rostered(value) data. Note that if the given staff is rostered for the given day and shift, then the rostered data will have 1 otherwise, it will be coded 0.

roster <- result %>% 
get_solution(x[i,j,k]) 

2. Select relevant data and rename the columns to understandable names.

roster <- roster[,c("i", "j", "k","value")]

#set readable column names
colnames(roster) <- c("staff", "day" , "shift" , "rostered") 

3. The roster for each staff can be visualized with the following code.

xtabs(rostered~ day + shift + staff, data = roster)