Capacitated Facility Location (CFLP)¶

using System;
using System.IO;
using System.Collections.Generic;
using localsolver;

public class CapacitatedFacilityLocation : IDisposable
{
    //Solver
    LocalSolver localsolver = new LocalSolver();

    //Data
    int nbMaxFacilities;
    int nbSites;
    double[] capacity;
    double[] openingPrice;
    double[] demand;
    double[,] allocationPrice;

    //Variables
    LSExpression[] facilityAssignments;
    LSExpression[] cost;
    LSExpression totalCost;

    private string[] SplitInput(StreamReader input)
    {
        string line = input.ReadLine();
        if (line == null) return new string[0];
        return line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    void ReadInstance(string fileName)
    {
        using (StreamReader input = new StreamReader(fileName))
        {
            string[] splitted;
            splitted = SplitInput(input);
            nbMaxFacilities = int.Parse(splitted[0]);
            nbSites = int.Parse(splitted[1]);

            // Table initialization
            capacity = new double[nbMaxFacilities];
            openingPrice = new double[nbMaxFacilities];
            demand = new double[nbSites];
            allocationPrice = new double[nbMaxFacilities, nbSites];

            for (int f = 0; f < nbMaxFacilities; f++)
            {
                splitted = SplitInput(input);
                capacity[f] = double.Parse(splitted[0]);
                openingPrice[f] = double.Parse(splitted[1]);
            }
            splitted = SplitInput(input);
            for (int s = 0; s < nbSites; s++)
            {
                demand[s] = double.Parse(splitted[s]);
            }
            for (int f = 0; f < nbMaxFacilities; f++)
            {
                splitted = SplitInput(input);
                for (int s = 0; s < nbSites; s++)
                {
                    allocationPrice[f, s] = double.Parse(splitted[s]);
                }
            }
        }
    }

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


    void Solve(int limit)
    {

        LSModel model = localsolver.GetModel();

        //Facilities are represented by the sets of sites they provide
        facilityAssignments = new LSExpression[nbMaxFacilities];
        for (int f = 0; f < nbMaxFacilities; f++)
        {
            facilityAssignments[f] = model.Set(nbSites);
        }
        //Each site is provided by exactly one facility, so partition constraint
        model.Constraint(model.Partition(facilityAssignments));

        // Cost define the cost induced by each facility
        cost = new LSExpression[nbMaxFacilities];

        LSExpression demandArray = model.Array(demand);
        LSExpression allocationPriceArray = model.Array(allocationPrice);

        for (int f = 0; f < nbMaxFacilities; f++)
        {
            LSExpression facility = facilityAssignments[f];
            LSExpression size = model.Count(facility);

            // Capacity constraint
            LSExpression demandSelector = model.LambdaFunction(i => demandArray[i]);
            model.Constraint(model.Sum(facility, demandSelector) <= capacity[f]);

            // Cost calcul
            LSExpression cost_selector = model.LambdaFunction(i => allocationPriceArray[f, i]);
            cost[f] = model.Sum(facility, cost_selector) + model.If(size > 0, openingPrice[f], 0);
        }
        //Objective : minimizing total cost
        totalCost = model.Sum(cost);
        model.Minimize(totalCost);

        model.Close();

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

        localsolver.Solve();
    }

    // Writes the solution in a file with the following format:
    //  - value of the objective
    //  - indices of the open facilities followed by all the sites they provide
    void WriteSolution(string fileName)
    {
        using (StreamWriter output = new StreamWriter(fileName))
        {
            output.WriteLine(totalCost.GetDoubleValue());
            for (int f = 0; f < nbMaxFacilities; f++)
            {
                if (cost[f].GetDoubleValue() > 0)
                {
                    output.WriteLine(f);
                    LSCollection assigned_sites = facilityAssignments[f].GetCollectionValue();
                    for (int s = 0; s < assigned_sites.Count(); s++)
                    {
                        output.Write(assigned_sites[s] + " ");
                    }
                    output.WriteLine();
                }
            }
        }
    }

    public static void Main(string[] args)
    {
        string instanceFile = args[0];
        string outputFile = args.Length > 1 ? args[1] : null;
        string strTimeLimit = args.Length > 2 ? args[2] : "20";

        using (CapacitatedFacilityLocation model = new CapacitatedFacilityLocation())
        {
            model.ReadInstance(instanceFile);
            model.Solve(int.Parse(strTimeLimit));
            if (outputFile != null)
                model.WriteSolution(outputFile);
        }
    }
}