PortableLpModelWriter.cs

Go to the documentation of this file.

using System.Globalization;
using System.Text;
using LotSizingDataModel.Solver.Modeling;
 
namespace LotSizingDataModel.Solver.External;
 
/// <summary>
/// Writes a solver-independent <see cref="MathematicalModel"/> to a
/// conservative LP file understood by the supported native solvers.
/// </summary>
/// <remarks>
/// <para>
/// Stable variable names of the form <c>v_&lt;id&gt;</c> are deliberately used
/// instead of domain names. This makes solution-file parsing independent of
/// spaces, punctuation and solver-specific name normalization.
/// </para>
/// <para>
/// Semi-continuous and semi-integer variables are intentionally rejected in
/// this first portable writer, matching the first CPLEX adapter's current
/// support level.
/// </para>
/// </remarks>
public sealed class PortableLpModelWriter
{
    /// <summary>
    /// Returns the stable LP name associated with a mathematical variable.
    /// </summary>
    /// <param name="variableId">Mathematical variable identifier.</param>
    /// <returns>Portable variable name.</returns>
    public static string GetVariableName(
        int variableId)
    {
        return $"v_{variableId}";
    }
 
    /// <summary>
    /// Writes the specified model to an LP file.
    /// </summary>
    /// <param name="model">Validated mathematical model.</param>
    /// <param name="path">Destination LP path.</param>
    public void Write(
        MathematicalModel model,
        string path)
    {
        ArgumentNullException.ThrowIfNull(model);
 
        if (string.IsNullOrWhiteSpace(path))
        {
            throw new ArgumentException(
                "A destination path is required.",
                nameof(path));
        }
 
        model.EnsureValid();
 
        foreach (MathematicalVariable variable in model.Variables)
        {
            if (variable.VariableType is
                MathematicalVariableType.SemiContinuous or
                MathematicalVariableType.SemiInteger)
            {
                throw new NotSupportedException(
                    $"Portable LP export does not yet support variable " +
                    $"type '{variable.VariableType}'.");
            }
        }
 
        string fullPath =
            Path.GetFullPath(path);
 
        string? directory =
            Path.GetDirectoryName(fullPath);
 
        if (!string.IsNullOrWhiteSpace(directory))
        {
            Directory.CreateDirectory(directory);
        }
 
        using var writer =
            new StreamWriter(
                fullPath,
                false,
                new UTF8Encoding(false));
 
        writer.WriteLine(
            "\\ Generated by LotSizingDataModel portable solver adapter");
 
        writer.WriteLine(
            model.Objective.Sense == ObjectiveSense.Minimize
                ? "Minimize"
                : "Maximize");
 
        writer.Write(" obj: ");
        WriteExpression(
            writer,
            model.Objective.Expression,
            includeConstant: true);
        writer.WriteLine();
 
        writer.WriteLine("Subject To");
 
        int constraintIndex = 0;
 
        foreach (LinearConstraint constraint in model.Constraints)
        {
            if (!constraint.IsEnabled)
            {
                continue;
            }
 
            writer.Write(
                $" c_{constraintIndex}: ");
 
            WriteExpression(
                writer,
                constraint.LeftHandSide,
                includeConstant: false);
 
            double adjustedRightHandSide =
                constraint.RightHandSide -
                constraint.LeftHandSide.Constant;
 
            writer.Write(
                constraint.Sense switch
                {
                    MathematicalConstraintSense.LessThanOrEqual =>
                        " <= ",
                    MathematicalConstraintSense.Equal =>
                        " = ",
                    MathematicalConstraintSense.GreaterThanOrEqual =>
                        " >= ",
                    _ =>
                        throw new NotSupportedException(
                            $"Unsupported mathematical constraint sense " +
                            $"'{constraint.Sense}'.")
                });
 
            writer.WriteLine(
                FormatNumber(adjustedRightHandSide));
 
            constraintIndex++;
        }
 
        writer.WriteLine("Bounds");
 
        foreach (MathematicalVariable variable in model.Variables)
        {
            WriteBounds(
                writer,
                variable);
        }
 
        MathematicalVariable[] integerVariables =
            model.Variables
                .Where(
                    variable =>
                        variable.VariableType ==
                        MathematicalVariableType.Integer)
                .ToArray();
 
        if (integerVariables.Length > 0)
        {
            writer.WriteLine("Generals");
 
            foreach (MathematicalVariable variable in integerVariables)
            {
                writer.WriteLine(
                    $" {GetVariableName(variable.Id)}");
            }
        }
 
        MathematicalVariable[] binaryVariables =
            model.Variables
                .Where(
                    variable =>
                        variable.VariableType ==
                        MathematicalVariableType.Binary)
                .ToArray();
 
        if (binaryVariables.Length > 0)
        {
            writer.WriteLine("Binaries");
 
            foreach (MathematicalVariable variable in binaryVariables)
            {
                writer.WriteLine(
                    $" {GetVariableName(variable.Id)}");
            }
        }
 
        writer.WriteLine("End");
    }
 
    private static void WriteExpression(
        TextWriter writer,
        LinearExpression expression,
        bool includeConstant)
    {
        bool wroteTerm =
            false;
 
        if (includeConstant &&
            expression.Constant != 0.0)
        {
            writer.Write(
                FormatNumber(expression.Constant));
 
            wroteTerm =
                true;
        }
 
        foreach (LinearTerm term in expression.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,
        MathematicalVariable variable)
    {
        string name =
            GetVariableName(variable.Id);
 
        double lower =
            variable.LowerBound;
 
        double upper =
            variable.UpperBound;
 
        if (double.IsNegativeInfinity(lower) &&
            double.IsPositiveInfinity(upper))
        {
            writer.WriteLine(
                $" {name} free");
 
            return;
        }
 
        if (lower == upper)
        {
            writer.WriteLine(
                $" {name} = {FormatNumber(lower)}");
 
            return;
        }
 
        if (!double.IsNegativeInfinity(lower) &&
            !double.IsPositiveInfinity(upper))
        {
            writer.WriteLine(
                $" {FormatNumber(lower)} <= {name} <= " +
                $"{FormatNumber(upper)}");
 
            return;
        }
 
        if (!double.IsNegativeInfinity(lower))
        {
            writer.WriteLine(
                $" {FormatNumber(lower)} <= {name}");
 
            return;
        }
 
        writer.WriteLine(
            $" {name} <= {FormatNumber(upper)}");
    }
 
    private static string FormatNumber(
        double value)
    {
        if (!double.IsFinite(value))
        {
            throw new ArgumentOutOfRangeException(
                nameof(value),
                value,
                "Only finite coefficients and right-hand sides can " +
                "be written as LP numeric values.");
        }
 
        return value.ToString(
            "G17",
            CultureInfo.InvariantCulture);
    }
}