* rolled back C API breaking changes - except: user_solution memory is now managed by HiGHS instead of the user

* added `setSolution` and `repairSolution` members that can accept partial solutions and find feasible solutions
* added kHighsCallbackCallbackMipUserSolution to C API
* changed C++ API to support both C API and new `HighsCallbackOutput`/`HighsCallbackInput` classes that manage memory
* Updated C/C++/highspy unit tests
* Updated highspy callback interface.  All callback arrays use numpy with read_only pointers, but contents can be changed safely.
* Some formatting changes (to conform with build checks)

Author: mathgeekcoder

check/TestCAPI.c

@@ -12,7 +12,7 @@
 const HighsInt dev_run = 0;
 const double double_equal_tolerance = 1e-5;
 
-void checkGetCallbackDataOutPointer(const HighsCCallbackDataOut* data_out,
+void checkGetCallbackDataOutPointer(const HighsCallbackDataOut* data_out,
                                     const char* name, HighsInt valid) {
   const void* name_p = Highs_getCallbackDataOutItem(data_out, name);
   if (valid) {
@@ -28,7 +28,7 @@ void checkGetCallbackDataOutPointer(const HighsCCallbackDataOut* data_out,
   }
 }
 
-void checkGetCallbackDataOutHighsInt(const HighsCCallbackDataOut* data_out,
+void checkGetCallbackDataOutHighsInt(const HighsCallbackDataOut* data_out,
                                      const char* name, HighsInt value) {
   const void* name_p = Highs_getCallbackDataOutItem(data_out, name);
   if (!name_p) {
@@ -46,7 +46,7 @@ void checkGetCallbackDataOutHighsInt(const HighsCCallbackDataOut* data_out,
   }
 }
 
-void checkGetCallbackDataOutInt(const HighsCCallbackDataOut* data_out,
+void checkGetCallbackDataOutInt(const HighsCallbackDataOut* data_out,
                                 const char* name, int value) {
   const void* name_p = Highs_getCallbackDataOutItem(data_out, name);
   if (!name_p) {
@@ -64,7 +64,7 @@ void checkGetCallbackDataOutInt(const HighsCCallbackDataOut* data_out,
   }
 }
 
-void checkGetCallbackDataOutInt64(const HighsCCallbackDataOut* data_out,
+void checkGetCallbackDataOutInt64(const HighsCallbackDataOut* data_out,
                                   const char* name, int64_t value) {
   const void* name_p = Highs_getCallbackDataOutItem(data_out, name);
   if (!name_p) {
@@ -82,7 +82,7 @@ void checkGetCallbackDataOutInt64(const HighsCCallbackDataOut* data_out,
   }
 }
 
-void checkGetCallbackDataOutDouble(const HighsCCallbackDataOut* data_out,
+void checkGetCallbackDataOutDouble(const HighsCallbackDataOut* data_out,
                                    const char* name, double value) {
   const void* name_p = Highs_getCallbackDataOutItem(data_out, name);
   if (!name_p) {
@@ -101,8 +101,8 @@ void checkGetCallbackDataOutDouble(const HighsCCallbackDataOut* data_out,
 }
 
 static void userCallback(const int callback_type, const char* message,
-                         const HighsCCallbackDataOut* data_out,
-                         HighsCCallbackDataIn* data_in,
+                         const HighsCallbackDataOut* data_out,
+                         HighsCallbackDataIn* data_in,
                          void* user_callback_data) {
   // Extract the double value pointed to from void* user_callback_data
   const double local_callback_data =
@@ -1877,9 +1877,9 @@ void testMultiObjective() {
   HighsInt integrality[2] = {kHighsVarTypeInteger, kHighsVarTypeInteger};
 
   Highs_setBoolOptionValue(highs, "output_flag", dev_run);
-  HighsInt return_status = Highs_passLp(highs, num_col, num_row, num_nz, a_format, sense,
-					offset, col_cost, col_lower, col_upper,
-					row_lower, row_upper, a_start, a_index, a_value);
+  HighsInt return_status = Highs_passLp(
+      highs, num_col, num_row, num_nz, a_format, sense, offset, col_cost,
+      col_lower, col_upper, row_lower, row_upper, a_start, a_index, a_value);
   assert(return_status == kHighsStatusOk);
 
   return_status = Highs_clearLinearObjectives(highs);
@@ -1891,15 +1891,19 @@ void testMultiObjective() {
   double abs_tolerance = 0;
   double rel_tolerance = 0;
   HighsInt priority = 10;
-  return_status = Highs_addLinearObjective(highs, weight, linear_objective_offset, coefficients, abs_tolerance, rel_tolerance, priority);
+  return_status = Highs_addLinearObjective(
+      highs, weight, linear_objective_offset, coefficients, abs_tolerance,
+      rel_tolerance, priority);
   assert(return_status == kHighsStatusOk);
-  
+
   weight = 1e-4;
   linear_objective_offset = 0;
   coefficients[0] = 1;
   coefficients[1] = 0;
   priority = 0;
-  return_status = Highs_addLinearObjective(highs, weight, linear_objective_offset, coefficients, abs_tolerance, rel_tolerance, priority);
+  return_status = Highs_addLinearObjective(
+      highs, weight, linear_objective_offset, coefficients, abs_tolerance,
+      rel_tolerance, priority);
   assert(return_status == kHighsStatusOk);
 
   return_status = Highs_run(highs);
@@ -1909,8 +1913,7 @@ void testMultiObjective() {
 
   Highs_writeSolutionPretty(highs, "");
   double* col_value = (double*)malloc(sizeof(double) * num_col);
-  return_status =
-    Highs_getSolution(highs, col_value, NULL, NULL, NULL);
+  return_status = Highs_getSolution(highs, col_value, NULL, NULL, NULL);
   assertDoubleValuesEqual("col_value[0]", col_value[0], 2);
   assertDoubleValuesEqual("col_value[1]", col_value[1], 6);
 
@@ -1923,43 +1926,46 @@ void testMultiObjective() {
   double abs_tolerance2[2] = {0, -1};
   double rel_tolerance2[2] = {0, -1};
   HighsInt priority2[2] = {10, 0};
-  return_status = Highs_passLinearObjectives(highs, 2, weight2, linear_objective_offset2, coefficients2, abs_tolerance2, rel_tolerance2, priority2);
+  return_status = Highs_passLinearObjectives(
+      highs, 2, weight2, linear_objective_offset2, coefficients2,
+      abs_tolerance2, rel_tolerance2, priority2);
   return_status = Highs_run(highs);
   assert(return_status == kHighsStatusOk);
   model_status = Highs_getModelStatus(highs);
   assert(model_status == kHighsModelStatusOptimal);
   Highs_writeSolutionPretty(highs, "");
-  return_status =
-    Highs_getSolution(highs, col_value, NULL, NULL, NULL);
+  return_status = Highs_getSolution(highs, col_value, NULL, NULL, NULL);
   assertDoubleValuesEqual("col_value[0]", col_value[0], 2);
   assertDoubleValuesEqual("col_value[1]", col_value[1], 6);
 
   //  weight2[1] = 1e-5;
   coefficients2[0] = 1.0001;
   abs_tolerance2[0] = 1e-5;
   rel_tolerance2[0] = 0.05;
-  return_status = Highs_passLinearObjectives(highs, 2, weight2, linear_objective_offset2, coefficients2, abs_tolerance2, rel_tolerance2, priority2);
+  return_status = Highs_passLinearObjectives(
+      highs, 2, weight2, linear_objective_offset2, coefficients2,
+      abs_tolerance2, rel_tolerance2, priority2);
   return_status = Highs_run(highs);
   assert(return_status == kHighsStatusOk);
   model_status = Highs_getModelStatus(highs);
   assert(model_status == kHighsModelStatusOptimal);
   Highs_writeSolutionPretty(highs, "");
-  return_status =
-    Highs_getSolution(highs, col_value, NULL, NULL, NULL);
+  return_status = Highs_getSolution(highs, col_value, NULL, NULL, NULL);
   assertDoubleValuesEqual("col_value[0]", col_value[0], 4.9);
   assertDoubleValuesEqual("col_value[1]", col_value[1], 3.1);
 
   if (dev_run) printf("\n***************\nLexicographic 2\n***************\n");
   abs_tolerance2[0] = -1;
 
-  return_status = Highs_passLinearObjectives(highs, 2, weight2, linear_objective_offset2, coefficients2, abs_tolerance2, rel_tolerance2, priority2);
+  return_status = Highs_passLinearObjectives(
+      highs, 2, weight2, linear_objective_offset2, coefficients2,
+      abs_tolerance2, rel_tolerance2, priority2);
   return_status = Highs_run(highs);
   assert(return_status == kHighsStatusOk);
   model_status = Highs_getModelStatus(highs);
   assert(model_status == kHighsModelStatusOptimal);
   Highs_writeSolutionPretty(highs, "");
-  return_status =
-    Highs_getSolution(highs, col_value, NULL, NULL, NULL);
+  return_status = Highs_getSolution(highs, col_value, NULL, NULL, NULL);
   assertDoubleValuesEqual("col_value[0]", col_value[0], 1.30069);
   assertDoubleValuesEqual("col_value[1]", col_value[1], 6.34966);
 
@@ -1968,82 +1974,89 @@ void testMultiObjective() {
 }
 
 void testQpIndefiniteFailure() {
-    void* highs = Highs_create();
-    Highs_setBoolOptionValue(highs, "output_flag", dev_run);
-    HighsInt ret;
-    const double inf = Highs_getInfinity(highs);
-    ret = Highs_addCol(highs, 0.0, 1.0, inf, 0, NULL, NULL);
-    assert(ret == 0);
-    ret = Highs_addCol(highs, 0.0, 1.0, 1.0, 0, NULL, NULL);
-    HighsInt start[2] = {0, 1};
-    HighsInt index[1] = {1};
-    double value[1] = {1.0};
-    ret = Highs_passHessian(highs, 2, 1, kHighsHessianFormatTriangular, start, index, value);
-    assert(ret == 0);
-    HighsInt run_status = Highs_run(highs);
-    HighsInt model_status = Highs_getModelStatus(highs);
-    assert(run_status == kHighsStatusError);
-    assert(model_status == kHighsModelStatusSolveError);
-    Highs_destroy(highs);
+  void* highs = Highs_create();
+  Highs_setBoolOptionValue(highs, "output_flag", dev_run);
+  HighsInt ret;
+  const double inf = Highs_getInfinity(highs);
+  ret = Highs_addCol(highs, 0.0, 1.0, inf, 0, NULL, NULL);
+  assert(ret == 0);
+  ret = Highs_addCol(highs, 0.0, 1.0, 1.0, 0, NULL, NULL);
+  HighsInt start[2] = {0, 1};
+  HighsInt index[1] = {1};
+  double value[1] = {1.0};
+  ret = Highs_passHessian(highs, 2, 1, kHighsHessianFormatTriangular, start,
+                          index, value);
+  assert(ret == 0);
+  HighsInt run_status = Highs_run(highs);
+  HighsInt model_status = Highs_getModelStatus(highs);
+  assert(run_status == kHighsStatusError);
+  assert(model_status == kHighsModelStatusSolveError);
+  Highs_destroy(highs);
 }
 
 void testDualRayTwice() {
-    void* highs = Highs_create();
-    Highs_setBoolOptionValue(highs, "output_flag", dev_run);
-    int ret;
-    double INF = Highs_getInfinity(highs);
-    ret = Highs_changeObjectiveOffset(highs, 0.0);
-    assert(ret == 0);
-    ret = Highs_setStringOptionValue(highs, "presolve", "off");
-    assert(ret == 0);
-    ret = Highs_addCol(highs, 0.0, 0.0, 0.0, 0, NULL, NULL);
-    assert(ret == 0);
-    ret = Highs_addCol(highs, 0.0, 0.0, 0.0, 0, NULL, NULL);
-    assert(ret == 0);
-    ret = Highs_addCol(highs, -1.0, 0.0, INF, 0, NULL, NULL);
-    assert(ret == 0);
-    ret = Highs_addCol(highs, -1.0, 0.0, INF, 0, NULL, NULL);
-    assert(ret == 0);
-    HighsInt index[2] = {2, 3};
-    double value[2] = {1.0, -1.0};
-    ret = Highs_addRow(highs, 0.0, 0.0, 2, index, value);
-    assert(ret == 0);
-    index[0] = 2;    index[1] = 3;
-    value[0] = 1.0;  value[1] = 1.0;
-    ret = Highs_addRow(highs, 1.0, INF, 2, index, value);
-    assert(ret == 0);
-    index[0] = 0;    index[1] = 2;
-    value[0] = -2.0; value[1] = 1.0;
-    ret = Highs_addRow(highs, -INF, 0.0, 2, index, value);
-    assert(ret == 0);
-    index[0] = 1;    index[1] = 3;
-    value[0] = -3.0; value[1] = 1.0;
-    ret = Highs_addRow(highs, -INF, 0.0, 2, index, value);
-    assert(ret == 0);
-    ret = Highs_run(highs);
-    assert(ret == 0);
-    HighsInt has_dual_ray = 0;
-    double dual_ray_value[4] = {0.0, 0.0, 0.0, 0.0};
-    ret = Highs_getDualRay(highs, &has_dual_ray, dual_ray_value);
-    assert(ret == 0);
-    assertIntValuesEqual("has_dual_ray", has_dual_ray, 1);
-    assertDoubleValuesEqual("dual_ray_value[0]", dual_ray_value[0], 0.0);
-    assertDoubleValuesEqual("dual_ray_value[1]", dual_ray_value[1], 1.0);
-    assertDoubleValuesEqual("dual_ray_value[2]", dual_ray_value[2], -1.0);
-    assertDoubleValuesEqual("dual_ray_value[3]", dual_ray_value[3], -1.0);
-    ret = Highs_changeColBounds(highs, 1, 1.0, 1.0);
-    assert(ret == 0);
-    ret = Highs_run(highs);
-    assert(ret == 0);
-    ret = Highs_getDualRay(highs, &has_dual_ray, dual_ray_value);
-    assert(ret == 0);
-    assertIntValuesEqual("has_dual_ray", has_dual_ray, 1);
-    assertDoubleValuesEqual("dual_ray_value[0]", dual_ray_value[0], 1.0);
-    assertDoubleValuesEqual("dual_ray_value[1]", dual_ray_value[1], 1.0);
-    assertDoubleValuesEqual("dual_ray_value[2]", dual_ray_value[2], -2.0);
-    assertDoubleValuesEqual("dual_ray_value[3]", dual_ray_value[3], 0.0);
-    Highs_destroy(highs);
-    return;
+  void* highs = Highs_create();
+  Highs_setBoolOptionValue(highs, "output_flag", dev_run);
+  int ret;
+  double INF = Highs_getInfinity(highs);
+  ret = Highs_changeObjectiveOffset(highs, 0.0);
+  assert(ret == 0);
+  ret = Highs_setStringOptionValue(highs, "presolve", "off");
+  assert(ret == 0);
+  ret = Highs_addCol(highs, 0.0, 0.0, 0.0, 0, NULL, NULL);
+  assert(ret == 0);
+  ret = Highs_addCol(highs, 0.0, 0.0, 0.0, 0, NULL, NULL);
+  assert(ret == 0);
+  ret = Highs_addCol(highs, -1.0, 0.0, INF, 0, NULL, NULL);
+  assert(ret == 0);
+  ret = Highs_addCol(highs, -1.0, 0.0, INF, 0, NULL, NULL);
+  assert(ret == 0);
+  HighsInt index[2] = {2, 3};
+  double value[2] = {1.0, -1.0};
+  ret = Highs_addRow(highs, 0.0, 0.0, 2, index, value);
+  assert(ret == 0);
+  index[0] = 2;
+  index[1] = 3;
+  value[0] = 1.0;
+  value[1] = 1.0;
+  ret = Highs_addRow(highs, 1.0, INF, 2, index, value);
+  assert(ret == 0);
+  index[0] = 0;
+  index[1] = 2;
+  value[0] = -2.0;
+  value[1] = 1.0;
+  ret = Highs_addRow(highs, -INF, 0.0, 2, index, value);
+  assert(ret == 0);
+  index[0] = 1;
+  index[1] = 3;
+  value[0] = -3.0;
+  value[1] = 1.0;
+  ret = Highs_addRow(highs, -INF, 0.0, 2, index, value);
+  assert(ret == 0);
+  ret = Highs_run(highs);
+  assert(ret == 0);
+  HighsInt has_dual_ray = 0;
+  double dual_ray_value[4] = {0.0, 0.0, 0.0, 0.0};
+  ret = Highs_getDualRay(highs, &has_dual_ray, dual_ray_value);
+  assert(ret == 0);
+  assertIntValuesEqual("has_dual_ray", has_dual_ray, 1);
+  assertDoubleValuesEqual("dual_ray_value[0]", dual_ray_value[0], 0.0);
+  assertDoubleValuesEqual("dual_ray_value[1]", dual_ray_value[1], 1.0);
+  assertDoubleValuesEqual("dual_ray_value[2]", dual_ray_value[2], -1.0);
+  assertDoubleValuesEqual("dual_ray_value[3]", dual_ray_value[3], -1.0);
+  ret = Highs_changeColBounds(highs, 1, 1.0, 1.0);
+  assert(ret == 0);
+  ret = Highs_run(highs);
+  assert(ret == 0);
+  ret = Highs_getDualRay(highs, &has_dual_ray, dual_ray_value);
+  assert(ret == 0);
+  assertIntValuesEqual("has_dual_ray", has_dual_ray, 1);
+  assertDoubleValuesEqual("dual_ray_value[0]", dual_ray_value[0], 1.0);
+  assertDoubleValuesEqual("dual_ray_value[1]", dual_ray_value[1], 1.0);
+  assertDoubleValuesEqual("dual_ray_value[2]", dual_ray_value[2], -2.0);
+  assertDoubleValuesEqual("dual_ray_value[3]", dual_ray_value[3], 0.0);
+  Highs_destroy(highs);
+  return;
 }
 
 /*