# Steel Mill Slab Design¶

## Principles learned¶

• Define the actual set of decision variables

• Preprocess the input to create useful data for the model

• Access an array with an “at” operator at an index that is an expression

## Problem¶

Steel is produced by casting molten iron into slabs. A steel mill can produce a finite number of slab sizes. An order has two properties, a color corresponding to the route required through the steel mill and a weight.

Given input orders, the problem is to assign the orders to slabs, the number and size of which are also to be determined, such that the total weight of steel produced is minimised. In other words we want to minimize the waste of steel (steel produced in addition to the actual sizes of orders). This assignment is subject to two further constraints:

• Capacity constraints: The total weight of orders assigned to a slab cannot exceed the slab capacity.

• Color constraints: Each slab can contain at most p of k total colors (p is usually 2). The color constraints arise because it is expensive to cut up slabs in order to send them to different parts of the mill.

For more details, see CSPLib and beCool.

## Data¶

The format of the data is as follows:

• 1st line: number of slab sizes, then the sequence of sizes

• 2nd line: number of colors

• 3rd line: number of orders

• Then for each order: size and color of the order

## Program¶

The model is based on the assignment of orders to slabs. An important point is that we associate no decision variable to the selected size for a slab. Instead, the wasted steel in each slab is automatically determined by its content. The waste is zero when the content fits exactly in one of the possible slab sizes and increases linearly otherwise. We define an array of values `wasteForContent` representing this saw-tooth profile, which allows a very simple writing of this non-linear relationship: ```wastedSteel[j] <- wasteForContent[slabContent[j]]```. It is pre-computed after the instance data has been read. The slab size being determined by the content, we must still ensure by a constraint that the maximum slab size is not exceeded.

It is a typical example of the importance of defining the right set of decision variables as explained in our quick start guide.

