lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/pdlp/cupdlp/cupdlp_utils.h

@@ -0,0 +1,212 @@
+//
+// Created by chuwen on 23-11-26.
+//
+
+#ifndef CUPDLP_CUPDLP_UTILS_H
+#define CUPDLP_CUPDLP_UTILS_H
+
+#include <stdio.h>
+#ifdef CUPDLP_TIMER
+#include <time.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+#include <time.h>
+#else
+#include <sys/time.h>
+#endif
+
+#endif
+#include "pdlp/cupdlp/cupdlp_defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void data_clear(CUPDLPdata *data);
+
+void problem_clear(CUPDLPproblem *problem);
+
+cupdlp_int vec_clear(CUPDLPvec *vec);
+
+void settings_clear(CUPDLPsettings *settings);
+
+void iterates_clear(CUPDLPiterates *iterates);
+
+void resobj_clear(CUPDLPresobj *resobj);
+
+void stepsize_clear(CUPDLPstepsize *stepsize);
+
+void timers_clear(int log_level, CUPDLPtimers *timers);
+
+void scaling_clear(CUPDLPscaling *scaling);
+
+cupdlp_int PDHG_Clear(CUPDLPwork *w);
+
+void PDHG_PrintPDHGParam(CUPDLPwork *w);
+
+void PDHG_PrintHugeCUPDHG(void);
+
+void PDHG_PrintUserParamHelper(void);
+
+cupdlp_retcode getUserParam(int argc, char **argv,
+                            cupdlp_bool *ifChangeIntParam, cupdlp_int *intParam,
+                            cupdlp_bool *ifChangeFloatParam,
+                            cupdlp_float *floatParam);
+
+cupdlp_retcode settings_SetUserParam(CUPDLPsettings *settings,
+                                     cupdlp_bool *ifChangeIntParam,
+                                     cupdlp_int *intParam,
+                                     cupdlp_bool *ifChangeFloatParam,
+                                     cupdlp_float *floatParam);
+
+cupdlp_retcode resobj_SetUserParam(CUPDLPresobj *resobj,
+                                   cupdlp_bool *ifChangeIntParam,
+                                   cupdlp_int *intParam,
+                                   cupdlp_bool *ifChangeFloatParam,
+                                   cupdlp_float *floatParam);
+
+cupdlp_retcode iterates_SetUserParam(CUPDLPiterates *iterates,
+                                     cupdlp_bool *ifChangeIntParam,
+                                     cupdlp_int *intParam,
+                                     cupdlp_bool *ifChangeFloatParam,
+                                     cupdlp_float *floatParam);
+
+cupdlp_retcode stepsize_SetUserParam(CUPDLPstepsize *stepsize,
+                                     cupdlp_bool *ifChangeIntParam,
+                                     cupdlp_int *intParam,
+                                     cupdlp_bool *ifChangeFloatParam,
+                                     cupdlp_float *floatParam);
+
+cupdlp_retcode scaling_SetUserParam(CUPDLPscaling *scaling,
+                                    cupdlp_bool *ifChangeIntParam,
+                                    cupdlp_int *intParam,
+                                    cupdlp_bool *ifChangeFloatParam,
+                                    cupdlp_float *floatParam);
+
+cupdlp_retcode timers_SetUserParam(CUPDLPtimers *timers,
+                                   cupdlp_bool *ifChangeIntParam,
+                                   cupdlp_int *intParam,
+                                   cupdlp_bool *ifChangeFloatParam,
+                                   cupdlp_float *floatParam);
+
+cupdlp_retcode PDHG_SetUserParam(CUPDLPwork *w, cupdlp_bool *ifChangeIntParam,
+                                 cupdlp_int *intParam,
+                                 cupdlp_bool *ifChangeFloatParam,
+                                 cupdlp_float *floatParam);
+
+cupdlp_retcode vec_Alloc(CUPDLPvec *vec, cupdlp_int n);
+
+cupdlp_retcode settings_Alloc(CUPDLPsettings *settings);
+
+cupdlp_retcode resobj_Alloc(CUPDLPresobj *resobj, CUPDLPproblem *problem,
+                            cupdlp_int ncols, cupdlp_int nrows);
+
+cupdlp_retcode iterates_Alloc(CUPDLPiterates *iterates, cupdlp_int ncols,
+                              cupdlp_int nrows);
+
+cupdlp_retcode stepsize_Alloc(CUPDLPstepsize *stepsize);
+
+cupdlp_retcode timers_Alloc(CUPDLPtimers *timers);
+
+void PDHG_Init_Data(CUPDLPwork *w);
+
+cupdlp_retcode PDHG_Alloc(CUPDLPwork *w);
+
+cupdlp_retcode PDHG_Create(CUPDLPwork **ww, CUPDLPproblem *lp,
+                           CUPDLPscaling *scaling);
+
+void PDHG_Destroy(CUPDLPwork **w);
+
+void vecPrint(const char *s, const cupdlp_float *a, cupdlp_int n);
+
+void vecIntPrint(const char *s, const cupdlp_int *a, cupdlp_int n);
+
+void PDHG_Dump_Stats(CUPDLPwork *w);
+
+/* TODO: Add compatibility for Windows platform */
+double my_clock(void);
+
+extern double getTimeStamp(void);
+
+cupdlp_retcode dense_create(CUPDLPdense **dense);
+
+cupdlp_retcode csr_create(CUPDLPcsr **csr);
+
+cupdlp_retcode csc_create(CUPDLPcsc **csc);
+
+cupdlp_retcode dense_alloc(CUPDLPdense *dense, cupdlp_int nRows,
+                           cupdlp_int nCols, cupdlp_float *val);
+
+cupdlp_retcode csr_alloc(CUPDLPcsr *csr, cupdlp_int nRows, cupdlp_int nCols,
+                         cupdlp_int nnz, cupdlp_int *col_ptr,
+                         cupdlp_int *row_ind, cupdlp_float *val);
+
+cupdlp_retcode csc_alloc(CUPDLPcsc *csc, cupdlp_int nRows, cupdlp_int nCols,
+                         cupdlp_int nnz, cupdlp_int *row_ptr,
+                         cupdlp_int *col_ind, cupdlp_float *val);
+
+cupdlp_retcode dense_alloc_matrix(CUPDLPdense *dense, cupdlp_int nRows,
+                                  cupdlp_int nCols, void *src,
+                                  CUPDLP_MATRIX_FORMAT src_matrix_format);
+
+cupdlp_retcode csr_alloc_matrix(CUPDLPcsr *csr, cupdlp_int nRows,
+                                cupdlp_int nCols, void *src,
+                                CUPDLP_MATRIX_FORMAT src_matrix_format);
+
+cupdlp_retcode csc_alloc_matrix(CUPDLPcsc *csc, cupdlp_int nRows,
+                                cupdlp_int nCols, void *src,
+                                CUPDLP_MATRIX_FORMAT src_matrix_format);
+
+void dense2csr(CUPDLPcsr *csr, CUPDLPdense *dense);
+
+void dense2csc(CUPDLPcsc *csc, CUPDLPdense *dense);
+
+void csr2csc(CUPDLPcsc *csc, CUPDLPcsr *csr);
+
+cupdlp_int csc2csr(CUPDLPcsr *csr, CUPDLPcsc *csc);
+
+void csr2dense(CUPDLPdense *dense, CUPDLPcsr *csr);
+
+void csc2dense(CUPDLPdense *dense, CUPDLPcsc *csc);
+
+cupdlp_int csc_clear(CUPDLPcsc *csc);
+
+cupdlp_int csc_clear_host(CUPDLPcsc *csc);
+
+cupdlp_int csr_clear(CUPDLPcsr *csr);
+
+void dense_clear(CUPDLPdense *dense);
+
+void dense_copy(CUPDLPdense *dst, CUPDLPdense *src);
+
+void csr_copy(CUPDLPcsr *dst, CUPDLPcsr *src);
+
+cupdlp_int csc_copy(CUPDLPcsc *dst, CUPDLPcsc *src);
+
+void csrPrintDense(const char *s, CUPDLPcsr *csr);
+
+void cscPrintDense(const char *s, CUPDLPcsc *csc);
+
+void writeJson(const char *fout, CUPDLPwork *work);
+
+void writeSol(const char *fout, cupdlp_int nCols, cupdlp_int nRows,
+              cupdlp_float *col_value, cupdlp_float *col_dual,
+              cupdlp_float *row_value, cupdlp_float *row_dual);
+
+  void debugPdlpIterHeaderLog(FILE* file);
+  void debugPdlpDataInitialise(struct DebugPdlpData* debug_pdlp);
+  void debugPdlpIterLog(FILE* file, const int iter_num, const struct DebugPdlpData* debug_pdlp, const double beta, const double primal_step, const double dual_step);
+  void debugPdlpFeasOptLog(FILE* file,
+			   const int iter_num,
+			   const double primal_obj, const double dual_obj,
+			   const double gap, const double primal_feas, const double dual_feas,
+			   const char* type);
+  void debugPdlpRestartLog(FILE* file, const int iter_num, const double current_score, const double average_score);
+  void debugPdlpRestarScoretLog(FILE* file, const double weight_squared, const double primal_feas, const double dual_feas, const double obj_gap);
+  void debugPdlpFinalSolutionLog(FILE* file, const double* x, int nCols, const double* y, int nRows);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // CUPDLP_CUPDLP_UTILS_H

