lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/examples/chip0.py

@@ -0,0 +1,29 @@
+# model and solve the LP
+#
+# maximize 10 x1 + 25x2
+# s. t.       x1 +  2x2 <= 80
+#             x1 +  4x2 <= 120
+#             x1 >= 0; x2 >= 0
+import highspy
+
+h = highspy.Highs()
+
+x1 = h.addVar(obj = 10)
+x2 = h.addVar(obj = 25)
+
+h.addConstr(x1 + 2*x2 <= 80)
+h.addConstr(x1 + 4*x2 <= 120)
+
+h.writeModel("")
+print("x1 = ", h.val(x1))
+print("x2 = ", h.val(x2))
+
+h.maximize()
+
+print("x1 = ", h.val(x1))
+print("x2 = ", h.val(x2))
+
+print("x = ", h.vals([x1, x2]))
+
+
+

data/ext/lpsolver-highs/examples/distillation.py

@@ -0,0 +1,77 @@
+# model and solve the problem, first as an LP, then as a MIP
+#
+# minimize 8 TypeA +  10 TypeB
+# s. t.    2 TypeA +   2 TypeB >=  7: Product1
+#          3 TypeA +   4 TypeB >= 12: Product2
+#          2 TypeA +   1 TypeB >=  6: Product3
+#            TypeA >= 0; TypeB >= 0
+
+import highspy
+width, precision = (4, 3)   # for printing
+
+h = highspy.Highs()
+h.silent()
+
+variableNames = ['TypeA', 'TypeB']
+x = h.addVariables(variableNames, obj = [8, 10], name = variableNames)
+
+constrNames = ['Product1', 'Product2', 'Product3']
+cons = h.addConstrs(2*x['TypeA'] + 2*x['TypeB'] >=  7,
+                    3*x['TypeA'] + 4*x['TypeB'] >= 12,
+                    2*x['TypeA'] +   x['TypeB'] >=  6, name = constrNames)
+
+h.setMinimize()
+
+status = h.writeModel('Distillation.lp')
+print(f"writeModel('Distillation.lp') status = {status}")
+
+status = h.writeModel('Distillation.mps')
+print(f"writeModel('Distillation.mps') status = {status}")
+
+
+print()
+print('# Solve as LP')
+
+h.solve()
+
+for name, var in x.items():
+    print(f'Use {h.variableValue(var):.1f} of {name}: reduced cost {h.variableDual(var):.6f}')
+    
+print()
+print('Use', h.vals(x))
+print('Use', h.allVariableValues(), 'of', h.allVariableNames())
+print()
+
+for c in cons:
+    print(f"Constraint {c.name} has value {h.constrValue(c):{width}.{precision}} and dual  {h.constrDual(c):{width}.{precision}}")
+
+print('Constraints have values', h.constrValues(cons), 'and duals', h.constrDuals(cons))
+print('Constraints have values', h.allConstrValues(), 'and duals', h.allConstrDuals())
+print(f"Optimal objective value is {h.getObjectiveValue():{width}.{precision}}")
+
+
+print()
+print()
+print('# Solve as MIP')
+
+h.setInteger(x.values())
+h.solve()
+
+for var in x.values():
+    print(f"Use {h.variableValue(var):{width}.{precision}} of {h.variableName(var)}")
+print(f"Optimal objective value is {h.getObjectiveValue():{width}.{precision}}")
+
+print()
+print()
+print('# Solve as LP with Gomory cut')
+
+# Make the variables continuous
+h.setContinuous(x.values())
+
+# Add Gomory cut
+h.addConstr(x['TypeA'] + x['TypeB'] >= 4, name = "Gomory")
+h.solve()
+
+for var in x.values():
+    print(f"Use {h.variableValue(var):{width}.{precision}} of {h.variableName(var)}")
+print(f"Optimal objective value is {h.getObjectiveValue():{width}.{precision}}")

data/ext/lpsolver-highs/examples/knapsack.py