Execution:
localsolver steel_mill_slab_design.lsp inFileName=instances/12orderproblem.in [lsTimeLimit=] [solFileName=]
```use io;

function input() {
local usage = "Usage: localsolver steel_mill_slab_design.lsp "
+ "inFileName=inputFile [solFileName=outputFile] [lsTimeLimit=timeLimit]";

if (inFileName == nil) throw usage;

nbColorsMaxSlab = 2;

maxSize = slabSizes[nbSlabSizes];

nbSlabs = nbOrders;

ordersByColor[1..nbColors] = {};
sumSizeOrders = 0;

for [i in 1..nbOrders] {
sumSizeOrders += orders[i];
}

preComputeWasteForContent();
}

// Compute the vector wasteForContent
function preComputeWasteForContent() {
// No waste when a slab is empty
wasteForContent = 0;

// The waste for each content is the difference between the minimum slab size
// able to contain this content and the content
prevSize = 0;
for [size in slabSizes] {
if (size < prevSize) throw "Slab sizes should be sorted in ascending order";
wasteForContent[content in prevSize + 1..size] = size - content;
prevSize = size;
}

wasteForContent[prevSize+1..sumSizeOrders] = 0;
}

/* Declare the optimization model */
function model() {

// x[o][s] = 1 if order o is assigned to slab s, 0 otherwise
x[1..nbOrders][1..nbSlabs] <- bool();

// Each order is assigned to a slab
for [o in 1..nbOrders]
constraint sum[s in 1..nbSlabs](x[o][s]) == 1;

// The content of each slab must not exceed the maximum size of the slab
for [s in 1..nbSlabs] {
slabContent[s] <- sum[o in 1..nbOrders](orders[o]*x[o][s]);
constraint slabContent[s] <= maxSize;
}

// Wasted steel is computed according to the content of the slab
wastedSteel[s in 1..nbSlabs] <- wasteForContent[slabContent[s]];

// color[c][s] = 1 if the color c in the slab s, 0 otherwise
color[c in 1..nbColors : count(ordersByColor[c]) > 0][s in 1..nbSlabs]
<- or[o in ordersByColor[c]](x[o][s]);

// The number of colors per slab must not exceed a specified value
for [s in 1..nbSlabs]
constraint sum[c in 1..nbColors : count(ordersByColor[c]) > 0](
color[c][s]) <= nbColorsMaxSlab;

// Minimize the total wasted steel
totalWastedSteel <- sum[s in 1..nbSlabs](wastedSteel[s]);

minimize totalWastedSteel;
}

/* Parametrize the solver */
function param() {
if (lsTimeLimit == nil) lsTimeLimit = 60;
}

/* Write the solution in a file with the following format:
*  - total wasted steel
*  - number of slabs used
*  - for each slab used, the number of orders in the slab and the list of orders */
function output() {
if (solFileName == nil) return;

local ordersBySlabs;
local solFile = io.openWrite(solFileName);
solFile.println(totalWastedSteel.value);

local actualNbSlabs = 0;
for [s in 1..nbSlabs] {
ordersBySlabs[s] = map[o in 1..nbOrders : x[o][s].value](o);
if (ordersBySlabs[s].count() > 0) actualNbSlabs = actualNbSlabs + 1;
}
solFile.println(actualNbSlabs);

for [s in 1..nbOrders] {
if (ordersBySlabs[s].count() > 0) {
solFile.print(ordersBySlabs[s].count() + " ");
for [o in ordersBySlabs[s].values()] solFile.print(o, " ");
solFile.println();
}
}
}
```
Execution (Windows)
set PYTHONPATH=%LS_HOME%\bin\python
python steel_mill_slab_design.py instances\12orderproblem.in
Execution (Linux)
export PYTHONPATH=/opt/localsolver_12_0/bin/python
python steel_mill_slab_design.py instances/12orderproblem.in
```import localsolver
import sys

if len(sys.argv) < 2:
print("Usage: python steel_mill_slab_design.py inputFile [outputFile] [timeLimit]")
sys.exit(1)

with open(filename) as f:
return [int(elem) for elem in f.read().split()]

# Compute the vector waste_for_content
def pre_compute_waste_for_content(slab_sizes, sum_size_orders):
# No waste when a slab is empty
waste_for_content =  * sum_size_orders

prev_size = 0
for size in slab_sizes:
if size < prev_size:
print("Slab sizes should be sorted in ascending order")
sys.exit(1)
for content in range(prev_size + 1, size):
waste_for_content[content] = size - content
prev_size = size
return waste_for_content

with localsolver.LocalSolver() as ls:
#
#
nb_colors_max_slab = 2

nb_slab_sizes = next(file_it)
slab_sizes = [next(file_it) for i in range(nb_slab_sizes)]
max_size = slab_sizes[nb_slab_sizes - 1]

nb_colors = next(file_it)
nb_orders = next(file_it)
nb_slabs = nb_orders

orders_by_color = [list() for c in range(nb_colors)]
orders = [None] * nb_orders
sum_size_orders = 0
for o in range(nb_orders):
orders[o] = next(file_it)
c = next(file_it)
# Note: colors are in 1..nb_colors
orders_by_color[c - 1].append(o)
sum_size_orders += orders[o]

waste_for_content = pre_compute_waste_for_content(slab_sizes, sum_size_orders)

#
# Declare the optimization model
#
model = ls.model

# x[o, s] = 1 if order o is assigned to slab s, 0 otherwise
x = [[model.bool() for s in range(nb_slabs)] for o in range(nb_orders)]

# Each order is assigned to a slab
for o in range(nb_orders):
nb_slabs_assigned = model.sum(x[o])
model.constraint(model.eq(nb_slabs_assigned, 1))

# The content of each slab must not exceed the maximum size of the slab
slab_content = [None] * nb_slabs
for s in range(nb_slabs):
slab_content[s] = model.sum([orders[o] * x[o][s] for o in range(nb_orders)])
model.constraint(slab_content[s] <= max_size)

# Create a LocalSolver array to be able to access it with "at" operators
waste_for_content_array = model.array(waste_for_content)

# Wasted steel is computed according to the content of the slab
wasted_steel = [waste_for_content_array[slab_content[s]] for s in range(nb_slabs)]

# color[c][s] = 1 if the color c in the slab s, 0 otherwise
color = [list() for c in range(nb_colors)]
for c in range(nb_colors):
if len(orders_by_color[c]) == 0:
continue
color[c] = [model.or_([x[o][s] for o in orders_by_color[c]])
for s in range(nb_slabs)]

# The number of colors per slab must not exceed a specified value
for s in range(nb_slabs):
nb_colors_slab = model.sum([color[c][s] for c in range(nb_colors)
if len(orders_by_color[c]) > 0])
model.constraint(nb_colors_slab <= nb_colors_max_slab)

# Minimize the total wasted steel
total_wasted_steel = model.sum(wasted_steel)
model.minimize(total_wasted_steel)

model.close()

# Parameterize the solver
if len(sys.argv) >= 4:
ls.param.time_limit = int(sys.argv)
else:
ls.param.time_limit = 60

ls.solve()

#
# Write the solution in a file with the following format:
#  - total wasted steel
#  - number of slabs used
#  - for each slab used, the number of orders in the slab and the list of orders
#
if len(sys.argv) >= 3:
with open(sys.argv, 'w') as f:
f.write("%d\n" % total_wasted_steel.value)

actual_nb_slabs = 0
orders_by_slabs = [None] * nb_slabs
for s in range(nb_slabs):
orders_by_slabs[s] = [o for o in range(nb_orders) if x[o][s].value == 1]
if len(orders_by_slabs[s]) > 0:
actual_nb_slabs += 1
f.write("%d\n" % actual_nb_slabs)

for s in range(nb_slabs):
nb_orders_in_slab = len(orders_by_slabs[s])
if nb_orders_in_slab == 0:
continue
f.write("%d " % nb_orders_in_slab)
for i in range(nb_orders_in_slab):
f.write("%d " % orders_by_slabs[s][i])
f.write("\n")
```
Compilation / Execution (Windows)
cl /EHsc steel_mill_slab_design.cpp -I%LS_HOME%\include /link %LS_HOME%\bin\localsolver120.lib
Compilation / Execution (Linux)
g++ steel_mill_slab_design.cpp -I/opt/localsolver_12_0/include -llocalsolver120 -lpthread -o steel_mill_slab_design
```#include "localsolver.h"
#include <fstream>
#include <iostream>
#include <vector>

using namespace localsolver;
using namespace std;

class SteelMillSlabDesign {
public:
// Number of available slabs
int nbSlabs;

// Number of orders
int nbOrders;

// Number of colors
int nbColors;

// Maximum number of colors per slab
int nbColorsMaxSlab;

// Maximum size of a slab
int maxSize;

// List of orders for each color
vector<vector<int>> ordersByColor;

// Orders size
vector<int> orders;

// Steel waste computed for each content value
vector<int> wasteForContent;

// LocalSolver
LocalSolver localsolver;

// LS Program variables
vector<vector<LSExpression>> x;

// Objective
LSExpression totalWastedSteel;

ifstream infile;
infile.open(fileName.c_str());

nbColorsMaxSlab = 2;

int nbSlabSizes;
infile >> nbSlabSizes;

vector<int> slabSizes(nbSlabSizes);
for (int i = 0; i < nbSlabSizes; ++i) {
infile >> slabSizes[i];
}
maxSize = slabSizes[nbSlabSizes - 1];

infile >> nbColors;
infile >> nbOrders;
nbSlabs = nbOrders;

ordersByColor.resize(nbColors);
orders.resize(nbOrders);
int sumSizeOrders = 0;
for (int o = 0; o < nbOrders; ++o) {
infile >> orders[o];
int c;
infile >> c;
// Note: colors are in 1..nbColors
ordersByColor[c - 1].push_back(o);
sumSizeOrders += orders[o];
}

preComputeWasteForContent(slabSizes, sumSizeOrders);
}

private:
// Compute the vector wasteForContent
void preComputeWasteForContent(const vector<int>& slabSizes, int sumSizeOrders) {

// No waste when a slab is empty
wasteForContent.resize(sumSizeOrders, (int)0);

int prevSize = 0;
for (size_t i = 0; i < slabSizes.size(); ++i) {
int size = slabSizes[i];
if (size < prevSize) {
cerr << "Slab sizes should be sorted in ascending order" << endl;
exit(1);
}
for (int content = prevSize + 1; content < size; ++content) {
wasteForContent[content] = (int)(size - content);
}
prevSize = size;
}
}

public:
void solve(int limit) {
// Declare the optimization model
LSModel model = localsolver.getModel();

// x[o][s] = 1 if order o is assigned to slab s, 0 otherwise
x.resize(nbOrders);
for (int o = 0; o < nbOrders; ++o) {
x[o].resize(nbSlabs);
for (int s = 0; s < nbSlabs; ++s) {
x[o][s] = model.boolVar();
}
}

// Each order is assigned to a slab
for (int o = 0; o < nbOrders; ++o) {
LSExpression nbSlabsAssigned = model.sum(x[o].begin(), x[o].end());
model.constraint(nbSlabsAssigned == 1);
}

// The content of each slab must not exceed the maximum size of the slab
vector<LSExpression> slabContent(nbSlabs);
for (int s = 0; s < nbSlabs; ++s) {
slabContent[s] = model.sum();
for (int o = 0; o < nbOrders; ++o) {
}
model.constraint(slabContent[s] <= maxSize);
}

// Create a LocalSolver array to be able to access it with "at" operators
LSExpression wasteForContentArray = model.array(wasteForContent.begin(), wasteForContent.end());

// Wasted steel is computed according to the content of the slab
vector<LSExpression> wastedSteel(nbSlabs);
for (int s = 0; s < nbSlabs; ++s) {
wastedSteel[s] = wasteForContentArray[slabContent[s]];
}

// color[c][s] = 1 if the color c in the slab s, 0 otherwise
vector<vector<LSExpression>> color(nbColors);
for (int c = 0; c < nbColors; ++c) {
color[c].resize(nbSlabs);
if (ordersByColor[c].size() == 0)
continue;
for (int s = 0; s < nbSlabs; ++s) {
color[c][s] = model.or_();
for (size_t i = 0; i < ordersByColor[c].size(); ++i) {
int o = ordersByColor[c][i];
}
}
}

// The number of colors per slab must not exceed a specified value
for (int s = 0; s < nbSlabs; ++s) {
for (int c = 0; c < nbColors; ++c) {
if (ordersByColor[c].size() == 0)
continue;
}
}

// Minimize the total wasted steel
totalWastedSteel = model.sum(wastedSteel.begin(), wastedSteel.end());
model.minimize(totalWastedSteel);

model.close();

// Parametrize the solver
localsolver.getParam().setTimeLimit(limit);

localsolver.solve();
}

/* Write the solution in a file with the following format:
*  - total wasted steel
*  - number of slabs used
*  - for each slab used, the number of orders in the slab and the list of orders */
void writeSolution(const string& fileName) {
ofstream outfile;
outfile.open(fileName.c_str());

outfile << totalWastedSteel.getValue() << endl;

int actualNbSlabs = 0;
vector<vector<int>> ordersBySlabs(nbSlabs);
for (int s = 0; s < nbSlabs; ++s) {
for (int o = 0; o < nbOrders; ++o) {
if (x[o][s].getValue() == 1)
ordersBySlabs[s].push_back(o);
}
if (ordersBySlabs[s].size() > 0)
actualNbSlabs++;
}
outfile << actualNbSlabs << endl;

for (int s = 0; s < nbSlabs; ++s) {
size_t nbOrdersInSlab = ordersBySlabs[s].size();
if (nbOrdersInSlab == 0)
continue;
outfile << nbOrdersInSlab << " ";
for (size_t i = 0; i < nbOrdersInSlab; ++i) {
outfile << ordersBySlabs[s][i] << " ";
}
outfile << endl;
}
}
};

int main(int argc, char** argv) {
if (argc < 2) {
return 1;
}

const char* instanceFile = argv;
const char* outputFile = argc >= 3 ? argv : NULL;
const char* strTimeLimit = argc >= 4 ? argv : "60";

try {
SteelMillSlabDesign model;
model.solve(atoi(strTimeLimit));
if (outputFile != NULL)
model.writeSolution(outputFile);
return 0;
} catch (const exception& e) {
cerr << "An error occurred: " << e.what() << endl;
return 1;
}
}
```
Compilation / Execution (Windows)
copy %LS_HOME%\bin\localsolvernet.dll .
csc SteelMillSlabDesign.cs /reference:localsolvernet.dll
```using System;
using System.IO;
using System.Collections.Generic;
using localsolver;

public class SteelMillSlabDesign : IDisposable
{
// Number of available slabs
int nbSlabs;

// Number of orders
int nbOrders;

// Number of colors
int nbColors;

// Maximum number of colors per slab
int nbColorsMaxSlab;

// Maximum size of a slab
int maxSize;

// List of orders for each color
List<int>[] ordersByColor;

// Orders size
int[] orders;

// Steel waste computed for each content value
long[] wasteForContent;

// LocalSolver
LocalSolver localsolver;

// LS Program variables
LSExpression[,] x;

// Objective
LSExpression totalWastedSteel;

public SteelMillSlabDesign()
{
localsolver = new LocalSolver();
}

public void Dispose()
{
if (localsolver != null)
localsolver.Dispose();
}

{
{
nbColorsMaxSlab = 2;
int nbSlabSizes = int.Parse(splitted);

int[] slabSizes = new int[nbSlabSizes];
for (int i = 0; i < nbSlabSizes; ++i)
slabSizes[i] = int.Parse(splitted[i + 1]);
maxSize = slabSizes[nbSlabSizes - 1];

nbSlabs = nbOrders;

ordersByColor = new List<int>[nbColors];
for (int c = 0; c < nbColors; ++c)
ordersByColor[c] = new List<int>();
orders = new int[nbOrders];
int sumSizeOrders = 0;
for (int o = 0; o < nbOrders; ++o)
{
orders[o] = int.Parse(splitted);
int c = int.Parse(splitted);
// Note: colors are in 1..nbColors
sumSizeOrders += orders[o];
}

PreComputeWasteForContent(slabSizes, sumSizeOrders);
}
}

// Compute the vector wasteForContent
private void PreComputeWasteForContent(int[] slabSizes, int sumSizeOrders)
{
// No waste when a slab is empty
wasteForContent = new long[sumSizeOrders];

int prevSize = 0;
for (int i = 0; i < slabSizes.Length; ++i)
{
int size = slabSizes[i];
if (size < prevSize)
throw new Exception("Slab sizes should be sorted in ascending order");

for (int content = prevSize + 1; content < size; ++content)
wasteForContent[content] = size - content;
prevSize = size;
}
}

void Solve(int limit)
{
// Declare the optimization model
LSModel model = localsolver.GetModel();

// x[o, s] = 1 if order o is assigned to slab s, 0 otherwise
x = new LSExpression[nbOrders, nbSlabs];
for (int o = 0; o < nbOrders; ++o)
{
for (int s = 0; s < nbSlabs; ++s)
x[o, s] = model.Bool();
}

// Each order is assigned to a slab
for (int o = 0; o < nbOrders; ++o)
{
LSExpression nbSlabsAssigned = model.Sum();
for (int s = 0; s < nbSlabs; ++s)
model.Constraint(nbSlabsAssigned == 1);
}

// The content of each slab must not exceed the maximum size of the slab
LSExpression[] slabContent = new LSExpression[nbSlabs];
for (int s = 0; s < nbSlabs; ++s)
{
slabContent[s] = model.Sum();
for (int o = 0; o < nbOrders; ++o)
model.Constraint(slabContent[s] <= maxSize);
}

// Create a LocalSolver array to be able to access it with "at" operators
LSExpression wasteForContentArray = model.Array(wasteForContent);

// Wasted steel is computed according to the content of the slab
LSExpression[] wastedSteel = new LSExpression[nbSlabs];
for (int s = 0; s < nbSlabs; ++s)
wastedSteel[s] = wasteForContentArray[slabContent[s]];

// color[c][s] = 1 if the color c in the slab s, 0 otherwise
LSExpression[,] color = new LSExpression[nbColors, nbSlabs];
for (int c = 0; c < nbColors; ++c)
{
if (ordersByColor[c].Count == 0)
continue;
for (int s = 0; s < nbSlabs; ++s)
{
color[c, s] = model.Or();
for (int i = 0; i < ordersByColor[c].Count; ++i)
{
int o = ordersByColor[c][i];
}
}
}

// The number of colors per slab must not exceed a specified value
for (int s = 0; s < nbSlabs; ++s)
{
for (int c = 0; c < nbColors; ++c)
{
if (ordersByColor[c].Count == 0)
continue;
}
}

// Minimize the total wasted steel
totalWastedSteel = model.Sum(wastedSteel);
model.Minimize(totalWastedSteel);

model.Close();

// Parametrize the solver
localsolver.GetParam().SetTimeLimit(limit);

localsolver.Solve();
}

/* Write the solution in a file with the following format:
*  - total wasted steel
*  - number of slabs used
*  - for each slab used, the number of orders in the slab and the list of orders */
void WriteSolution(string fileName)
{
using (StreamWriter output = new StreamWriter(fileName))
{
output.WriteLine(totalWastedSteel.GetValue());
int actualNbSlabs = 0;
List<int>[] ordersBySlabs = new List<int>[nbSlabs];
for (int s = 0; s < nbSlabs; ++s)
{
ordersBySlabs[s] = new List<int>();
for (int o = 0; o < nbOrders; ++o)
{
if (x[o, s].GetValue() == 1)
}
if (ordersBySlabs[s].Count > 0)
actualNbSlabs++;
}
output.WriteLine(actualNbSlabs);

for (int s = 0; s < nbSlabs; ++s)
{
int nbOrdersInSlab = ordersBySlabs[s].Count;
if (nbOrdersInSlab == 0)
continue;
output.Write(nbOrdersInSlab + " ");
for (int i = 0; i < nbOrdersInSlab; ++i)
output.Write(ordersBySlabs[s][i] + " ");
output.WriteLine();
}
}
}

public static void Main(string[] args)
{
if (args.Length < 1)
{
Environment.Exit(1);
}

string instanceFile = args;
string outputFile = args.Length > 1 ? args : null;
string strTimeLimit = args.Length > 2 ? args : "60";

using (SteelMillSlabDesign model = new SteelMillSlabDesign())
{
model.Solve(int.Parse(strTimeLimit));
if (outputFile != null)
model.WriteSolution(outputFile);
}
}
}
```
Compilation / Execution (Windows)
javac SteelMillSlabDesign.java -cp %LS_HOME%\bin\localsolver.jar
Compilation / Execution (Linux)
javac SteelMillSlabDesign.java -cp /opt/localsolver_12_0/bin/localsolver.jar
```import java.util.*;
import java.io.*;
import localsolver.*;

public class SteelMillSlabDesign {
// Number of available slabs
private int nbSlabs;

// Number of orders
private int nbOrders;

// Number of colors
private int nbColors;

// Maximum number of colors per slab
private int nbColorsMaxSlab;

// Maximum size of a slab
private int maxSize;

// List of orders for each color
private ArrayList<ArrayList<Integer>> ordersByColor;

// Orders size
private int[] orders;

// Steel waste computed for each content value
private long[] wasteForContent;

// LocalSolver
private final LocalSolver localsolver;

// LS Program variables
private LSExpression[][] x;

// Objective
private LSExpression totalWastedSteel;

private SteelMillSlabDesign(LocalSolver localsolver) {
this.localsolver = localsolver;
}

private void readInstance(String fileName) throws IOException {
try (Scanner input = new Scanner(new File(fileName))) {
nbColorsMaxSlab = 2;
int nbSlabSizes = input.nextInt();

int[] slabSizes = new int[nbSlabSizes];
for (int i = 0; i < nbSlabSizes; ++i) {
slabSizes[i] = input.nextInt();
}
maxSize = slabSizes[nbSlabSizes - 1];

nbColors = input.nextInt();
nbOrders = input.nextInt();
nbSlabs = nbOrders;

ordersByColor = new ArrayList<ArrayList<Integer>>(nbColors);
for (int c = 0; c < nbColors; ++c) {
}
orders = new int[nbOrders];
int sumSizeOrders = 0;
for (int o = 0; o < nbOrders; ++o) {
orders[o] = input.nextInt();
int c = input.nextInt();
// Note: colors are in 1..nbColors
sumSizeOrders += orders[o];
}

preComputeWasteForContent(slabSizes, sumSizeOrders);
}
}

// Compute the vector wasteForContent
private void preComputeWasteForContent(int[] slabSizes, int sumSizeOrders) {
// No waste when a slab is empty
wasteForContent = new long[sumSizeOrders];

int prevSize = 0;
for (int i = 0; i < slabSizes.length; ++i) {
int size = slabSizes[i];
if (size < prevSize)
throw new RuntimeException("Slab sizes should be sorted in ascending order");
for (int content = prevSize + 1; content < size; ++content) {
wasteForContent[content] = size - content;
}
prevSize = size;
}
}

private void solve(int limit) {
// Declare the optimization model
LSModel model = localsolver.getModel();

// x[o][s] = 1 if order o is assigned to slab s, 0 otherwise
x = new LSExpression[nbOrders][nbSlabs];
for (int o = 0; o < nbOrders; ++o) {
for (int s = 0; s < nbSlabs; ++s) {
x[o][s] = model.boolVar();
}
}

// Each order is assigned to a slab
for (int o = 0; o < nbOrders; ++o) {
LSExpression nbSlabsAssigned = model.sum(x[o]);
model.constraint(model.eq(nbSlabsAssigned, 1));
}

// The content of each slab must not exceed the maximum size of the slab
LSExpression[] slabContent = new LSExpression[nbSlabs];
for (int s = 0; s < nbSlabs; ++s) {
slabContent[s] = model.sum();
for (int o = 0; o < nbOrders; ++o) {
}
model.constraint(model.leq(slabContent[s], maxSize));
}

// Create a LocalSolver array to be able to access it with "at" operators
LSExpression wasteForContentArray = model.array(wasteForContent);

// Wasted steel is computed according to the content of the slab
LSExpression[] wastedSteel = new LSExpression[nbSlabs];
for (int s = 0; s < nbSlabs; ++s) {
wastedSteel[s] = model.at(wasteForContentArray, slabContent[s]);
}

// color[c][s] = 1 if the color c in the slab s, 0 otherwise
LSExpression[][] color = new LSExpression[nbColors][nbSlabs];
for (int c = 0; c < nbColors; ++c) {
if (ordersByColor.get(c).size() == 0)
continue;
for (int s = 0; s < nbSlabs; ++s) {
color[c][s] = model.or();
for (int i = 0; i < ordersByColor.get(c).size(); ++i) {
int o = ordersByColor.get(c).get(i);
}
}
}

// The number of colors per slab must not exceed a specified value
for (int s = 0; s < nbSlabs; ++s) {
for (int c = 0; c < nbColors; ++c) {
if (ordersByColor.get(c).size() == 0)
continue;
}
}

// Minimize the total wasted steel
totalWastedSteel = model.sum(wastedSteel);
model.minimize(totalWastedSteel);

model.close();

// Parametrize the solver
localsolver.getParam().setTimeLimit(limit);

localsolver.solve();
}

/*
* Write the solution in a file with the following format:
* - total wasted steel
* - number of slabs used
* - for each slab used, the number of orders in the slab and the list of orders
*/
private void writeSolution(String fileName) throws IOException {
try (PrintWriter output = new PrintWriter(new FileWriter(fileName))) {
output.println(totalWastedSteel.getValue());

int actualNbSlabs = 0;
ArrayList<ArrayList<Integer>> ordersBySlabs = new ArrayList<ArrayList<Integer>>(nbSlabs);
for (int s = 0; s < nbSlabs; ++s) {
for (int o = 0; o < nbOrders; ++o) {
if (x[o][s].getValue() == 1)
}
if (ordersBySlabs.get(s).size() > 0)
actualNbSlabs++;
}
output.println(actualNbSlabs);

for (int s = 0; s < nbSlabs; ++s) {
int nbOrdersInSlab = ordersBySlabs.get(s).size();
if (nbOrdersInSlab == 0)
continue;
output.print(nbOrdersInSlab + " ");
for (int i = 0; i < nbOrdersInSlab; ++i) {
output.print(ordersBySlabs.get(s).get(i) + " ");
}
output.println();
}
}
}

public static void main(String[] args) {
if (args.length < 1) {
System.exit(1);
}

String instanceFile = args;
String outputFile = args.length > 1 ? args : null;
String strTimeLimit = args.length > 2 ? args : "60";

try (LocalSolver localsolver = new LocalSolver()) {
SteelMillSlabDesign model = new SteelMillSlabDesign(localsolver);