lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/include/highs/pdlp/cupdlp/cupdlp_cs.h

@@ -0,0 +1,40 @@
+#ifndef CUPDLP_CS_H
+#define CUPDLP_CS_H
+
+#include "pdlp/cupdlp/cupdlp_defs.h"
+
+/* sparse matrix in column-oriented form used in reading mps*/
+typedef struct cupdlp_cs_sparse {
+  int nzmax;
+  int m;     /* number of rows */
+  int n;     /* number of columns */
+  int *p;    /* column pointers (size n+1) or col indices (size nzmax) */
+  int *i;    /* row indices, size nzmax */
+  double *x; /* numerical values, size nzmax */
+  int nz;    /* # of entries in triplet matrix, -1 for compressed-col */
+} cupdlp_dcs;
+
+int cupdlp_dcs_entry(cupdlp_dcs *T, int i, int j, double x);
+cupdlp_dcs *cupdlp_dcs_compress(const cupdlp_dcs *T);
+double cupdlp_dcs_norm(const cupdlp_dcs *A);
+int cupdlp_dcs_print(const cupdlp_dcs *A, int brief);
+
+/* utilities */
+void *cupdlp_dcs_calloc(int n, size_t size);
+void *cupdlp_dcs_free(void *p);
+void *cupdlp_dcs_realloc(void *p, int n, size_t size, int *ok);
+cupdlp_dcs *cupdlp_dcs_spalloc(int m, int n, int nzmax, int values, int t);
+cupdlp_dcs *cupdlp_dcs_spfree(cupdlp_dcs *A);
+int cupdlp_dcs_sprealloc(cupdlp_dcs *A, int nzmax);
+void *cupdlp_dcs_malloc(int n, size_t size);
+
+/* utilities */
+double cupdlp_dcs_cumsum(int *p, int *c, int n);
+cupdlp_dcs *cupdlp_dcs_done(cupdlp_dcs *C, void *w, void *x, int ok);
+cupdlp_dcs *cupdlp_dcs_transpose(const cupdlp_dcs *A, int values);
+
+#define IS_CSC(A) (A && (A->nz == -1))
+#define IS_TRIPLET(A) (A && (A->nz >= 0))
+/*--------------------------------------------------------------------------*/
+
+#endif

data/ext/lpsolver-highs/build/include/highs/pdlp/cupdlp/cupdlp_defs.h