@@ -0,0 +1,43 @@
+# Simple knapsack example to illustrate setSolution
+# max 8x1 + 5x2 + 3x3 + 11x4 + 7x5
+#     4x1 + 3x2 + 1x3 +  5x4 + 4x5 <= 11
+
+import numpy as np
+import highspy
+
+def print_solution(h, x):
+    print(f"Solution: ({', '.join(map(str, abs(h.val(x))))})")
+
+h = highspy.Highs()
+h.silent()
+h.setOptionValue("presolve", "off")
+
+x = h.addBinaries(5)
+h.addConstr((x * [4, 3, 1, 5, 4]).sum() <= 11)
+h.maximize((x * [8, 5, 3, 11, 7]).sum())
+    
+# solution is [1, 0, 1, 1, 0]
+print_solution(h, x)
+
+
+# Illustrate setSolution
+# First by passing back the optimal solution
+h.clearSolver()
+h.setSolution(h.getSolution())
+h.run()
+print_solution(h, x)
+
+# Now passing back the optimal values of two variables as a sparse solution
+h.clearSolver()
+index = np.array([0, 3])
+value = np.array([1, 1], dtype=np.float64)
+h.setSolution(2, index, value)
+h.run()
+print_solution(h, x)
+
+# Test passing back the optimal value of one variable, and a non-optimal value of another, as a sparse solution in untyped array
+h.clearSolver()
+h.setSolution(2, np.array([0, 4]), np.array([1, 1]))
+h.run()
+print_solution(h, x)
+

data/ext/lpsolver-highs/examples/minimal.py

@@ -0,0 +1,11 @@
+import highspy
+
+h = highspy.Highs()
+
+x1 = h.addVariable(lb = -h.inf)
+x2 = h.addVariable(lb = -h.inf)
+
+h.addConstrs(x2 - x1 >= 2, 
+             x1 + x2 >= 0)
+
+h.minimize(x2)

data/ext/lpsolver-highs/examples/multi_objective.py

