highs-sys 1.14.2

Rust binding for the HiGHS linear programming solver. See http://highs.dev.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#include "HCheckConfig.h"
#include "Highs.h"
#include "catch.hpp"
#include "io/Filereader.h"
#include "ipm/hipo/ipm/Solver.h"
#include "ipm/hipo/ipm/Status.h"
#include "lp_data/HighsCallback.h"
#include "parallel/HighsParallel.h"

// Example for using HiPO from its C++ interface. The program solves the Netlib
// problem afiro.

// #include <unistd.h>

#include <cmath>
#include <iostream>
#include <vector>

const bool dev_run = false;

TEST_CASE("test-hipo-afiro", "[highs_hipo]") {
  // Test that hipo runs and finds correct solution for afiro

  std::string model = "afiro.mps";
  const double expected_obj = -464.753;

  Highs highs;
  highs.setOptionValue("output_flag", dev_run);
  highs.setOptionValue("solver", kHipoString);
  highs.setOptionValue("timeless_log", kHighsOnString);

  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;
  highs.readModel(filename);

  HighsStatus status = highs.run();
  REQUIRE(status == HighsStatus::kOk);

  const double actual_obj = highs.getObjectiveValue();
  REQUIRE(std::abs(actual_obj - expected_obj) < 0.001);

  highs.resetGlobalScheduler(true);
}

TEST_CASE("test-hipo-deterministic", "[highs_hipo]") {
  // Test that hipo finds the exact same solution if run twice

  std::string model = "80bau3b.mps";
  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;

  HighsInt iter_1, iter_2;
  HighsSolution solution_1, solution_2;

  {
    Highs highs;
    highs.setOptionValue("output_flag", dev_run);
    highs.setOptionValue(kSolverString, kHipoString);
    highs.setOptionValue(kParallelString, kHighsOnString);
    highs.setOptionValue(kRunCrossoverString, kHighsOffString);
    highs.readModel(filename);
    HighsStatus status = highs.run();
    REQUIRE(status == HighsStatus::kOk);
    solution_1 = highs.getSolution();
    iter_1 = highs.getInfo().ipm_iteration_count;
    highs.resetGlobalScheduler(true);
  }
  {
    Highs highs;
    highs.setOptionValue("output_flag", dev_run);
    highs.setOptionValue(kSolverString, kHipoString);
    highs.setOptionValue(kParallelString, kHighsOnString);
    highs.setOptionValue(kRunCrossoverString, kHighsOffString);
    highs.readModel(filename);
    HighsStatus status = highs.run();
    REQUIRE(status == HighsStatus::kOk);
    solution_2 = highs.getSolution();
    iter_2 = highs.getInfo().ipm_iteration_count;
    highs.resetGlobalScheduler(true);
  }

  REQUIRE(iter_1 == iter_2);
  REQUIRE(solution_1.value_valid == solution_2.value_valid);
  REQUIRE(solution_1.dual_valid == solution_2.dual_valid);
  REQUIRE(solution_1.col_value == solution_2.col_value);
  REQUIRE(solution_1.row_value == solution_2.row_value);
  REQUIRE(solution_1.col_dual == solution_2.col_dual);
  REQUIRE(solution_1.row_dual == solution_2.row_dual);
}

TEST_CASE("test-hipo-orderings", "[highs_hipo]") {
  // Test that hipo orderings work correctly

  std::string model = "adlittle.mps";
  const double expected_obj = 2.2549e5;

  Highs highs;
  highs.setOptionValue("output_flag", dev_run);
  highs.setOptionValue("solver", kHipoString);
  highs.setOptionValue("timeless_log", kHighsOnString);

  std::string filename = std::string(HIGHS_DIR) + "/check/instances/" + model;
  highs.readModel(filename);

  // metis
  {
    highs.setOptionValue(kHipoOrderingString, kHipoMetisString);
    HighsStatus status = highs.run();
    REQUIRE(status == HighsStatus::kOk);

    const double actual_obj = highs.getObjectiveValue();

    REQUIRE(std::abs(actual_obj - expected_obj) / std::abs(expected_obj) <
            1e-4);
  }

  // amd
  {
    highs.setOptionValue(kHipoOrderingString, kHipoAmdString);
    HighsStatus status = highs.run();
    REQUIRE(status == HighsStatus::kOk);

    const double actual_obj = highs.getObjectiveValue();
    REQUIRE(std::abs(actual_obj - expected_obj) / std::abs(expected_obj) <
            1e-4);
  }

  // rcm
  {
    highs.setOptionValue(kHipoOrderingString, kHipoRcmString);
    HighsStatus status = highs.run();
    REQUIRE(status == HighsStatus::kOk);

    const double actual_obj = highs.getObjectiveValue();
    REQUIRE(std::abs(actual_obj - expected_obj) / std::abs(expected_obj) <
            1e-4);
  }

  highs.resetGlobalScheduler(true);
}