PortableLpModelWriter.cs

Go to the documentation of this file.

using System.Globalization;
using System.Text;
using ULSAlgorithms.Optimization.Modeling;
 
namespace ULSAlgorithms.Optimization.Execution;
 
/// <summary>
/// Writes a conservative LP representation understood by all four supported
/// execution backends.
/// </summary>
/// <remarks>
/// Stable names <c>v_&lt;id&gt;</c> are used instead of semantic model names so
/// solution-file parsing is independent of punctuation and provider-specific
/// name normalization.
/// </remarks>
public sealed class PortableLpModelWriter
{
    /// <summary>Gets the stable portable variable name.</summary>
    public static string GetVariableName(
        int variableId) =>
        $"v_{variableId}";
 
    /// <summary>Writes the supplied model to an LP file.</summary>
    public void Write(
        LinearModel model,
        string path)
    {
        ArgumentNullException.ThrowIfNull(model);
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
 
        string fullPath =
            Path.GetFullPath(path);
 
        string? directory =
            Path.GetDirectoryName(fullPath);
 
        if (!string.IsNullOrWhiteSpace(directory))
        {
            Directory.CreateDirectory(directory);
        }
 
        using var writer =
            new StreamWriter(
                fullPath,
                append: false,
                new UTF8Encoding(
                    encoderShouldEmitUTF8Identifier: false));
 
        writer.WriteLine(
            "\\ Generated by ULSAlgorithms portable solver execution layer");
 
        writer.WriteLine("Minimize");
        writer.Write(" obj: ");
 
        // The objective constant is deliberately omitted from the LP file.
        // It cannot alter the optimizer's decisions and is added back by the
        // independent objective reconstruction.
        WriteExpression(
            writer,
            model.Objective.Terms);
 
        writer.WriteLine();
        writer.WriteLine("Subject To");
 
        for (int index = 0;
             index < model.Constraints.Count;
             index++)
        {
            LinearConstraint constraint =
                model.Constraints[index];
 
            writer.Write(
                $" c_{index}: ");
 
            WriteExpression(
                writer,
                constraint.Terms);
 
            writer.Write(
                constraint.Sense switch
                {
                    LinearConstraintSense.LessOrEqual => " <= ",
                    LinearConstraintSense.Equal => " = ",
                    LinearConstraintSense.GreaterOrEqual => " >= ",
                    _ =>
                        throw new NotSupportedException(
                            $"Unsupported constraint sense '{constraint.Sense}'.")
                });
 
            writer.WriteLine(
                FormatNumber(
                    constraint.RightHandSide));
        }
 
        writer.WriteLine("Bounds");
 
        foreach (LinearVariable variable in model.Variables)
        {
            WriteBounds(
                writer,
                variable);
        }
 
        LinearVariable[] generals =
            model.Variables
                .Where(
                    static variable =>
                        variable.Type ==
                        LinearVariableType.Integer)
                .ToArray();
 
        if (generals.Length > 0)
        {
            writer.WriteLine("Generals");
 
            foreach (LinearVariable variable in generals)
            {
                writer.WriteLine(
                    $" {GetVariableName(variable.Id)}");
            }
        }
 
        LinearVariable[] binaries =
            model.Variables
                .Where(
                    static variable =>
                        variable.Type ==
                        LinearVariableType.Binary)
                .ToArray();
 
        if (binaries.Length > 0)
        {
            writer.WriteLine("Binaries");
 
            foreach (LinearVariable variable in binaries)
            {
                writer.WriteLine(
                    $" {GetVariableName(variable.Id)}");
            }
        }
 
        writer.WriteLine("End");
    }
 
    private static void WriteExpression(
        TextWriter writer,
        IEnumerable<LinearTerm> terms)
    {
        bool wroteTerm = false;
 
        foreach (LinearTerm term in terms)
        {
            double coefficient =
                term.Coefficient;
 
            if (coefficient == 0.0)
            {
                continue;
            }
 
            if (wroteTerm)
            {
                writer.Write(
                    coefficient >= 0.0
                        ? " + "
                        : " - ");
            }
            else if (coefficient < 0.0)
            {
                writer.Write("-");
            }
 
            double magnitude =
                Math.Abs(coefficient);
 
            if (magnitude != 1.0)
            {
                writer.Write(
                    FormatNumber(magnitude));
 
                writer.Write(" ");
            }
 
            writer.Write(
                GetVariableName(
                    term.VariableId));
 
            wroteTerm = true;
        }
 
        if (!wroteTerm)
        {
            writer.Write("0");
        }
    }
 
    private static void WriteBounds(
        TextWriter writer,
        LinearVariable variable)
    {
        string name =
            GetVariableName(variable.Id);
 
        if (variable.LowerBound ==
            variable.UpperBound)
        {
            writer.WriteLine(
                $" {name} = {FormatNumber(variable.LowerBound)}");
 
            return;
        }
 
        if (!double.IsPositiveInfinity(
                variable.UpperBound))
        {
            writer.WriteLine(
                $" {FormatNumber(variable.LowerBound)} <= {name} <= " +
                $"{FormatNumber(variable.UpperBound)}");
 
            return;
        }
 
        writer.WriteLine(
            $" {FormatNumber(variable.LowerBound)} <= {name}");
    }
 
    private static string FormatNumber(
        double value)
    {
        if (!double.IsFinite(value))
        {
            throw new ArgumentOutOfRangeException(
                nameof(value),
                value,
                "LP coefficients and finite bounds must be finite.");
        }
 
        return value.ToString(
            "G17",
            CultureInfo.InvariantCulture);
    }
}