@@ -0,0 +1,139 @@
+# Multi-objective binary knapsack example
+from highspy import Highs, HighsLinearObjective
+import numpy as np
+
+# Parameters
+capacity = 13
+
+# chosen such that applying each objective lexicographically gives a different solution
+profit = np.asarray([
+        [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1],
+        [1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
+        [1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,0,0],
+        [1,1,1,1,0,1,0,0,1,1,0,0,0,1,1,1,0,0,0,0],
+
+    ], dtype=np.float64).reshape(4, 20)
+
+OBJECTIVES = profit.shape[0]
+ITEMS = profit.shape[1]
+
+def pretty_print(objective_values):
+    return '[ ' + ', '.join(map(lambda x: "{:2.0f}".format(x), objective_values)) + ' ]'
+
+#
+# individual optimization of each objective
+def individual_objectives(h, X):
+    print('## Individual:\n')
+    objective_values = []
+
+    for k in range(OBJECTIVES):
+        h.maximize(np.dot(X, profit[k,:]))
+        print(f'  Obj {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), profit[k,:]))}]')
+        print(f'  Sol {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]\n')
+        objective_values.append(h.getObjectiveValue())
+
+    print(f'  OBJ: {pretty_print(objective_values)}\n\n')
+
+#
+# manual implementation of lexicographic multi-objective optimization
+def manual_lexicographic(h, X):
+    print('## Manual lexicographic:\n')
+    cons = []
+    objs = np.dot(profit, X)
+
+    for k in range(OBJECTIVES):
+        h.maximize(objs[k])
+        print(f'  Obj {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), profit[k,:]))}]')
+        print(f'  Sol {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]\n')
+
+        # add constraint to ensure next solution are at least as good in this objective
+        cons.append(h.addConstr(np.dot(profit[k,:], X) >= h.getObjectiveValue()))
+
+    objective_values = h.vals(objs)
+    h.deleteRows(len(cons), cons)  # clean up constraints
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(objective_values)}\n\n')
+
+
+#
+# built-in lexicographic multi-objective optimization
+def highs_lexicographic(h, X):
+    print('## Built-in lexicographic:\n')
+    h.setOptionValue('blend_multi_objectives', False) # use lexicographic
+
+    for k in range(OBJECTIVES):
+        obj = HighsLinearObjective()
+        obj.coefficients = profit[k,:].tolist()
+        obj.weight = -1    # maximize
+        obj.priority = -k  # higher priority for lower k
+        obj.abs_tolerance = 0.01
+        obj.rel_tolerance = 0.001
+
+        h.addLinearObjective(obj)
+
+    h.solve()
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n\n')
+
+    print(f'  Number of objectives: {h.getNumLinearObjectives()}')
+    for k in range(h.getNumLinearObjectives()):
+        obj = h.getLinearObjective(k)
+        print(f'  Obj {k+1}: weight={obj.weight}, priority={obj.priority}, abs_tol={obj.abs_tolerance}, rel_tol={obj.rel_tolerance}')
+    print('\n')
+
+    h.clearLinearObjectives()
+
+
+#
+# manual implementation of weighted multi-objective optimization
+def manual_weighted(h, X):
+    print('## Manual Weighted:\n')
+    weights = np.asarray([1.0/(k+1) for k in range(OBJECTIVES)], dtype=np.float64)
+    h.maximize(np.dot(weights[:,None] * profit, X).sum())
+
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n')
+
+    print(f'  Obj: {h.getObjective()[0]}\n\n')
+
+
+#
+# built-in weighted multi-objective optimization
+def highs_weighted(h, X):
+    print('## Built-in Weighted:\n')
+    h.setOptionValue('blend_multi_objectives', True) # use weighted
+
+    for k in range(OBJECTIVES):
+        obj = HighsLinearObjective()
+        obj.coefficients = profit[k,:].tolist()
+        obj.weight = -1.0/(k+1)
+
+        h.addLinearObjective(obj)
+
+    h.solve()
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n')
+
+    print(f'  Number of objectives: {h.getNumLinearObjectives()}')
+    for k in range(h.getNumLinearObjectives()):
+        obj = h.getLinearObjective(k)
+        print(f'  Obj {k+1}: weight={obj.weight}, priority={obj.priority}, abs_tol={obj.abs_tolerance}, rel_tol={obj.rel_tolerance}')
+    print('\n')
+
+    h.clearLinearObjectives()
+
+
+if __name__ == "__main__":
+    h = Highs()
+    h.silent(True)
+
+    X = h.addBinaries(ITEMS)
+    h.addConstr(X.sum() <= capacity)
+
+    individual_objectives(h, X)
+
+    manual_lexicographic(h, X)
+    manual_weighted(h, X)
+
+    highs_lexicographic(h, X)
+    highs_weighted(h, X)

data/ext/lpsolver-highs/examples/multiple_objective.py

