A parser for LP files,and the four tools built on it.

What's here

The crate and its tools

The Rust library

Library capabilities

• ParsingObjectives (several per file, with Gurobi multi-objective attributes), linear constraints, bounds, variable-type sections, SOS1/SOS2 sets and comments, with the section keyword variants of the CPLEX, Gurobi, Xpress and Mosek dialects.
• Extended syntaxQuadratic objectives and constraints, indicator constraints, lazy constraints and user cuts, and Gurobi general constraints (MAX, MIN, ABS, AND, OR; not PWL).
• Variable typesContinuous, integer, general, binary, semi-continuous and semi-integer, with lower, upper, double or free bounds.
• MPSRead and write MPS files alongside LP (LpProblem::parse_mps, mps::writer), so a model can move between the two formats.
• WritingRound-trip safe LP output with configurable problem-name comment, line length, decimal precision, and section spacing.
• ModificationRename, update or remove objectives, constraints, variables, coefficients and RHS values in place, or build a problem from scratch with ProblemBuilder.
• AnalysisCounts, matrix density, coefficient and RHS ranges, and warnings for badly scaled or inconsistent models, with configurable thresholds.
• DiffCompare two problems (diff feature) with absolute and relative tolerances and an optional name normaliser. The CLI and TUI build the normaliser from regex rules.
• SerialisationSerialize and Deserialize on the model (serde feature), so any serde format works. The CLI writes JSON and YAML.
• SolvingHand a single-objective linear problem to CBC, GLPK, Gurobi or CPLEX through the lp-solvers crate (lp-solvers feature). Quadratic, indicator and general constraints are refused rather than dropped.

Parse and inspect

use lp_parser_rs::{parser::parse_file, problem::LpProblem};
use std::path::Path;

let content = parse_file(Path::new("problem.lp"))?;
let problem = LpProblem::parse(&content)?;
println!("{} objectives, {} constraints, {} variables",
    problem.objective_count(), problem.constraint_count(), problem.variable_count());

Modify and write back

use lp_parser_rs::{model::VariableType, problem::LpProblem, writer::write_lp_string};

let mut problem = LpProblem::parse(&std::fs::read_to_string("problem.lp")?)?;

problem.update_objective_coefficient("profit", "x1", 5.0)?;
problem.rename_objective("profit", "total_profit")?;
problem.update_constraint_coefficient("capacity", "x1", 2.0)?;
problem.update_constraint_rhs("capacity", 200.0)?;
problem.rename_variable("x1", "production_a")?;
problem.update_variable_type("production_a", VariableType::Integer)?;

std::fs::write("modified.lp", write_lp_string(&problem)?)?; // errors on names LP cannot represent

Modification methods on LpProblem: update_objective_coefficient, rename_objective, remove_objective, update_constraint_coefficient, update_constraint_rhs, rename_constraint, remove_constraint, rename_variable, update_variable_type, remove_variable. Writer options live on LpWriterOptions (include_problem_name, max_line_length, decimal_precision, include_section_spacing) and are passed to write_lp_string_with_options. decimal_precision defaults to None, which writes each number in its shortest exact form.

Cargo features

The command line

CLI: lp_parser

Every subcommand reads LP or MPS (a .mps extension reads MPS) and writes to stdout or a file (-o). -f picks text, JSON or YAML, and --pretty indents JSON. Global flags: -v/--verbose, -q/--quiet.

parse — display file structure

lp_parser parse problem.lp
lp_parser parse problem.lp --format yaml -o problem.yaml

info — summary statistics

Counts plus optional full listings via --variables, --constraints, --objectives.

lp_parser info problem.lp --variables --constraints --objectives
lp_parser info problem.lp --format json --pretty

analyze — structural analysis and warnings

lp_parser analyze problem.lp --issues-only
lp_parser analyze problem.lp --large-coeff-threshold 1e8 --ratio-threshold 1e5

# example output
summary: { name: diet, sense: Minimize, objective_count: 1, constraint_count: 7, variable_count: 16, density: 0.571 }
variables: { type_distribution: { upper_bounded: 9, double_bounded: 7 }, discrete_variable_count: 0 }
constraints: { type_distribution: { equality: 7 }, rhs_range: { min: 30.0, max: 50000.0 } }
coefficients: { constraint_coeff_range: { min: 0.1, max: 3055.2 }, coefficient_ratio: 101840.0 }
issues: []

diff — compare two LP or MPS files

lp_parser diff old.lp new.lp --abs-tol 1e-6 --rel-tol 1e-9
lp_parser diff old.lp new.lp --rename '\[\d+\]$' '[N]' --format json --pretty

Both diff and analyze follow GNU diff's exit codes, so CI can gate on them: diff exits 0 when the problems match, 1 when they differ and 2 on failure; analyze exits 0 when clean, 1 on an error-severity issue and 2 on failure.

convert — translate to another format

