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

#include "Avgas.h"
#include "HCheckConfig.h"
#include "Highs.h"
#include "catch.hpp"
#include "lp_data/HighsLpUtils.h"
#include "util/HighsUtils.h"

const bool dev_run = false;

// No commas in test case name.
TEST_CASE("LP-orientation", "[lp_orientation]") {
  Avgas avgas;
  HighsInt num_row = 0;
  HighsInt num_row_nz = 0;
  vector<double> rowLower;
  vector<double> rowUpper;
  vector<HighsInt> ARstart;
  vector<HighsInt> ARindex;
  vector<double> ARvalue;

  for (HighsInt row = 0; row < avgas_num_row; row++)
    avgas.addRow(row, num_row, num_row_nz, rowLower, rowUpper, ARstart, ARindex,
                 ARvalue);

  ARstart.push_back(num_row_nz);

  HighsInt num_col = 0;
  HighsInt num_col_nz = 0;
  vector<double> colCost;
  vector<double> colLower;
  vector<double> colUpper;
  vector<HighsInt> Astart;
  vector<HighsInt> Aindex;
  vector<double> Avalue;
  for (HighsInt col = 0; col < avgas_num_col; col++)
    avgas.addCol(col, num_col, num_col_nz, colCost, colLower, colUpper, Astart,
                 Aindex, Avalue);
  Astart.push_back(num_col_nz);

  assert(num_col_nz == num_row_nz);

  double optimal_objective_function_value = -7.75;
  Highs highs;
  if (!dev_run) {
    highs.setOptionValue("output_flag", false);
  } else {
    highs.setOptionValue("log_dev_level", kHighsLogDevLevelVerbose);
  }
  const HighsLp& highs_lp = highs.getLp();
  const HighsInfo& info = highs.getInfo();

  REQUIRE(highs_lp.a_matrix_.format_ == MatrixFormat::kColwise);

  // Set up the LP externally
  HighsLp lp;
  lp.num_col_ = num_col;
  lp.num_row_ = num_row;
  lp.col_cost_ = colCost;
  lp.col_lower_ = colLower;
  lp.col_upper_ = colUpper;
  lp.row_lower_ = rowLower;
  lp.row_upper_ = rowUpper;
  lp.a_matrix_.start_ = Astart;
  lp.a_matrix_.index_ = Aindex;
  lp.a_matrix_.value_ = Avalue;
  lp.a_matrix_.format_ = MatrixFormat::kColwise;
  // Have to set the matrix dimension so that setFormat can be used
  lp.a_matrix_.num_col_ = num_col;
  lp.a_matrix_.num_row_ = num_row;
  // Pass the LP
  highs.passModel(lp);
  highs.run();
  REQUIRE(info.objective_function_value == optimal_objective_function_value);

  // Make the external LP row-wise then pass and solve it
  lp.ensureRowwise();
  highs.passModel(lp);
  highs.run();
  REQUIRE(info.objective_function_value == optimal_objective_function_value);

  // Make the external LP col-wise then pass and solve it
  lp.ensureColwise();
  highs.passModel(lp);
  highs.run();
  REQUIRE(info.objective_function_value == optimal_objective_function_value);

  // Clear the internal LP
  highs.clearModel();
  REQUIRE(highs.addCols(num_col, colCost.data(), colLower.data(),
                        colUpper.data(), 0, NULL, NULL,
                        NULL) == HighsStatus::kOk);
  REQUIRE(highs.addRows(num_row, rowLower.data(), rowUpper.data(), num_row_nz,
                        ARstart.data(), ARindex.data(),
                        ARvalue.data()) == HighsStatus::kOk);
  highs.run();
  REQUIRE(info.objective_function_value == optimal_objective_function_value);

  // Clear the internal LP
  highs.clearModel();
  highs.addCols(num_col, colCost.data(), colLower.data(), colUpper.data(), 0,
                NULL, NULL, NULL);
  double one_row_lower;
  double one_row_upper;
  vector<HighsInt> one_row_index;
  vector<double> one_row_value;
  HighsInt one_row_num_nz;
  for (HighsInt row = 0; row < avgas_num_row; row++) {
    avgas.getRow(row, one_row_lower, one_row_upper, one_row_index,
                 one_row_value);
    one_row_num_nz = one_row_index.size();
    REQUIRE(highs.addRow(one_row_lower, one_row_upper, one_row_num_nz,
                         one_row_index.data(),
                         one_row_value.data()) == HighsStatus::kOk);
  }
  highs.run();
  REQUIRE(info.objective_function_value == optimal_objective_function_value);

  //  return_status = highs.writeModel("");

  highs.resetGlobalScheduler(true);
}