@@ -0,0 +1,120 @@
+import numpy as np
+import highspy
+
+hscb = highspy.cb 
+
+h = highspy.Highs()
+h.setOptionValue("output_flag", False);
+
+inf = highspy.kHighsInf
+lp = highspy.HighsLp()
+lp.num_col_ = 2
+lp.num_row_ = 3
+lp.col_cost_ = np.array([0, 0], dtype=np.double)
+lp.col_lower_ = np.array([0, 0], dtype=np.double)
+lp.col_upper_ = np.array([inf, inf], dtype=np.double)
+lp.row_lower_ = np.array([-inf, -inf, -inf], dtype=np.double)
+lp.row_upper_ = np.array([18, 8, 14], dtype=np.double)
+lp.a_matrix_.start_ = np.array([0, 3, 6])
+lp.a_matrix_.index_ = np.array([0, 1, 2, 0, 1, 2])
+lp.a_matrix_.value_ = np.array([3, 1, 1, 1, 1, 2], dtype=np.double)
+h.passModel(lp)
+# LP constraints are
+#
+# 3x +  y <= 18
+#
+#  x +  y <= 8
+#
+#  x + 2y <= 14
+linear_objective0 = highspy.HighsLinearObjective()
+linear_objective0.weight = -1
+linear_objective0.offset = -1
+linear_objective0.coefficients = np.array([1, 1], dtype=np.double)
+linear_objective0.abs_tolerance = 0
+linear_objective0.rel_tolerance = 0
+linear_objective0.priority = 10
+
+linear_objective1 = highspy.HighsLinearObjective()
+linear_objective1.weight = 1e-4
+linear_objective1.offset = 0
+linear_objective1.coefficients = np.array([1, 0], dtype=np.double)
+linear_objective1.abs_tolerance = -1
+linear_objective1.rel_tolerance = -1
+linear_objective1.priority = 0
+
+h.addLinearObjective(linear_objective0)
+h.addLinearObjective(linear_objective1)
+# Objectives
+#
+# f0: x + y - 1 (weight -1)
+#
+# f1: x         (weight 1e-4)
+#
+# With objective min -f0 (since its weight is -1) the LP has nonunique
+# optimal solutions on the line joining (2, 6) and (5, 3)
+#
+# Blending -f0 + 1e-4 f1 minimizes x along the line joining (2, 6) and
+# (5, 3) to give optimal solution at (2, 6) with objective -7
+h.run()
+solution = h.getSolution()
+print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}) for min -f0 + 1e-4 f1")
+
+# Switch to lexicographic optimization 
+h.setOptionValue("blend_multi_objectives", False);
+
+linear_objective0.coefficients = np.array([1.0001, 1], dtype=np.double)
+linear_objective0.abs_tolerance = 1e-5;
+linear_objective0.rel_tolerance = 0.05;
+linear_objective1.weight = 1e-3
+
+h.clearLinearObjectives()
+h.addLinearObjective(linear_objective0)
+h.addLinearObjective(linear_objective1)
+# Objectives
+#
+# f0 = 1.0001 x + y - 1 (with priority 10 and absolute tolerance 1e-5)
+#
+# f1 =        x         (with priority  0)
+#
+# Lexicographically: HiGHS 
+#
+# minimizes f0 (to give objective 7.0005) 
+#
+# adds a constraint that
+#
+# 1.0001 x + y - 1 >= 7.0005 - 1e-5 => 1.0001 x + y >= 8.00049
+#
+# to ensure that the initial objective is within 1e-5 of its optimal
+# value
+#
+# minimizes f1 to give optimal solution at (4.90000, 3.10000) - where
+# x + y = 8 and 1.0001 x + y = 8.00049
+
+h.run()
+solution = h.getSolution()
+print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}) for min f1 and 1.0001 x + y >= 8.00049")
+
+linear_objective0.abs_tolerance = -1;
+h.clearLinearObjectives()
+h.addLinearObjective(linear_objective0)
+h.addLinearObjective(linear_objective1)
+# Objectives as before, but absolute tolerence for f0 now -1 (negative
+# => ignored) so relative tolerance of 0.05 is used
+#
+# Lexicographically: HiGHS 
+#
+# minimizes f0 (to give objective 7.0005) 
+#
+# adds a constraint that
+#
+# 1.0001 x + y - 1 >= 7.0005 * 0.95 => 1.0001 x + y >= 7.650475
+#
+# to ensure that the initial objective 95% of its optimal value
+#
+# minimizes f1 to give optimal solution at (1.30069, 6.34966) - where
+# x + y = 8 and 1.0001 x + y = 7.650475
+h.run()
+solution = h.getSolution()
+print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}) for min f1 and 1.0001 x + y = 7.650475")
+
+

data/ext/lpsolver-highs/examples/network_flow.py

