lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/pdlp/CupdlpWrapper.h

@@ -0,0 +1,108 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/CupdlpWrapper.h
+ * @brief
+ */
+#ifndef PDLP_CUPDLP_WRAPPER_H_
+#define PDLP_CUPDLP_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "lp_data/HighsSolution.h"
+#include "pdlp/cupdlp/cupdlp.h"
+
+#ifdef CUPDLP_GPU
+#include <cuda_runtime.h>
+#endif
+
+// #define CUPDLP_CPP_INIT(var, type, size)                                \
+//   {                                                                     \
+//     (var) = (type *)malloc((size) * sizeof(type));                      \
+//     if ((var) == NULL) {                                                \
+//       retcode = 1;                                                      \
+//       goto exit_cleanup;                                                \
+//     }                                                                   \
+//   }
+
+#define cupdlp_init_int(var, size) \
+  { (var) = (int*)malloc((size) * sizeof(int)); }
+
+#define cupdlp_init_double(var, size) \
+  { (var) = (double*)malloc((size) * sizeof(double)); }
+
+#define cupdlp_init_work(var, size) \
+  { (var) = (CUPDLPwork*)malloc((size) * sizeof(CUPDLPwork)); }
+
+#define cupdlp_init_problem(var, size) \
+  { (var) = (CUPDLPproblem*)malloc((size) * sizeof(CUPDLPproblem)); }
+
+#define cupdlp_init_data(var, size) \
+  { (var) = (CUPDLPdata*)malloc((size) * sizeof(CUPDLPdata)); }
+
+#ifdef CUPDLP_CPU
+
+#define cupdlp_init_vec_double(var, size) \
+  { (var) = (double*)malloc((size) * sizeof(double)); }
+
+#define cupdlp_copy_vec(dst, src, type, size) \
+  memcpy(dst, src, sizeof(type) * (size))
+
+#endif
+
+//#define cupdlp_init_csc_cpu(var, size)	\
+//   {\
+//     (var) = (CUPDLPcsc*)malloc((size) * sizeof(CUPDLPcsc));\
+//   }
+
+cupdlp_retcode problem_create(CUPDLPproblem** prob);
+// cupdlp_retcode csc_create(CUPDLPcsc **csc_cpu);
+
+cupdlp_retcode problem_alloc(
+    CUPDLPproblem* prob, cupdlp_int nRows, cupdlp_int nCols, cupdlp_int nEqs,
+    cupdlp_float* cost, cupdlp_float offset, cupdlp_float sign_origin,
+    void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+    CUPDLP_MATRIX_FORMAT dst_matrix_format, cupdlp_float* rhs,
+    cupdlp_float* lower, cupdlp_float* upper, cupdlp_float* alloc_matrix_time,
+    cupdlp_float* copy_vec_time);
+
+cupdlp_retcode data_alloc(CUPDLPdata* data, cupdlp_int nRows, cupdlp_int nCols,
+                          void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+                          CUPDLP_MATRIX_FORMAT dst_matrix_format);
+
+double infNorm(double* x, cupdlp_int n);
+
+void cupdlp_hasLower(cupdlp_float* haslb, const cupdlp_float* lb,
+                     const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_hasUpper(cupdlp_float* hasub, const cupdlp_float* ub,
+                     const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_haslb(cupdlp_float* haslb, const cupdlp_float* lb,
+                  const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_hasub(cupdlp_float* hasub, const cupdlp_float* ub,
+                  const cupdlp_float bound, const cupdlp_int len);
+
+HighsStatus solveLpCupdlp(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpCupdlp(const HighsOptions& options, HighsTimer& timer,
+                          const HighsLp& lp, HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& callback);
+int formulateLP_highs(const cupdlp_int local_log_level, const HighsLp& lp,
+                      double** cost, int* nCols, int* nRows, int* nnz,
+                      int* nEqs, int** csc_beg, int** csc_idx, double** csc_val,
+                      double** rhs, double** lower, double** upper,
+                      double* offset, double* sign_origin, int* nCols_origin,
+                      int** constraint_new_idx, int** constraint_type);
+
+cupdlp_int getCupdlpLogLevel(const HighsOptions& options);
+
+#endif

data/ext/lpsolver-highs/highs/pdlp/HiPdlpTimer.h

@@ -0,0 +1,155 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/HiPdlpTimer.h
+ * @brief Indices of HiPDLP iClocks
+ */
+#ifndef PDLP_HIPDLPTIMER_H_
+#define PDLP_HIPDLPTIMER_H_
+
+// Clocks for profiling HiPDLP
+enum iClockHipdlp {
+  kHipdlpClockTotal = 0,
+  kHipdlpClockPreprocess,
+  kHipdlpClockSolve,
+  kHipdlpClockPostprocess,
+  // Solve clocks
+  kHipdlpClockIterateUpdate,
+  kHipdlpClockConvergenceCheck,
+  kHipdlpClockRestartCheck,
+  kHipdlpClockAverageIterate,
+  // IterateUpdate clocks
+  kHipdlpClockMatrixMultiply,
+  kHipdlpClockMatrixTransposeMultiply,
+  kHipdlpClockProjectX,
+  kHipdlpClockProjectY,
+  kHipdlpClockStepSizeAdjustment,
+  // AverageIterate clocks
+  kHipdlpClockAverageIterateUpdateX,
+  kHipdlpClockAverageIterateUpdateY,
+  kHipdlpClockAverageIterateComputeX,
+  kHipdlpClockAverageIterateComputeY,
+  kHipdlpClockAverageIterateMatrixMultiply,
+  kHipdlpClockAverageIterateMatrixTransposeMultiply,
+
+  kNumHipdlpClock  //!< Number of HIPDLP clocks
+};
+
+const double tolerance_percent_report = 0.1;
+
+class HipdlpTimer {
+ public:
+  void initialiseHipdlpClocks(HighsTimerClock& hipdlp_timer_clock) {
+    HighsTimer* timer_pointer = hipdlp_timer_clock.timer_pointer_;
+    std::vector<HighsInt>& clock = hipdlp_timer_clock.clock_;
+
+    clock.resize(kNumHipdlpClock);
+    clock[kHipdlpClockTotal] = 0;
+    clock[kHipdlpClockPreprocess] =
+        timer_pointer->clock_def("HiPDLP preprocess");
+    clock[kHipdlpClockSolve] = timer_pointer->clock_def("HiPDLP solve");
+    clock[kHipdlpClockPostprocess] =
+        timer_pointer->clock_def("HiPDLP postprocess");
+    clock[kHipdlpClockIterateUpdate] =
+        timer_pointer->clock_def("Iterate update");
+    clock[kHipdlpClockMatrixMultiply] = timer_pointer->clock_def("Ax");
+    clock[kHipdlpClockMatrixTransposeMultiply] =
+        timer_pointer->clock_def("Aty");
+    clock[kHipdlpClockProjectX] = timer_pointer->clock_def("Project X");
+    clock[kHipdlpClockProjectY] = timer_pointer->clock_def("Project Y");
+    clock[kHipdlpClockStepSizeAdjustment] =
+        timer_pointer->clock_def("Step size adjustment");
+    clock[kHipdlpClockConvergenceCheck] =
+        timer_pointer->clock_def("Convergence check");
+    clock[kHipdlpClockRestartCheck] = timer_pointer->clock_def("Restart check");
+    clock[kHipdlpClockAverageIterate] =
+        timer_pointer->clock_def("Average iterate");
+    clock[kHipdlpClockAverageIterateUpdateX] =
+        timer_pointer->clock_def("Update X");
+    clock[kHipdlpClockAverageIterateUpdateY] =
+        timer_pointer->clock_def("Update Y");
+    clock[kHipdlpClockAverageIterateComputeX] =
+        timer_pointer->clock_def("Compute X");
+    clock[kHipdlpClockAverageIterateComputeY] =
+        timer_pointer->clock_def("Compute Y");
+    clock[kHipdlpClockAverageIterateMatrixMultiply] =
+        timer_pointer->clock_def("Ax  [A]");
+    clock[kHipdlpClockAverageIterateMatrixTransposeMultiply] =
+        timer_pointer->clock_def("Aty [A]");
+  };
+
+  bool reportHipdlpClockList(
+      const char* grepStamp, const std::vector<HighsInt> hipdlp_clock_list,
+      const HighsTimerClock& hipdlp_timer_clock,
+      const HighsInt kHipdlpClockIdeal = kHipdlpClockTotal,
+      const double tolerance_percent_report_ = -1) {
+    HighsTimer* timer_pointer = hipdlp_timer_clock.timer_pointer_;
+    if (!timer_pointer->printf_flag) return false;
+    const std::vector<HighsInt>& clock = hipdlp_timer_clock.clock_;
+    HighsInt hipdlp_clock_list_size = hipdlp_clock_list.size();
+    std::vector<HighsInt> clockList;
+    clockList.resize(hipdlp_clock_list_size);
+    for (HighsInt en = 0; en < hipdlp_clock_list_size; en++) {
+      clockList[en] = clock[hipdlp_clock_list[en]];
+    }
+    const double ideal_sum_time =
+        timer_pointer->clock_time[clock[kHipdlpClockIdeal]];
+    const double tolerance_percent_report =
+        tolerance_percent_report_ >= 0 ? tolerance_percent_report_ : 1e-8;
+    return timer_pointer->reportOnTolerance(
+        grepStamp, clockList, ideal_sum_time, tolerance_percent_report);
+  };
+
+  void reportHipdlpCoreClock(const HighsTimerClock& hipdlp_timer_clock) {
+    const std::vector<HighsInt> hipdlp_clock_list{
+        kHipdlpClockPreprocess, kHipdlpClockSolve, kHipdlpClockPostprocess};
+    reportHipdlpClockList("HipdlpCore___", hipdlp_clock_list,
+                          hipdlp_timer_clock, kHipdlpClockTotal);
+  };
+
+  void reportHipdlpSolveClock(const HighsTimerClock& hipdlp_timer_clock) {
+    const std::vector<HighsInt> hipdlp_clock_list{
+        kHipdlpClockIterateUpdate, kHipdlpClockConvergenceCheck,
+        kHipdlpClockRestartCheck, kHipdlpClockAverageIterate};
+    reportHipdlpClockList("HipdlpSolve__", hipdlp_clock_list,
+                          hipdlp_timer_clock, kHipdlpClockSolve);
+  };
+
+  void reportHipdlpIterateUpdateClock(
+      const HighsTimerClock& hipdlp_timer_clock) {
+    const std::vector<HighsInt> hipdlp_clock_list{
+        kHipdlpClockMatrixMultiply, kHipdlpClockMatrixTransposeMultiply,
+        kHipdlpClockProjectX, kHipdlpClockProjectY};
+    reportHipdlpClockList("HipdlpIterUpd", hipdlp_clock_list,
+                          hipdlp_timer_clock, kHipdlpClockIterateUpdate);
+  };
+
+  void reportHipdlpAverageIterateClock(
+      const HighsTimerClock& hipdlp_timer_clock) {
+    const std::vector<HighsInt> hipdlp_clock_list{
+        kHipdlpClockAverageIterateUpdateX,
+        kHipdlpClockAverageIterateUpdateY,
+        kHipdlpClockAverageIterateComputeX,
+        kHipdlpClockAverageIterateComputeY,
+        kHipdlpClockAverageIterateMatrixMultiply,
+        kHipdlpClockAverageIterateMatrixTransposeMultiply};
+    reportHipdlpClockList("HipdlpAvgIter", hipdlp_clock_list,
+                          hipdlp_timer_clock, kHipdlpClockAverageIterate);
+  };
+
+  void reportHipdlpMatrixMultiplyClock(
+      const HighsTimerClock& hipdlp_timer_clock) {
+    const std::vector<HighsInt> hipdlp_clock_list{
+        kHipdlpClockMatrixMultiply, kHipdlpClockMatrixTransposeMultiply,
+        kHipdlpClockAverageIterateMatrixMultiply,
+        kHipdlpClockAverageIterateMatrixTransposeMultiply};
+    reportHipdlpClockList("HipdlpMtxMult", hipdlp_clock_list,
+                          hipdlp_timer_clock, kHipdlpClockSolve);
+  };
+};
+
+#endif /* PDLP_HIPDLPTIMER_H_ */

data/ext/lpsolver-highs/highs/pdlp/HiPdlpWrapper.cpp

@@ -0,0 +1,141 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/HiPdlpWrapper.cpp
+ * @brief
+ * @author Julian Hall
+ */
+#include "pdlp/HiPdlpWrapper.h"
+
+#include "pdlp/cupdlp/cupdlp_utils.h"
+#include "pdlp/hipdlp/logger.hpp"
+#include "pdlp/hipdlp/pdhg.hpp"
+#include "pdlp/hipdlp/restart.hpp"
+
+HighsStatus solveLpHiPdlp(HighsLpSolverObject& solver_object) {
+  return solveLpHiPdlp(solver_object.options_, solver_object.timer_,
+                       solver_object.lp_, solver_object.basis_,
+                       solver_object.solution_, solver_object.model_status_,
+                       solver_object.highs_info_, solver_object.callback_);
+}
+
+HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
+                          const HighsLp& lp, HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& callback) {
+  // Indicate that no imprecise solution has (yet) been found
+  resetModelStatusAndHighsInfo(model_status, highs_info);
+
+  /*** Order of operations
+   * Preprocess with HiPdlp
+   * Scale with HiPdlp
+   * Solve with HiPdlp
+   * Unscale with HiPdlp
+   * Postprocess with HiPDLP
+   * ***/
+  PDLPSolver pdlp;
+
+  // 0. Set up logger and params
+  pdlp.setup(options, timer);
+
+  // 1. Pass the LP to be solved
+  pdlp.passLp(&lp);
+
+  // 2. Preprocess with HiPdlp
+  pdlp.preprocessLp();
+
+  // 3. Scale with HiPdlp
+  pdlp.scaleProblem();
+
+  // 4. Solve with HiPdlp
+  std::vector<double> x, y;
+  x.resize(pdlp.getNumCol(), 0.0);
+  y.resize(pdlp.getNumRow(), 0.0);
+
+  pdlp.solve(x, y);
+
+  // 5. Unscale with HiPdlp
+  pdlp.unscaleSolution(x, y);
+
+  // 6. Postprocess with HiPDLP
+  HighsSolution pdlp_solution;
+  PostSolveRetcode retcode = pdlp.postprocess(pdlp_solution);
+  if (retcode != PostSolveRetcode::OK) {
+    assert(111 == 444);
+    return HighsStatus::kError;
+  }
+
+#if PDLP_DEBUG_LOG
+  // print col_value and row_dual
+  debugPdlpFinalSolutionLog(pdlp.debug_pdlp_log_file_,
+                            pdlp_solution.col_value.data(), lp.num_col_,
+                            pdlp_solution.row_dual.data(), lp.num_row_);
+  pdlp.closeDebugLog();
+#endif
+
+  // Report profiling
+#if PDLP_PROFILE
+  pdlp.reportHipdlpTimer();
+#endif
+
+  // --- Print Summary ---
+  pdlp.logSummary();
+
+  highs_info.pdlp_iteration_count = pdlp.getIterationCount();
+
+  model_status = HighsModelStatus::kUnknown;
+  highs_solution.clear();
+  highs_solution = pdlp_solution;
+  highs_basis.valid = false;
+
+  const TerminationStatus termination_status = pdlp.getTerminationCode();
+  switch (termination_status) {
+    case TerminationStatus::OPTIMAL: {
+      model_status = HighsModelStatus::kOptimal;
+      break;
+    }
+    case TerminationStatus::INFEASIBLE: {
+      assert(111 == 222);
+      model_status = HighsModelStatus::kInfeasible;
+      return HighsStatus::kOk;
+      break;
+    }
+    case TerminationStatus::UNBOUNDED: {
+      assert(111 == 333);
+      model_status = HighsModelStatus::kUnbounded;
+      return HighsStatus::kOk;
+      break;
+    }
+    case TerminationStatus::MAXITER: {
+      model_status = HighsModelStatus::kIterationLimit;
+      break;
+    }
+    case TerminationStatus::TIMEOUT: {
+      model_status = HighsModelStatus::kTimeLimit;
+      break;
+    }
+    default:
+      assert(termination_status == TerminationStatus::ERROR);
+      return HighsStatus::kError;
+  }
+  assert(termination_status == TerminationStatus::OPTIMAL ||
+         termination_status == TerminationStatus::MAXITER ||
+         termination_status == TerminationStatus::TIMEOUT);
+  // highs_solution.col_value = x;
+  // highs_solution.col_value.resize(lp.num_col_);
+  // highs_solution.row_dual = y;
+  // lp.a_matrix_.product(highs_solution.row_value, highs_solution.col_value);
+  // lp.a_matrix_.productTranspose(highs_solution.col_dual,
+  //                               highs_solution.row_dual);
+  // for (HighsInt iCol = 0; iCol < lp.num_col_; iCol++)
+  //   highs_solution.col_dual[iCol] =
+  //       lp.col_cost_[iCol] - highs_solution.col_dual[iCol];
+  highs_solution.value_valid = true;
+  highs_solution.dual_valid = true;
+  return HighsStatus::kOk;
+}

data/ext/lpsolver-highs/highs/pdlp/HiPdlpWrapper.h

@@ -0,0 +1,26 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/HiPdlpWrapper.h
+ * @brief
+ */
+#ifndef PDLP_HIPDLP_WRAPPER_H_
+#define PDLP_HIPDLP_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "lp_data/HighsSolution.h"
+HighsStatus solveLpHiPdlp(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
+                          const HighsLp& lp, HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& callback);
+
+#endif

data/ext/lpsolver-highs/highs/pdlp/cupdlp/Diff

@@ -0,0 +1,12 @@
+diff cupdlp_restart.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_restart.h
+diff cupdlp_restart.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_restart.c
+diff cupdlp_proj.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_proj.h
+diff cupdlp_proj.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_proj.c
+diff cupdlp_cs.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_cs.h
+diff cupdlp_cs.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_cs.c
+diff cupdlp_scaling_cuda.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_scaling_cuda.h
+diff cupdlp_scaling_cuda.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_scaling_cuda.c
+diff cupdlp_solver.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_solver.h
+diff cupdlp_solver.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_solver.c
+diff cupdlp_utils.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_utils.h
+diff cupdlp_step.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_step.h

data/ext/lpsolver-highs/highs/pdlp/cupdlp/Meld

@@ -0,0 +1,7 @@
+meld cupdlp.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp.h
+meld glbopts.h /home/jajhall/cuPDLP-C/cupdlp/glbopts.h
+meld cupdlp_defs.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_defs.h
+meld cupdlp_step.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_step.c
+meld cupdlp_utils.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_utils.c
+meld cupdlp_linalg.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_linalg.h
+meld cupdlp_linalg.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_linalg.c

data/ext/lpsolver-highs/highs/pdlp/cupdlp/Merge

@@ -0,0 +1,2 @@
+merge cupdlp.h glbopts.h cupdlp_defs.h cupdlp_step.c cupdlp_utils.c cupdlp_linalg.h cupdlp_linalg.c > merge.c
+merge /home/jajhall/cuPDLP-C/cupdlp/cupdlp.h /home/jajhall/cuPDLP-C/cupdlp/glbopts.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_defs.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_step.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_utils.c /home/jajhall/cuPDLP-C/cupdlp/cupdlp_linalg.h /home/jajhall/cuPDLP-C/cupdlp/cupdlp_linalg.c > cuPDLP-C_merge.c

data/ext/lpsolver-highs/highs/pdlp/cupdlp/README.md

@@ -0,0 +1,95 @@
+# cuPDLP-C observations
+
+This directory contains files from [cuPDLP-C v0.3.0](https://github.com/COPT-Public/cuPDLP-C/tree/v0.3.0). Below are some issues experienced when integrating them into HiGHS. In March 2025 it was updated to https://github.com/COPT-Public/cuPDLP-C/commit/7b94c41efca42fa176a129a935b59718e1455fad. 
+
+## Termination of cuPDLP-C
+
+cuPDLP-C terminates when either the current or averaged iterates satisfy primal/dual feasibility, using a 2-norm measure relative to the size of the RHS/costs, and after scaling the LP. 
+
+HiGHS assesses primal/dual feasibility using a infinity-norm absolute measure for the unscaled LP. Thus the cuPDLP-C result frequently fails to satisfy HiGHS primal/dual feasibility. To get around this partially, `iInfNormAbsLocalTermination` has been introduced into cuPDLP-C. 
+
+By default, `iInfNormAbsLocalTermination` is false, so that the original cuPDLP-C termination criteria are used.
+
+When `iInfNormAbsLocalTermination` is true, cuPDLP-C terminates only when primal/dual feasibility is satisfied for the infinity-norm absolute measure of the current iterate, so that HiGHS primal/dual feasibility is satisfied. 
+
+However, the cuPDLP-C scaling may still result in the HiGHS tolerances not being satisfied. Users can inspect `HighsInfo` values for the maximum and sum of infeasibilities, and the new `HighsInfo` values measuring the maximum and sum of complementarity violations.
+
+## Preprocessing issue
+
+The following line is not recognised by g++, 
+
+> #if !defined(CUPDLP_CPU)
+
+so I've had to replace all ocurrences by
+
+> #ifndef CUPDLP_CPU
+
+This yields a compiler warning about "extra tokens at end of #ifndef
+directive" in the case of the following, but it's not a problem for
+now, as CUPDLP_CPU is set
+
+> #ifndef CUPDLP_CPU & USE_KERNELS
+
+## Use of macro definitions within C++
+
+When definitions in `glbopts.h` are used in `CupdlpWrapper.cpp` there is a g++ compiler error, because `typeof` isn't recognised
+
+> #define CUPDLP_INIT(var, size)                                  \
+  {                                                             \
+    (var) = (typeof(var))malloc((size) * sizeof(typeof(*var))); \
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+
+Hence there is a set of type-specific definitions in `CupdlpWrapper.h`, such as 
+
+>#define cupdlp_init_double(var, size)\
+   {\
+     (var) = (double*)malloc((size) * sizeof(double));\
+   }
+
+## C methods not picked up by g++
+
+Three methods
+* `double infNorm(double *x, cupdlp_int n);`
+* `void cupdlp_haslb(cupdlp_float *haslb, const cupdlp_float *lb, const cupdlp_float bound, const cupdlp_int len);`
+* `void cupdlp_hasub(cupdlp_float *hasub, const cupdlp_float *ub, const cupdlp_float bound, const cupdlp_int len);`
+
+are declared in `cupdlp_linalg.h` and defined in `cupdlp_linalg.c` but not picked up by g++. Hence duplicate methods are declared and defined in `CupdlpWrapper.h` and `CupdlpWrapper.cpp`.
+
+## Use of macro definitions within C
+
+Although the macro definitions in `glbopts.h` are fine when used in C under Linux, they cause the following compiler errors on Windows.
+
+> error C2146: syntax error: missing ';' before identifier 'calloc' (or 'malloc')
+
+In HiGHS, all the macros using `typeof` have been replaced by multiple type-specific macros
+
+## Problem with sys/time.h
+
+The HiGHS branch add-pdlp compiles and runs fine on @jajhall's Linux machine, but CI tests on GitHub fail utterly due to `sys/time.h` not being found. Until this is fixed, or HiGHS passes its own timer for use within `cuPDLP-c`, timing within `cuPDLP-c` can be disabled using the compiler directive `CUPDLP_TIMER`. By default this is defined, so the `cuPDLP-c` is retained.
+
+## Controlling the `cuPDLP-c` logging
+
+As a research code, `cuPDLP-c` naturally produces a lot of logging output. HiGHS must be able to run with less logging output, or completely silently. This is achieved using the `nLogLevel` parameter in `cuPDLP-c`. 
+
+By default, `nLogLevel` is 2, so all the original `cuPDLP-c` logging is produced.
+
+* If `nLogLevel` is 1, then the `cuPDLP-c` logging is less verbose 
+* If `nLogLevel` is 0, then there is no `cuPDLP-c` logging
+
+A related issue is the use of `fp` and `fp_sol`. HiGHS won't be using these, so sets them to null pointers. `cuPDLP-c` already doesn't print the solution if `fp_sol` is a null pointer, so the call to `writeJson(fp, pdhg);` is now conditional on `if (fp)`. 
+
+## Handling infeasible or unbounded problems
+
+`cuPDLP-c` now terminates with status `INFEASIBLE_OR_UNBOUNDED` for the infeasible and unbounded LPs in unit tests `pdlp-infeasible-lp` and `pdlp-unbounded-lp` in `highs/check/TestPdlp.cpp`. In the case of the unbounded LP, PDLP identifies a primal feasible point, so unboundedness can be deduced. This is done in `HighsSolve.cpp:131.
+
+## Returning the iteration count
+
+The `cuPDLP-c` iteration count is held in `pdhg->timers->nIter`, but `pdhg` is destroyed in `LP_SolvePDHG`, so `cupdlp_int* num_iter` has been added to the parameter list of this method.
+
+## To be done
+
+- Make CupldlpWrapper.cpp look more like C++ than C

data/ext/lpsolver-highs/highs/pdlp/cupdlp/cuda/CMakeLists.txt

@@ -0,0 +1,58 @@
+if (HIGHS_GPU_LIB)
+  return()
+endif()
+
+# separate libs for now
+
+enable_language(CXX CUDA)
+
+add_library(cudalin SHARED
+       ${CUPDLP_INCLUDE_DIR}/cuda/cupdlp_cuda_kernels.cu
+       ${CUPDLP_INCLUDE_DIR}/cuda/cupdlp_cuda_kernels.cuh
+       ${CUPDLP_INCLUDE_DIR}/cuda/cupdlp_cudalinalg.cuh
+       ${CUPDLP_INCLUDE_DIR}/cuda/cupdlp_cudalinalg.cu
+       ../../hipdlp/pdhg.cu  
+)
+
+# latest has
+# set_target_properties(cudalin PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+set_target_properties(cudalin PROPERTIES 
+CUDA_SEPARABLE_COMPILATION ON
+#CUDA_ARCHITECTURES "60;70;75;80;86" )
+#Deleted 60;70 due to errors
+#nvcc fatal   : Unsupported gpu architecture 'compute_60'
+#nvcc fatal   : Unsupported gpu architecture 'compute_70'
+CUDA_ARCHITECTURES "75;80;86" )
+
+
+# set_target_properties(cudalin PROPERTIES CUDA_ARCHITECTURES native)
+
+target_include_directories(cudalin PUBLIC "$<BUILD_INTERFACE:${CMAKE_CUDA_PATH}/include>")
+
+if (WIN32)
+  target_link_libraries(cudalin ${CUDA_LIBRARY})
+else()
+  # target_compile_definitions(cudalin
+  #     PUBLIC
+  #     # If the debug configuration pass the DEBUG define to the compiler
+  #     $<$<CONFIG:Debug>:-DCUPDLP_DEBUG=1>
+  #   )
+  target_link_libraries(cudalin ${CUDA_LIBRARY} m)
+endif()
+
+# add a test
+add_executable(testcudalin test_cuda_linalg.c)
+add_executable(testcublas test_cublas.c)
+
+set_target_properties(testcudalin PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+#target_include_directories(cudalinalg PRIVATE ${CUPDLP_INCLUDE_DIR}/cuda)
+target_link_libraries(testcudalin PRIVATE cudalin ${CUDA_LIBRARY})
+
+set_target_properties(testcublas PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+target_link_libraries(testcublas PRIVATE cudalin ${CUDA_LIBRARY})
+
+target_include_directories(cudalin PUBLIC 
+    "$<BUILD_INTERFACE:${CMAKE_CUDA_PATH}/include>"
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../hipdlp>"  # Add this for pdhg_kernels.hpp
+)