highs-sys

Rust绑定HiGHS线性规划求解器。请参阅 http://highs.dev。

此仓库包含HiGHS本身的源代码作为子模块。您应该使用以下命令克隆它：

git clone --recursive [email protected]:rust-or/highs-sys.git

此crate可以使用您系统上已安装和可用的HiGHS版本，或者构建并静态链接HiGHS本身。

使用方法

在运行时，HiGHS至少依赖于C++标准库。它需要安装到您的系统以及您想要部署应用程序的任何系统上。

如何安装这些取决于您的操作系统。

Debian

sudo apt-get install libstdc++6

（但可能已经安装到您的系统上）

macOS

当安装XCode时，libc++默认安装。

构建HiGHS

此crate可以选择构建HiGHS并将其静态链接，或者链接到已安装的版本。要构建HiGHS，您至少需要一个C++编译器和cmake。启用附加功能可能会产生额外的运行时依赖项。

Linux

这些可以使用您分发版的包管理器轻松安装。例如，在Debian上： sudo apt install g++ cmake。

macOS

要安装C++编译器，运行 xcode-select --install。获取cmake的最简单方法是通过brew： brew install cmake。

如果您启用了libz或ninja功能，也应该通过brew安装这些。

Windows

您需要安装CMake和Clang（可在LLVM中找到）。

它们可在winget中找到。

winget install -e --id Kitware.CMake
winget install -e --id LLVM.LLVM

如果您启用了Ninja功能，您也可以通过winget获取Ninja。

winget install -e --id Ninja-build.Ninja

如果需要，需要安装libz并设置环境变量ZLIB_ROOT以使其可被发现。

使用预安装的HiGHS版本

您可以选择不构建HiGHS，而是链接到您系统上已安装的版本。为此，在您的系统上安装pkg-config并在此crate上启用discover功能。

这通常会导致HiGHS以动态链接的方式链接，这意味着它还需要部署的系统上安装。

请注意，在撰写本文时，HiGHS在少数包管理器中进行了打包，因此您可能需要从源代码构建和安装HiGHS。

功能标志

build（默认启用）：构建HiGHS并以静态方式链接highs_release：将CMake配置文件设置为“发布”，无论构建配置如何；仅当build启用时生效。 libz：启用HiGHS libz链接以支持读取'mps.gz'；仅当build启用时生效。 ninja：将CMake生成器设置为Ninja；仅当build启用时生效。 discover：使用pkg-config发现并链接到已安装的HiGHS版本；如果两者都启用，则优先于build

示例

    // This illustrates the use of Highs_call, the simple C interface to
// HiGHS. It's designed to solve the general LP problem
//
// Min c^Tx subject to L <= Ax <= U; l <= x <= u
//
// where A is a matrix with m rows and n columns
//
// The scalar n is numcol
// The scalar m is numrow
//
// The vector c is colcost
// The vector l is collower
// The vector u is colupper
// The vector L is rowlower
// The vector U is rowupper
//
// The matrix A is represented in packed column-wise form: only its
// nonzeros are stored
//
// * The number of nonzeros in A is nnz
//
// * The row indices of the nonnzeros in A are stored column-by-column
// in aindex
//
// * The values of the nonnzeros in A are stored column-by-column in
// avalue
//
// * The position in aindex/avalue of the index/value of the first
// nonzero in each column is stored in astart
//
// Note that astart[0] must be zero
//
// After a successful call to Highs_call, the primal and dual
// solution, and the simplex basis are returned as follows
//
// The vector x is colvalue
// The vector Ax is rowvalue
// The vector of dual values for the variables x is coldual
// The vector of dual values for the variables Ax is rowdual
// The basic/nonbasic status of the variables x is colbasisstatus
// The basic/nonbasic status of the variables Ax is rowbasisstatus
//
// The status of the solution obtained is modelstatus
//
// To solve maximization problems, the values in c must be negated
//
// The use of Highs_call is illustrated for the LP
//
// Min    f  = 2x_0 + 3x_1
// s.t.                x_1 <= 6
//       10 <=  x_0 + 2x_1 <= 14
//        8 <= 2x_0 +  x_1
// 0 <= x_0 <= 3; 1 <= x_1

fn main() {
    let numcol: usize = 2;
    let numrow: usize = 3;
    let nnz: usize = 5;

    // Define the column costs, lower bounds and upper bounds
    let colcost: &mut [f64] = &mut [2.0, 3.0];
    let collower: &mut [f64] = &mut [0.0, 1.0];
    let colupper: &mut [f64] = &mut [3.0, 1.0e30];
    // Define the row lower bounds and upper bounds
    let rowlower: &mut [f64] = &mut [-1.0e30, 10.0, 8.0];
    let rowupper: &mut [f64] = &mut [6.0, 14.0, 1.0e30];
    // Define the constraint matrix column-wise
    let astart: &mut [c_int] = &mut [0, 2];
    let aindex: &mut [c_int] = &mut [1, 2, 0, 1, 2];
    let avalue: &mut [f64] = &mut [1.0, 2.0, 1.0, 2.0, 1.0];

    let colvalue: &mut [f64] = &mut vec![0.; numcol];
    let coldual: &mut [f64] = &mut vec![0.; numcol];
    let rowvalue: &mut [f64] = &mut vec![0.; numrow];
    let rowdual: &mut [f64] = &mut vec![0.; numrow];

    let colbasisstatus: &mut [c_int] = &mut vec![0; numcol];
    let rowbasisstatus: &mut [c_int] = &mut vec![0; numrow];

    let modelstatus: &mut c_int = &mut 0;

    let status: c_int = unsafe {
        Highs_call(
            numcol.try_into().unwrap(),
            numrow.try_into().unwrap(),
            nnz.try_into().unwrap(),
            colcost.as_mut_ptr(),
            collower.as_mut_ptr(),
            colupper.as_mut_ptr(),
            rowlower.as_mut_ptr(),
            rowupper.as_mut_ptr(),
            astart.as_mut_ptr(),
            aindex.as_mut_ptr(),
            avalue.as_mut_ptr(),
            colvalue.as_mut_ptr(),
            coldual.as_mut_ptr(),
            rowvalue.as_mut_ptr(),
            rowdual.as_mut_ptr(),
            colbasisstatus.as_mut_ptr(),
            rowbasisstatus.as_mut_ptr(),
            modelstatus
        )
    };

    assert_eq!(status, 0);
    // The solution is x_0 = 2 and x_1 = 4
    assert_eq!(colvalue, &[2., 4.]);
}

有关更多示例，请参阅tests。