@@ -0,0 +1,37 @@
+# Example of a shortest path network flow in a graph
+# Shows integration of highspy with networkx
+
+import highspy
+import networkx as nx
+
+orig, dest = ('A', 'D')
+
+# create directed graph with edge weights (distances)
+G = nx.DiGraph()
+G.add_weighted_edges_from([('A', 'B', 2.0), ('B', 'C', 3.0), ('A', 'C', 1.5), ('B', 'D', 2.5), ('C', 'D', 1.0)])
+
+h = highspy.Highs()
+h.silent()
+
+x = h.addBinaries(G.edges, obj=nx.get_edge_attributes(G, 'weight'))
+
+# add flow conservation constraints
+#                        {  1  if n = orig
+#   sum(out) - sum(in) = { -1  if n = dest
+#                        {  0     otherwise
+rhs  = lambda n: 1 if n == orig else -1 if n == dest else 0
+flow = lambda E: h.qsum((x[e] for e in E))
+
+h.addConstrs(flow(G.out_edges(n)) - flow(G.in_edges(n)) == rhs(n) for n in G.nodes)
+h.minimize()
+
+# Print the solution
+print('Shortest path from', orig, 'to', dest, 'is: ', end = '')
+sol = h.vals(x)
+
+n = orig
+while n != dest:
+    print(n, end=' ')
+    n = next(e[1] for e in G.out_edges(n) if sol[e] > 0.5)
+
+print(dest)

data/ext/lpsolver-highs/examples/nqueens.py

@@ -0,0 +1,29 @@
+# This is an example of the N-Queens problem, which is a classic combinatorial problem.
+# The problem is to place N queens on an N x N chessboard so that no two queens attack each other.
+#
+# We show how to model the problem as a MIP and solve it using highspy.
+# Using numpy can simplify the construction of the constraints (i.e., diagonal).
+
+import highspy
+import numpy as np
+
+N = 8
+h = highspy.Highs()
+h.silent()
+
+x = h.addBinaries(N, N)
+
+h.addConstrs(x.sum(axis=1) == 1)    # each row has exactly one queen
+h.addConstrs(x.sum(axis=0) == 1)    # each col has exactly one queen
+
+y = np.fliplr(x)
+h.addConstrs(x.diagonal(k).sum() <= 1 for k in range(-N + 1, N))   # each diagonal has at most one queen
+h.addConstrs(y.diagonal(k).sum() <= 1 for k in range(-N + 1, N))   # each 'reverse' diagonal has at most one queen
+
+h.solve()
+sol = h.vals(x)
+
+print('Queens:')
+
+for i in range(N):
+    print(''.join('Q' if sol[i, j] > 0.5 else '*' for j in range(N)))

data/ext/lpsolver-highs/examples/plot_highs_log.py