@@ -0,0 +1,447 @@
+#ifndef CUPDLP_H_GUARD
+#define CUPDLP_H_GUARD
+
+// The below already defined in CMake.
+// #define CUPDLP_CPU
+// #define CUPDLP_DEBUG (1)
+#define CUPDLP_TIMER
+
+#include "HConfig.h"
+
+#ifdef CUPDLP_GPU
+#include "cuda/cupdlp_cuda_kernels.cuh"
+#include "cuda/cupdlp_cudalinalg.cuh"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <math.h>
+#include <string.h>
+
+#include "glbopts.h"
+
+#define PDHG_USE_TIMERS (1)
+#define USE_MY_BLAS (1)
+#define USE_KERNELS (1)
+
+#define PDHG_STEPSIZE_REDUCTION_EXP \
+  (0.3)  // Parameters in PDLP adaptive linesearch
+#define PDHG_STEPSIZE_GROWTH_EXP (0.6)
+#define PDHG_USE_TIMERS (1)
+#define PDHG_DISPLAY_TERMINATION_CHECK (1)
+
+#define PDHG_PROJECT_INITIAL_X (0)
+#define SHOW_DEFINE(x) printf("%s=%s\n", #x, STR(x))
+
+#define CUPDLP_DEBUG_INTERVAL (40)
+#define CUPDLP_RELEASE_INTERVAL (40)
+#define CUPDLP_DUMP_ITERATES_STATS (1)
+#define CUPDLP_DUMP_LINESEARCH_STATS (1)
+#define CUPDLP_INEXACT_EPS (1e-4)
+
+#define PDLP_DEBUG_LOG (0)
+
+typedef struct CUPDLP_CUDA_DENSE_VEC CUPDLPvec;
+typedef struct CUPDLP_DENSE_MATRIX CUPDLPdense;
+typedef struct CUPDLP_CSR_MATRIX CUPDLPcsr;
+typedef struct CUPDLP_CSC_MATRIX CUPDLPcsc;
+typedef struct CUPDLP_DATA CUPDLPdata;
+typedef struct CUPDLP_SETTINGS CUPDLPsettings;
+typedef struct CUPDLP_PROBLEM CUPDLPproblem;
+typedef struct CUPDLP_RES_OBJ CUPDLPresobj;
+typedef struct CUPDLP_ITERATES CUPDLPiterates;
+typedef struct CUPDLP_STEPSIZE CUPDLPstepsize;
+typedef struct CUPDLP_SCALING CUPDLPscaling;
+typedef struct CUPDLP_TIMERS CUPDLPtimers;
+typedef struct CUPDLP_WORK CUPDLPwork;
+typedef cupdlp_int cupdlp_retcode;
+
+typedef enum {
+  OPTIMAL = 0,
+  INFEASIBLE,
+  UNBOUNDED,
+  INFEASIBLE_OR_UNBOUNDED,
+  TIMELIMIT_OR_ITERLIMIT,
+  FEASIBLE,
+} termination_code;
+
+typedef enum {
+  LAST_ITERATE = 0,
+  AVERAGE_ITERATE,
+} termination_iterate;
+
+typedef enum {
+  PDHG_FIXED_LINESEARCH = 0,
+  PDHG_MALITSKY_POCK_LINESEARCH,
+  PDHG_ADAPTIVE_LINESEARCH
+} pdhg_linesearch;
+
+typedef enum {
+  PDHG_WITHOUT_RESTART = 0,
+  PDHG_GPU_RESTART,
+  PDHG_CPU_RESTART,
+} pdhg_restart;
+
+typedef enum {
+  CPU = 0,
+  SINGLE_GPU,
+  MULTI_GPU,
+} CUPDLP_DEVICE;
+
+typedef enum {
+  DENSE = 0,
+  CSR,
+  CSC,
+  CSR_CSC,
+} CUPDLP_MATRIX_FORMAT;
+
+typedef enum {
+  N_ITER_LIM = 0,
+  IF_SCALING,
+  I_SCALING_METHOD,
+  E_LINE_SEARCH_METHOD,
+  E_RESTART_METHOD,
+  IF_RUIZ_SCALING,
+  IF_L2_SCALING,
+  IF_PC_SCALING,
+  N_LOG_LEVEL,
+  N_LOG_INTERVAL,
+  IF_PRESOLVE,
+  I_INF_NORM_ABS_LOCAL_TERMINATION,
+  N_INT_USER_PARAM
+} CUPDLP_INT_USER_PARAM_INDEX;
+  //#define N_INT_USER_PARAM 12
+typedef enum {
+  D_SCALING_LIMIT = 0,
+  D_PRIMAL_TOL,
+  D_DUAL_TOL,
+  D_GAP_TOL,
+  D_FEAS_TOL,
+  D_TIME_LIM,
+  N_FLOAT_USER_PARAM
+} CUPDLP_FLOAT_USER_PARAM_INDEX;
+  //#define N_FLOAT_USER_PARAM 6
+
+// used in sparse matrix-dense vector multiplication
+struct CUPDLP_CUDA_DENSE_VEC {
+  cupdlp_int len;
+  cupdlp_float *data;
+#ifndef CUPDLP_CPU
+  cusparseDnVecDescr_t cuda_vec;
+#endif
+};
+
+struct CUPDLP_DENSE_MATRIX {
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  cupdlp_float *data;
+};
+
+struct CUPDLP_CSR_MATRIX {
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  cupdlp_int nMatElem;
+  cupdlp_int *rowMatBeg;
+  cupdlp_int *rowMatIdx;
+  cupdlp_float *rowMatElem;
+#ifndef CUPDLP_CPU
+  // Pointers to GPU vectors
+  cusparseSpMatDescr_t cuda_csr;
+#endif
+};
+
+struct CUPDLP_CSC_MATRIX {
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  cupdlp_int nMatElem;
+  cupdlp_int *colMatBeg;
+  cupdlp_int *colMatIdx;
+  cupdlp_float *colMatElem;
+
+  // Used to avoid implementing NormInf on cuda
+  cupdlp_float MatElemNormInf;
+#ifndef CUPDLP_CPU
+  // Pointers to GPU vectors
+  cusparseSpMatDescr_t cuda_csc;
+#endif
+};
+
+struct CUPDLP_DATA {
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  CUPDLP_MATRIX_FORMAT matrix_format;
+  CUPDLPdense *dense_matrix;
+  CUPDLPcsr *csr_matrix;
+  CUPDLPcsc *csc_matrix;
+  CUPDLP_DEVICE device;
+};
+
+struct CUPDLP_SETTINGS {
+  // scaling
+  cupdlp_int ifScaling;
+  cupdlp_int iScalingMethod;
+  cupdlp_float dScalingLimit;
+
+  // termination criteria
+  cupdlp_float dPrimalTol;
+  cupdlp_float dDualTol;
+  cupdlp_float dGapTol;
+
+  // max iter and time
+  cupdlp_int nIterLim;
+  cupdlp_float dTimeLim;
+
+  // Logging
+  cupdlp_int nLogLevel;
+  cupdlp_int nLogInterval;
+
+  // restart
+  pdhg_restart eRestartMethod;
+};
+
+// some elements are duplicated from CUPDLP_DATA
+struct CUPDLP_PROBLEM {
+  /* Copy of LP problem with permuted columns. */
+  CUPDLPdata *data;
+  // cupdlp_int nMatElem;
+  // cupdlp_int *colMatBeg;
+  // cupdlp_int *colMatIdx;
+  // cupdlp_float *colMatElem;
+  // cupdlp_int *rowMatBeg;
+  // cupdlp_int *rowMatIdx;
+  // cupdlp_float *rowMatElem;
+  cupdlp_float *lower;
+  cupdlp_float *upper;
+  cupdlp_float *cost;  // cost for minimization
+  cupdlp_float *rhs;
+  cupdlp_float dMaxCost;
+  cupdlp_float dMaxRhs;
+  cupdlp_float dMaxRowBound;
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  cupdlp_int nEqs;
+  cupdlp_float *hasLower;
+  cupdlp_float *hasUpper;
+  cupdlp_float
+      offset;  // true objVal = c'x * sig + offset, sig = 1 (min) or -1 (max)
+  cupdlp_float sense_origin;  // sig = 1 (min) or -1 (max)
+};
+
+struct CUPDLP_RES_OBJ {
+  /* residuals and objectives */
+  cupdlp_float dFeasTol;
+  cupdlp_float dPrimalObj;
+  cupdlp_float dDualObj;
+  cupdlp_float dDualityGap;
+  cupdlp_float dComplementarity;
+  cupdlp_float dPrimalFeas;
+  cupdlp_float dDualFeas;
+  cupdlp_float dRelObjGap;
+  cupdlp_float *primalResidual;
+  cupdlp_float *dualResidual;
+  cupdlp_float *dSlackPos;
+  cupdlp_float *dSlackNeg;
+  cupdlp_float *dSlackPosAverage;
+  cupdlp_float *dSlackNegAverage;
+  cupdlp_float *dLowerFiltered;
+  cupdlp_float *dUpperFiltered;
+
+  /* for infeasibility detection */
+  termination_code primalCode;
+  termination_code dualCode;
+  termination_iterate termInfeasIterate;
+
+  cupdlp_float dPrimalInfeasObj;
+  cupdlp_float dDualInfeasObj;
+  cupdlp_float dPrimalInfeasRes;
+  cupdlp_float dDualInfeasRes;
+
+  cupdlp_float dPrimalInfeasObjAverage;
+  cupdlp_float dDualInfeasObjAverage;
+  cupdlp_float dPrimalInfeasResAverage;
+  cupdlp_float dDualInfeasResAverage;
+
+  // buffers
+  cupdlp_float *primalInfeasRay;     // x / norm(x)
+  cupdlp_float *primalInfeasConstr;  // [Ax, min(Gx, 0)]
+  cupdlp_float *primalInfeasBound;   // primal bound violation
+  cupdlp_float *dualInfeasRay;       // y / norm(y, lbd)
+  cupdlp_float *dualInfeasLbRay;     // lbd^+ / norm(y, lbd)
+  cupdlp_float *dualInfeasUbRay;     // lbd^- / norm(y, lbd)
+  cupdlp_float *dualInfeasConstr;    // ATy1 + GTy2 + lambda
+  // cupdlp_float *dualInfeasBound;     // dual bound violation
+
+  cupdlp_float dPrimalObjAverage;
+  cupdlp_float dDualObjAverage;
+  cupdlp_float dDualityGapAverage;
+  cupdlp_float dComplementarityAverage;
+  cupdlp_float dPrimalFeasAverage;
+  cupdlp_float dDualFeasAverage;
+  cupdlp_float dRelObjGapAverage;
+  cupdlp_float *primalResidualAverage;
+  cupdlp_float *dualResidualAverage;
+
+  cupdlp_float dPrimalFeasLastRestart;
+  cupdlp_float dDualFeasLastRestart;
+  cupdlp_float dDualityGapLastRestart;
+
+  cupdlp_float dPrimalFeasLastCandidate;
+  cupdlp_float dDualFeasLastCandidate;
+  cupdlp_float dDualityGapLastCandidate;
+
+  termination_code termCode;
+  termination_iterate termIterate;
+};
+
+struct CUPDLP_ITERATES {
+  /* iterates */
+  cupdlp_int nRows;
+  cupdlp_int nCols;
+  //  todo, CPU VERSION, check
+  //        cupdlp_float *x;
+  //        cupdlp_float *y;
+  //        cupdlp_float *xUpdate;
+  //        cupdlp_float *yUpdate;
+  //
+  //        cupdlp_int iLastRestartIter;
+  //        cupdlp_float dLastRestartDualityGap;
+  //        cupdlp_float dLastRestartBeta;
+  //        cupdlp_float *xSum;
+  //        cupdlp_float *ySum;
+  //        cupdlp_float *xAverage;
+  //        cupdlp_float *yAverage;
+  //        cupdlp_float *xLastRestart;
+  //        cupdlp_float *yLastRestart;
+  //
+  //        cupdlp_float *ax;
+  //        cupdlp_float *axUpdate;
+  //        cupdlp_float *axAverage;
+  //        cupdlp_float *aty;
+  //        cupdlp_float *atyUpdate;
+  //        cupdlp_float *atyAverage;
+
+  cupdlp_int iLastRestartIter;
+  cupdlp_float dLastRestartDualityGap;
+  cupdlp_float dLastRestartBeta;
+  cupdlp_float *xSum;
+  cupdlp_float *ySum;
+
+  cupdlp_float *xLastRestart;
+  cupdlp_float *yLastRestart;
+
+  CUPDLPvec *x[2]; // in iteration k, x^k stored in x[k % 2], x^{k+1} created in x[k + 1 % 2]
+  CUPDLPvec *y[2];
+  CUPDLPvec *ax[2];
+  CUPDLPvec *aty[2];
+  CUPDLPvec *xAverage, *yAverage, *axAverage, *atyAverage;
+
+};
+
+struct CUPDLP_STEPSIZE {
+  /* stepsize */
+  pdhg_linesearch eLineSearchMethod;  // 0 = FixedStep
+  cupdlp_float dPrimalStep;
+  cupdlp_float dDualStep;
+  cupdlp_float dSumPrimalStep;
+  cupdlp_float dSumDualStep;
+  // Stepsize ratio,
+  //  \beta = dBeta = dDualStep / dPrimalStep,
+  //    in the paper, primal weight is the \omega:
+  //    \omega = \sqrt\beta
+  cupdlp_float dBeta;
+  cupdlp_float dTheta;  // Used in Malitsky-Pock stepsize
+  cupdlp_int nStepSizeIter;
+};
+
+struct CUPDLP_SCALING {
+  /* scaling */
+  cupdlp_int ifScaled;
+  cupdlp_float *rowScale;
+  cupdlp_float *colScale;
+
+  /*new scaling*/
+  cupdlp_int ifRuizScaling;
+  cupdlp_int ifL2Scaling;
+  cupdlp_int ifPcScaling;
+  cupdlp_int RuizTimes;
+  cupdlp_float RuizNorm;
+  cupdlp_float PcAlpha;
+
+  /* original 2 norm */
+  cupdlp_float dNormCost;
+  cupdlp_float dNormRhs;
+};
+
+struct CUPDLP_TIMERS {
+  /* timers */
+  cupdlp_int nIter;
+  cupdlp_float dSolvingTime;
+  cupdlp_float dSolvingBeg;
+  cupdlp_float dScalingTime;
+  cupdlp_float dPresolveTime;
+#if PDHG_USE_TIMERS
+  cupdlp_float dAtyTime;
+  cupdlp_float dAxTime;
+  cupdlp_float dComputeResidualsTime;
+  cupdlp_float dUpdateIterateTime;
+  cupdlp_int nAtyCalls;
+  cupdlp_int nAxCalls;
+  cupdlp_int nComputeResidualsCalls;
+  cupdlp_int nUpdateIterateCalls;
+#endif
+#ifndef CUPDLP_CPU
+  // GPU timers
+  cupdlp_float AllocMem_CopyMatToDeviceTime;
+  cupdlp_float CopyVecToDeviceTime;
+  cupdlp_float DeviceMatVecProdTime;
+  cupdlp_float CopyVecToHostTime;
+  cupdlp_float FreeDeviceMemTime;
+  cupdlp_float CudaPrepareTime;
+#endif
+};
+
+struct DebugPdlpData {
+  double ax_norm;
+  double aty_norm;
+  double ax_average_norm;
+  double aty_average_norm;
+  double x_average_norm;
+};
+    
+struct CUPDLP_WORK {
+  CUPDLPproblem *problem;
+  CUPDLPsettings *settings;
+  CUPDLPresobj *resobj;
+  CUPDLPiterates *iterates;
+  CUPDLPstepsize *stepsize;
+  CUPDLPscaling *scaling;
+  CUPDLPtimers *timers;
+  // cupdlp_float *buffer;
+  CUPDLPvec *buffer;
+  cupdlp_float *buffer2;
+  cupdlp_float *buffer3;
+
+  cupdlp_float *rowScale;
+  cupdlp_float *colScale;
+#ifndef CUPDLP_CPU
+  // CUDAmv *MV;
+  cusparseHandle_t cusparsehandle;
+  void *dBuffer_csc_ATy;
+  void *dBuffer_csr_Ax;
+
+  // cusparseDnVecDescr_t vecbuffer;
+  cublasHandle_t cublashandle;
+#endif
+
+#if PDLP_DEBUG_LOG 
+  FILE* debug_pdlp_log_file_;
+  struct DebugPdlpData debug_pdlp_data_;
+#endif
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/lpsolver-highs/build/include/highs/pdlp/cupdlp/cupdlp_linalg.h

@@ -0,0 +1,189 @@
+#ifndef CUPDLP_CUPDLP_LINALG_H
+#define CUPDLP_CUPDLP_LINALG_H
+
+#include "cupdlp_defs.h"
+#include "cupdlp_utils.h"
+
+#ifndef CUPDLP_CPU
+#include "cuda/cupdlp_cudalinalg.cuh"
+#endif
+
+void ScatterCol(CUPDLPwork *w, cupdlp_int iCol, cupdlp_float multiplier,
+                cupdlp_float *target);
+
+void ScatterRow(CUPDLPwork *w, cupdlp_int iRow, cupdlp_float multiplier,
+                cupdlp_float *target);
+
+void AxCPU(CUPDLPwork *w, cupdlp_float *ax, const cupdlp_float *x);
+
+void ATyCPU(CUPDLPwork *w, cupdlp_float *aty, const cupdlp_float *y);
+
+extern double nrm2(cupdlp_int n, const double *x, cupdlp_int incx);
+
+extern double nrminf(cupdlp_int n, const double *x, cupdlp_int incx);
+
+double twoNorm(double *x, cupdlp_int n);
+
+double twoNormSquared(double *x, cupdlp_int n);
+
+double infNorm(double *x, cupdlp_int n);
+
+cupdlp_int infNormIndex(double *x, cupdlp_int n);
+
+/*------------------------ new added --------------------*/
+
+double GenNorm(double *x, cupdlp_int n, cupdlp_float p);
+
+void cupdlp_cdot(cupdlp_float *x, const cupdlp_float *y, const cupdlp_int len);
+
+void cupdlp_cdiv(cupdlp_float *x, const cupdlp_float *y, const cupdlp_int len);
+
+// void cupdlp_scaleVector(cupdlp_float *xout, cupdlp_float *x, cupdlp_float
+// weight, const cupdlp_int len);
+void cupdlp_projLowerBound(cupdlp_float *x, const cupdlp_float *lb,
+                           const cupdlp_int len);
+void cupdlp_projUpperBound(cupdlp_float *x, const cupdlp_float *ub,
+                           const cupdlp_int len);
+void cupdlp_projSameLowerBound(cupdlp_float *x, const cupdlp_float lb,
+                               const cupdlp_int len);
+void cupdlp_projSameUpperBound(cupdlp_float *x, const cupdlp_float ub,
+                               const cupdlp_int len);
+void cupdlp_projPositive(cupdlp_float *x, const cupdlp_int len);
+void cupdlp_projNegative(cupdlp_float *x, const cupdlp_int len);
+
+// void cupdlp_projLowerBound(cupdlp_float *xout, cupdlp_float *x, cupdlp_float
+// *lb, const cupdlp_int len); void cupdlp_projUpperBound(cupdlp_float *xout,
+// cupdlp_float *x, cupdlp_float *ub, const cupdlp_int len); void
+// cupdlp_projSameLowerBound(cupdlp_float *xout, cupdlp_float *x, cupdlp_float
+// lb, const cupdlp_int len); void cupdlp_projSameUpperBound(cupdlp_float *xout,
+// cupdlp_float *x, cupdlp_float ub, const cupdlp_int len); void
+// cupdlp_projPositive(cupdlp_float *xout, cupdlp_float *x, const cupdlp_int
+// len); void cupdlp_projNegative(cupdlp_float *xout, cupdlp_float *x, const
+// cupdlp_int len); cupdlp_float cupdlp_diffTwoNormSquared(cupdlp_float *x,
+// cupdlp_float *y, const cupdlp_int len); cupdlp_float
+// cupdlp_diffTwoNorm(cupdlp_float *x, cupdlp_float *y, const cupdlp_int len);
+// cupdlp_float cupdlp_diffInfNorm(cupdlp_float *x, cupdlp_float *y, const
+// cupdlp_int len); cupdlp_float cupdlp_diffDotDiff(cupdlp_float *x1,
+// cupdlp_float *x2, cupdlp_float *y1, cupdlp_float *y2, const cupdlp_int len);
+// void cupdlp_cdot_fb(cupdlp_float *x, const cupdlp_bool *y, const cupdlp_int
+// len);
+
+/*------------------------ new added --------------------*/
+
+extern double dot(cupdlp_int n, const cupdlp_float *x, cupdlp_int incx,
+                  const cupdlp_float *y, cupdlp_int incy);
+
+extern double Dotprod(const cupdlp_float *x, const cupdlp_float *y, cupdlp_int n);
+
+// todo, add this
+extern double Dotprod_Neumaier(const cupdlp_float *x, const cupdlp_float *y, cupdlp_int n);
+
+/* x = x + weight * y */
+void AddToVector(cupdlp_float *x, const cupdlp_float weight,
+                 const cupdlp_float *y, const cupdlp_int n);
+
+void ScaleVector(cupdlp_float weight, cupdlp_float *x, cupdlp_int n);
+
+// The main matrix-vector multiplication routines
+// #ifndef CUPDLP_CPU
+// Ax currently only works for CSC matrix multiply dense vector
+// void Ax(CUPDLPwork *w, cupdlp_float *ax, const cupdlp_float *x);
+// void Ax(CUPDLPwork *w, cupdlp_float *ax, void* vecAx, const cupdlp_float *x,
+// void *vecX);
+void Ax(CUPDLPwork *w, CUPDLPvec *ax, const CUPDLPvec *x);
+
+// ATy currently only works for CSR matrix multiply dense vector
+// void ATy(CUPDLPwork *w, cupdlp_float *aty, const cupdlp_float *y);
+// void ATy(CUPDLPwork *w, cupdlp_float *aty, void *vecATy, const cupdlp_float
+// *y, void *vecY);
+void ATy(CUPDLPwork *w, CUPDLPvec *aty, const CUPDLPvec *y);
+
+// #endif
+
+/*-------------- Apis compatible with both CPU and GPU -------------------*/
+// only implemented the APis need to be used on GPU
+
+// functions in cublas
+cupdlp_int cupdlp_axpy(CUPDLPwork *w, const cupdlp_int n,
+                       const cupdlp_float *alpha, const cupdlp_float *x,
+                       cupdlp_float *y);
+
+cupdlp_int cupdlp_dot(CUPDLPwork *w, const cupdlp_int n, const cupdlp_float *x,
+                      const cupdlp_float *y, cupdlp_float *res);
+
+cupdlp_int cupdlp_twoNorm(CUPDLPwork *w, const cupdlp_int n,
+                          const cupdlp_float *x, cupdlp_float *res);
+
+cupdlp_int cupdlp_infNorm(CUPDLPwork *w, const cupdlp_int n,
+                          const cupdlp_float *x, cupdlp_float *res);
+
+cupdlp_int cupdlp_infNormIndex(CUPDLPwork *w, const cupdlp_int n,
+                               const cupdlp_float *x, cupdlp_int *res);
+
+cupdlp_int cupdlp_scaleVector(CUPDLPwork *w, const cupdlp_float weight,
+                              cupdlp_float *x, const cupdlp_int n);
+
+void cupdlp_twoNormSquared(CUPDLPwork *w, const cupdlp_int n,
+                           const cupdlp_float *x, cupdlp_float *res);
+
+void cupdlp_diffTwoNormSquared(CUPDLPwork *w, const cupdlp_float *x,
+                               const cupdlp_float *y, const cupdlp_int len,
+                               cupdlp_float *res);
+
+void cupdlp_diffTwoNorm(CUPDLPwork *w, const cupdlp_float *x,
+                        const cupdlp_float *y, const cupdlp_int len,
+                        cupdlp_float *res);
+
+void cupdlp_diffDotDiff(CUPDLPwork *w, const cupdlp_float *x1,
+                        const cupdlp_float *x2, const cupdlp_float *y1,
+                        const cupdlp_float *y2, const cupdlp_int len,
+                        cupdlp_float *res);
+
+// functions not in cublas
+/* element wise dot: x = x .* y*/
+void cupdlp_edot(cupdlp_float *x, const cupdlp_float *y, const cupdlp_int len);
+/* element wise div: x = x ./ y*/
+void cupdlp_ediv(cupdlp_float *x, const cupdlp_float *y, const cupdlp_int len);
+
+void cupdlp_projlb(cupdlp_float *x, const cupdlp_float *lb,
+                   const cupdlp_int len);
+
+void cupdlp_projub(cupdlp_float *x, const cupdlp_float *ub,
+                   const cupdlp_int len);
+
+void cupdlp_projSamelb(cupdlp_float *x, const cupdlp_float lb,
+                       const cupdlp_int len);
+
+void cupdlp_projSameub(cupdlp_float *x, const cupdlp_float ub,
+                       const cupdlp_int len);
+
+/* xout = max(x, 0) */
+void cupdlp_projPos(cupdlp_float *x, const cupdlp_int len);
+
+/* xout = min(x, 0) */
+void cupdlp_projNeg(cupdlp_float *x, 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);
+
+void cupdlp_filterlb(cupdlp_float *x, const cupdlp_float *lb,
+                     const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_filterub(cupdlp_float *x, const cupdlp_float *ub,
+                     const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_initvec(cupdlp_float *x, const cupdlp_float val,
+                    const cupdlp_int len);
+
+void cupdlp_compute_interaction_and_movement(CUPDLPwork *w,
+                                             cupdlp_float *dMovement,
+                                             cupdlp_float *dIteraction);
+
+// WIP
+// double get_fabs_value(double* vec, int index);
+// double get_fabs_value(double* vec, int index, int N);
+
+#endif  // CUPDLP_CUPDLP_LINALG_H

data/ext/lpsolver-highs/build/include/highs/pdlp/cupdlp/cupdlp_proj.h

@@ -0,0 +1,19 @@
+//
+// Created by chuwen on 23-11-28.
+//
+
+#ifndef CUPDLP_CUPDLP_PROJ_H
+#define CUPDLP_CUPDLP_PROJ_H
+
+#include "pdlp/cupdlp/cupdlp_defs.h"
+#include "pdlp/cupdlp/glbopts.h"
+
+void PDHG_Project_Bounds(CUPDLPwork *work, double *r);
+
+// void PDHG_Project_Row_Duals(CUPDLPwork *work, double *r);
+
+void PDHG_Restart_Iterate(CUPDLPwork *pdhg);
+
+void PDHG_Restart_Iterate_GPU(CUPDLPwork *pdhg);
+
+#endif  // CUPDLP_CUPDLP_PROJ_H