Targets: lp, mps, csv, json, yaml. Without --precision, numbers are written in their shortest exact form. LP output honours --precision, --max-line-length, --no-problem-name, and --compact; MPS output honours --precision; CSV writes constraints.csv, objectives.csv, and variables.csv to a directory.

lp_parser convert problem.lp --format lp --precision 4 --compact
lp_parser convert problem.lp --format csv --output ./out

solve — run an external solver

Solves with CBC (default) or GLPK, which must be on your PATH (-s/--solver). Multiple objectives, strict inequalities, quadratic terms, and indicator or general constraints are errors; SOS constraints are dropped with a warning.

lp_parser solve problem.lp --solver glpk --format json --pretty

The terminal UI

TUI: lp_diff

A ratatui explorer and diff viewer for LP and MPS files. One file opens a single-model explorer; two files are diffed, in any mix of formats (lp_diff model.lp model.mps). It also solves with HiGHS, re-solves after an RHS edit, applies presolve-style rewrites and compares the result, and ranks the rows and columns most likely to be slowing a solve down.

• Explore and diffFive sections (Summary, Variables, Constraints, Objectives, Numerics), coefficient-level side-by-side diffs, raw LP text view, kind filters, delta sorts, and tolerances you can cycle live.
• SearchTelescope-style pop-up across every section: fuzzy by default, with r: regex, s: substring and c: content modes. There is also a command palette and a 100-entry jumplist.
• SolveS solves either file, or both one after the other, with HiGHS on a background thread. Results tab into Summary, Variables, Constraints, Log and Duals, with solution diffing, ranked duals, CSV export, and e for infeasibility diagnosis.
• What-ifE edits a constraint's RHS in memory and solves it alongside the unedited model, to see how far a shadow price holds.
• RewriteP applies solution-preserving presolve rules (fixed columns to RHS, singleton rows to bounds, bound propagation, integer bound rounding, redundant and forcing rows, empty rows and columns, row scaling, column scaling) to a fixpoint, then solves the original and the rewritten model and compares them. Two further rules, split dense rows and relax integrality, change the optimal set on purpose and are off by default.
• DiagnosticsD puts each row and column's coefficient spread next to its result from the last solve, and ranks the worst-conditioned, likely degenerate and densest by name.
• Solver panesU names the variables an unbounded model runs away along, I finds the minimal conflicting set (IIS) of an infeasible one, R shows how far each objective coefficient and row activity can move before the basis changes, and B times the same model under six HiGHS configurations side by side.

Editor support

Language server: lp-lsp

A language server for .lp files. It understands the CPLEX LP format and the Gurobi extensions the parser supports, and keeps working while a file is half-written. It talks LSP over stdio and takes no arguments, so any editor that can run a language server can use it.

• DiagnosticsSyntax errors as you type, plus model checks such as duplicate names, conflicting bounds, unused declarations and badly scaled coefficients, with configurable thresholds.
• NavigationGo to definition, find references, highlights, document and workspace symbols, call hierarchy (which constraints use a variable), and a "used in N constraints" code lens.
• RenameVariables and constraint names across the workspace. It refuses names that would change how the file parses.
• Hover and completionDetails on variables, constraints, and keywords; suggestions that fit where the cursor is; signature help for MAX, MIN, ABS, AND, and OR.
• FormattingWhole document, a selection, or on Enter, preserving comments. It never touches a file with syntax errors.
• Code actionsQuick fixes for the problems it reports, plus refactors such as adding a bound, moving a variable between type sections, and reordering sections.
• ExtrasInlay hints, semantic highlighting, folding, and the commands lp.analyze, lp.convertToMps, and lp.showModelStats.

-- Neovim 0.11+: ~/.config/nvim/lsp/lp_lsp.lua
return {
  cmd = { 'lp-lsp' },
  filetypes = { 'lp' },
  root_markers = { '.git' },
}

-- init.lua
vim.filetype.add({ extension = { lp = 'lp' } })
vim.lsp.enable('lp_lsp')

A VS Code extension lives in lsp/editors/vscode (build it from source). Helix needs a languages.toml entry, and Zed a small dev extension to register the language; the README has both.

Python bindings

Python: parse_lp

Python bindings to the Rust library, with type stubs (Python 3.9+). They cover parsing, data access, modification, LP and MPS writing, analysis with configurable thresholds, CSV export and diff between two problems.

from parse_lp import LpParser

parser = LpParser("problem.lp")

print(parser.name, parser.sense, parser.num_variables)

parser.update_objective_coefficient("OBJ", "x1", 5.0)
parser.rename_variable("x2", "production")
parser.update_constraint_rhs("C1", 100.0)

parser.save_to_file("modified_problem.lp")

analysis = parser.analyze()
print(analysis["summary"]["density"])

The constructor parses the file straight away; the format follows the extension (.mps reads MPS). LpParser.from_file(path, format="mps") overrides it, LpParser.from_string(text) parses in-memory text, and to_mps_string / save_to_mps write MPS back out.

Getting it

Install

Develop with cargo insta test --all-features and review snapshot changes with cargo insta review. Pull requests are welcome on GitHub.