@@ -0,0 +1,134 @@
+import re
+import matplotlib.pyplot as plt
+import numpy as np
+import math as math
+
+
+def parse_highs_log(log_file_path):
+    last_full_entry = []
+    current_entry = []
+    found_solution = False
+
+    with open(log_file_path, "r") as f:
+        for line in f:
+            if "Running HiGHS" in line:
+                if found_solution:
+                    last_full_entry = current_entry
+                current_entry = [line]
+                found_solution = False
+            else:
+                current_entry.append(line)
+                if "Writing the solution to" in line:
+                    found_solution = True
+
+    if not last_full_entry:
+        last_full_entry = current_entry
+
+    if not last_full_entry:
+        return None, None, None, None, None, None
+
+    time_values, best_bound_values, best_sol_values, in_queue_values, expl_values, gap_values = (
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+    )
+    for line in last_full_entry:
+        match = re.search(r"\dk?\s+\d+\.\ds$", line)
+
+        if not match:
+            continue
+
+        tokens = line.split()
+        if len(tokens) == 13:
+            tokens = tokens[1:]
+        assert len(tokens) == 12, f"{line}"
+
+        in_queue_values.append(float(tokens[1]))  # InQueue
+        expl_values.append(float(tokens[3].replace("%", "")))  # Expl.%
+        best_bound_values.append(float(tokens[4].replace("inf", "nan")))  # Best Bound
+        best_sol_values.append(float(tokens[5].replace("inf", "nan")))  # Best Sol
+        gap_values.append(
+            float(tokens[6].replace("%", "").replace("inf", "nan").replace("Large", "nan"))
+        )  # Gap%
+        time_values.append(float(tokens[11].replace("s", "")))  # Time
+
+    return time_values, best_bound_values, best_sol_values, in_queue_values, expl_values, gap_values
+
+
+def plot_highs_log(
+    time_values, best_bound_values, best_sol_values, in_queue_values, expl_values, gap_values
+):
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+
+    best_bound_colour = "blue"
+    best_solution_colour = "green"
+    in_queue_colour = "red"
+    explored_colour = "purple"
+    gap_colour = "orange"
+
+    # Plot Objective Bounds
+    ax1.plot(time_values, best_bound_values, label="Best Bound", color=best_bound_colour)
+    ax1.plot(time_values, best_sol_values, label="Best Solution", color=best_solution_colour)
+    ax1.set_xlabel("Time (seconds)")
+    ax1.set_ylabel("Objective Bounds", color=best_bound_colour, labelpad=15)
+    ax1.tick_params(axis="y", labelcolor=best_bound_colour)
+
+    # Limit y-axis to the range between min and max of the non-NaN values
+    valid_gap_index = next(i for i, gap in enumerate(gap_values) if not np.isnan(gap))
+    min_y = min(best_bound_values[valid_gap_index], best_sol_values[valid_gap_index])
+    max_y = max(best_bound_values[valid_gap_index], best_sol_values[valid_gap_index])
+    padding = (max_y - min_y) * 0.1
+    ax1.set_ylim(min_y - padding, max_y + padding)
+
+    # Add second y-axis for InQueue values
+    ax2 = ax1.twinx()
+    ax2.plot(time_values, in_queue_values, label="InQueue", color=in_queue_colour)
+#    ax2.set_ylabel("InQueue", color=in_queue_colour, loc="top", labelpad=12)
+    ax2.yaxis.label.set_rotation(0)
+    ax2.tick_params(axis="y", labelcolor=in_queue_colour)
+
+    # Add third y-axis for Explored % values (scaled)
+    ax3 = ax1.twinx()
+    ax3.spines["right"].set_position(("outward", 50))
+    ax3.plot(time_values, expl_values, label="Explored %", color=explored_colour)
+#    ax3.set_ylabel("Expl.%", color=explored_colour, loc="top", labelpad=10)
+    ax3.yaxis.label.set_rotation(0)
+    ax3.tick_params(axis="y", labelcolor=explored_colour)
+
+    # Add fourth y-axis for Gap % values (scaled)
+    ax4 = ax1.twinx()
+    ax4.spines["right"].set_position(("outward", 90))
+    ax4.plot(time_values, gap_values, label="Gap %", color=gap_colour, linestyle="--", linewidth=1)
+#    ax4.set_ylabel("Gap.%", color=gap_colour, loc="top", labelpad=22)
+    ax4.yaxis.label.set_rotation(0)
+    ax4.tick_params(axis="y", labelcolor=gap_colour)
+
+    # Plot vertical hash lines where Best Solution changes
+    for i in range(1, len(best_sol_values)):
+        # Print if change detected and not NaN
+        if (best_sol_values[i] != best_sol_values[i - 1]) and not(math.isnan(best_sol_values[i])):
+            ax1.axvline(x=time_values[i], color="grey", linestyle="--", linewidth=0.5)
+
+    # Shift plot area left to make room on the right for the three y-axis labels.
+    fig.subplots_adjust(left=0.08, right=0.85)
+
+    # Set up legend
+    fig.legend(loc="lower center", ncols=5)
+
+    # Show plot
+    plt.title("HiGHS MIP Log Analysis", pad=20)
+    plt.show()
+
+
+#log_file_path = "/path/to/your/logfile.log"
+log_file_path = "HiGHS.log"
+time_values, best_bound_values, best_sol_values, in_queue_values, expl_values, gap_values = (
+    parse_highs_log(log_file_path)
+)
+
+plot_highs_log(
+    time_values, best_bound_values, best_sol_values, in_queue_values, expl_values, gap_values
+)