data/ext/lpsolver-highs/highs/pdlp/cupdlp/glbopts.h

@@ -0,0 +1,342 @@
+#ifndef GLB_H_GUARD
+#define GLB_H_GUARD
+
+#include "HConfig.h"
+
+// #ifndef CUPDLP_CPU
+// #include <cublas_v2.h>         // cublas
+// #include <cuda_runtime_api.h>  // cudaMalloc, cudaMemcpy, etc.
+// #include <cusparse.h>          // cusparseSpMV
+// #endif
+
+#ifdef __cplusplus
+
+extern "C" {
+#endif
+
+#include <math.h>
+
+// return code
+#define RETCODE_OK (0)
+#define RETCODE_FAILED (1)
+#define BOOL (1)
+// #define DLONG
+
+#ifndef cupdlp
+#define cupdlp(x) cupdlp_##x
+#endif
+
+/* cupdlp VERSION NUMBER ----------------------------------------------    */
+#define cupdlp_VERSION \
+  ("1.0.0") /* string literals automatically null-terminated */
+
+#ifdef MATLAB_MEX_FILE
+#include "mex.h"
+#define cupdlp_printf mexPrintf
+#define _cupdlp_free mxFree
+#define _cupdlp_malloc mxMalloc
+#define _cupdlp_calloc mxCalloc
+#define _cupdlp_realloc mxRealloc
+#elif defined PYTHON
+#include <Python.h>
+#include <stdlib.h>
+#define cupdlp_printf(...)                           \
+  {                                                  \
+    PyGILState_STATE gilstate = PyGILState_Ensure(); \
+    PySys_WriteStdout(__VA_ARGS__);                  \
+    PyGILState_Release(gilstate);                    \
+  }
+#define _cupdlp_free free
+#define _cupdlp_malloc malloc
+#define _cupdlp_calloc calloc
+#define _cupdlp_realloc realloc
+#else
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define cupdlp_printf printf
+#define cupdlp_snprintf snprintf
+#define _cupdlp_free free
+#define _cupdlp_malloc malloc
+#define _cupdlp_calloc calloc
+#define _cupdlp_realloc realloc
+#endif
+
+// for cuda
+#ifdef CUPDLP_CPU
+
+#define CUPDLP_COPY_VEC(dst, src, type, size) \
+  memcpy(dst, src, sizeof(type) * (size))
+
+  //CUPDLP_INIT_VEC is not used
+  //
+  //#define CUPDLP_INIT_VEC(var, size)				\
+//  {                                                             \
+//    (var) = (typeof(var))malloc((size) * sizeof(typeof(*var))); \
+//    if ((var) == cupdlp_NULL) {                                 \
+//      retcode = RETCODE_FAILED;                                 \
+//      goto exit_cleanup;                                        \
+//    }                                                           \
+//  }
+  //#define CUPDLP_INIT_ZERO_VEC(var, size)		     \
+//  {                                                          \
+//    (var) = (typeof(var))calloc(size, sizeof(typeof(*var))); \
+//    if ((var) == cupdlp_NULL) {                              \
+//      retcode = RETCODE_FAILED;                              \
+//      goto exit_cleanup;                                     \
+//    }                                                        \
+//  }
+#define cupdlp_init_zero_vec_double(var, size)                      \
+  {                                                          \
+    (var) = (double*)calloc(size, sizeof(double));	     \
+    if ((var) == cupdlp_NULL) {                              \
+      retcode = RETCODE_FAILED;                              \
+      goto exit_cleanup;                                     \
+    }                                                        \
+  }
+#define cupdlp_init_zero_vec_int(var, size)                      \
+  {                                                          \
+    (var) = (int*)calloc(size, sizeof(int));	     \
+    if ((var) == cupdlp_NULL) {                              \
+      retcode = RETCODE_FAILED;                              \
+      goto exit_cleanup;                                     \
+    }                                                        \
+  }
+#define CUPDLP_FREE_VEC(x) \
+  {                        \
+    _cupdlp_free(x);       \
+    x = cupdlp_NULL;       \
+  }
+#define CUPDLP_ZERO_VEC(var, type, size) memset(var, 0, sizeof(type) * (size))
+
+#endif
+
+#define cupdlp_free(x) \
+  {                    \
+    _cupdlp_free(x);   \
+    x = cupdlp_NULL;   \
+  }
+#define cupdlp_malloc(x) _cupdlp_malloc(x)
+#define cupdlp_calloc(x, y) _cupdlp_calloc(x, y)
+#define cupdlp_realloc(x, y) _cupdlp_realloc(x, y)
+#define cupdlp_zero(var, type, size) memset(var, 0, sizeof(type) * (size))
+#define cupdlp_copy(dst, src, type, size) \
+  memcpy(dst, src, sizeof(type) * (size))
+//#define CUPDLP_INIT(var, size)				\
+//  {                                                             \
+//    (var) = (typeof(var))malloc((size) * sizeof(typeof(*var))); \
+//    if ((var) == cupdlp_NULL) {                                 \
+//      retcode = RETCODE_FAILED;                                 \
+//      goto exit_cleanup;                                        \
+//    }                                                           \
+//  }
+#define CUPDLP_INIT_DOUBLE(var, size)                                  \
+  {                                                             \
+    (var) = (double*)malloc((size) * sizeof(double)); \
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_CUPDLP_VEC(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPvec*)malloc((size) * sizeof(CUPDLPvec)); \
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_DENSE_MATRIX(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPdense*)malloc((size) * sizeof(CUPDLPdense)); \
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_CSR_MATRIX(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPcsr*)malloc((size) * sizeof(CUPDLPcsr)); \
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_CSC_MATRIX(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPcsc*)malloc((size) * sizeof(CUPDLPcsc));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_SETTINGS(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPsettings*)malloc((size) * sizeof(CUPDLPsettings));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_RESOBJ(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPresobj*)malloc((size) * sizeof(CUPDLPresobj));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_ITERATES(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPiterates*)malloc((size) * sizeof(CUPDLPiterates));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_STEPSIZE(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPstepsize*)malloc((size) * sizeof(CUPDLPstepsize));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+#define CUPDLP_INIT_TIMERS(var, size)                                  \
+  {                                                             \
+    (var) = (CUPDLPtimers*)malloc((size) * sizeof(CUPDLPtimers));	\
+    if ((var) == cupdlp_NULL) {                                 \
+      retcode = RETCODE_FAILED;                                 \
+      goto exit_cleanup;                                        \
+    }                                                           \
+  }
+  //#define CUPDLP_INIT_ZERO(var, size)			     \
+//  {                                                          \
+//    (var) = (typeof(var))calloc(size, sizeof(typeof(*var))); \
+//    if ((var) == cupdlp_NULL) {                              \
+//      retcode = RETCODE_FAILED;                              \
+//      goto exit_cleanup;                                     \
+//    }                                                        \
+//  }
+#define CUPDLP_INIT_ZERO_DOUBLE(var, size)                          \
+  {                                                          \
+    (var) = (double*)calloc(size, sizeof(double)); \
+    if ((var) == cupdlp_NULL) {                              \
+      retcode = RETCODE_FAILED;                              \
+      goto exit_cleanup;                                     \
+    }                                                        \
+  }
+#define CUPDLP_INIT_ZERO_CUPDLP_WORK(var, size)                          \
+  {                                                          \
+    (var) = (CUPDLPwork*)calloc(size, sizeof(CUPDLPwork)); \
+    if ((var) == cupdlp_NULL) {                              \
+      retcode = RETCODE_FAILED;                              \
+      goto exit_cleanup;                                     \
+    }                                                        \
+  }
+#define CUPDLP_FREE(var) cupdlp_free(var)
+#define CUPDLP_CALL(func)       \
+  {                             \
+    if ((func) != RETCODE_OK) { \
+      retcode = RETCODE_FAILED; \
+      goto exit_cleanup;        \
+    }                           \
+  }
+
+#ifndef SFLOAT
+#ifdef DLONG
+typedef long long cupdlp_int;
+#else
+typedef int cupdlp_int;
+#endif
+typedef double cupdlp_float;
+#ifndef NAN
+#define NAN ((cupdlp_float)0x7ff8000000000000)
+#endif
+#ifndef INFINITY
+#define INFINITY NAN
+#endif
+#else
+typedef float cupdlp_float;
+#ifndef NAN
+#define NAN ((float)0x7fc00000)
+#endif
+#ifndef INFINITY
+#define INFINITY NAN
+#endif
+#endif
+
+#ifdef BOOL
+
+#include <stdbool.h>
+
+typedef bool cupdlp_bool;
+#endif
+
+#define cupdlp_NULL 0
+
+#ifndef MAX
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef ABS
+#define ABS(x) (((x) < 0) ? -(x) : (x))
+#endif
+
+#ifndef POWF
+#ifdef SFLOAT
+#define POWF powf
+#else
+#define POWF pow
+#endif
+#endif
+
+#ifndef SQRTF
+#ifdef SFLOAT
+#define SQRTF sqrtf
+#else
+#define SQRTF sqrt
+#endif
+#endif
+
+#if EXTRA_VERBOSE > 1
+#if (defined _WIN32 || defined _WIN64 || defined _WINDLL)
+#define __func__ __FUNCTION__
+#endif
+#define DEBUG_FUNC                                                     \
+  cupdlp_printf("IN function: %s, time: %4f ms, file: %s, line: %i\n", \
+                __func__, cupdlp(tocq)(&global_timer), __FILE__, __LINE__);
+#define RETURN
+cupdlp_printf("EXIT function: %s, time: %4f ms, file: %s, line: %i\n", __func__,
+              cupdlp(tocq)(&global_timer), __FILE__, __LINE__);
+return
+#else
+#define DEBUG_FUNC
+#define RETURN return
+#endif
+
+#define EPS_TOL (1E-18)
+#define EPS (1E-8)  // for condition number in subnp
+#define SAFEDIV_POS(X, Y) ((Y) < EPS_TOL ? ((X) / EPS_TOL) : (X) / (Y))
+
+#define CONVERGED_INTERVAL (1)
+#define INDETERMINATE_TOL (1e-9)
+
+#define OUR_DBL_MAX 1E+20
+
+#ifndef CUPDLP_ASSERT_H
+
+#include <assert.h>
+
+#define CUPDLP_ASSERT assert
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif