Handle objective sense (max/min) consistently across solver, API, and MPS reader

Keep problems in their original sense and normalize max→min once inside the core, reporting results back in the caller's sense (replaces the scattered
sign-flipping that caused objective/dual-sign bugs).

Author: ZedongPeng

include/cupdlpx.h

@@ -30,7 +30,8 @@ extern "C"
                                     const double *con_ub,
                                     const double *var_lb,
                                     const double *var_ub,
-                                    const double *objective_constant);
+                                    const double *objective_constant,
+                                    objective_sense_t objective_sense);
 
     // Set up initial primal and dual solution for an lp_problem_t
     void set_start_values(lp_problem_t *prob, const double *primal, const double *dual);

internal/internal_types.h

@@ -43,7 +43,7 @@ typedef struct
     double *variable_upper_bound;
     double *objective_vector;
     double objective_constant;
-    double objective_sign;
+    double original_objective_sign;
     cu_sparse_matrix_csr_t *constraint_matrix;
     cu_sparse_matrix_csr_t *constraint_matrix_t;
     double *constraint_lower_bound;

internal/solver.h

@@ -23,7 +23,7 @@ extern "C"
 {
 #endif
 
-    cupdlpx_result_t *optimize(const pdhg_parameters_t *params, lp_problem_t *original_problem);
+    cupdlpx_result_t *optimize(const pdhg_parameters_t *params, const lp_problem_t *original_problem);
 
 #ifdef __cplusplus
 }

internal/utils.h

@@ -124,7 +124,15 @@ extern "C"
 
     void check_termination_criteria(pdhg_solver_state_t *solver_state, const termination_criteria_t *criteria);
 
-    void print_initial_info(const pdhg_parameters_t *params, lp_problem_t *problem);
+    void print_initial_info(const pdhg_parameters_t *params, const lp_problem_t *problem);
+
+    void filter_constraint_matrix_entries(lp_problem_t *out, const lp_problem_t *in, const pdhg_parameters_t *params);
+
+    lp_problem_t preprocess_problem(const lp_problem_t *original, const pdhg_parameters_t *params);
+
+    void free_preprocessed_problem(const lp_problem_t *preprocessed, const lp_problem_t *original);
+
+    void restore_original_objective_sense(cupdlpx_result_t *result, objective_sense_t sense);
 
     void pdhg_final_log(const cupdlpx_result_t *result, const pdhg_parameters_t *params);
 

python/cupdlpx/model.py

@@ -355,23 +355,20 @@ def optimize(self):
         # check model sense
         if self.ModelSense not in (PDLP.MINIMIZE, PDLP.MAXIMIZE):
             raise ValueError("model_sense must be PDLP.MINIMIZE or PDLP.MAXIMIZE")
-        # determine sign
-        sign = 1 if self.ModelSense == PDLP.MINIMIZE else -1
-        # effective objective based on sense
-        c_eff  = sign * self.c if self.c is not None else None
-        c0_eff = sign * self.c0 if self.c0 is not None else None
+        minimize = self.ModelSense == PDLP.MINIMIZE
         # call the core solver
         info = solve_once(
             self.A,
-            c_eff,
-            c0_eff,
+            self.c,
+            self.c0,
             self.lb,
             self.ub,
             self.constr_lb,
             self.constr_ub,
             params=self._params,
             primal_start=self._primal_start,
-            dual_start=self._dual_start
+            dual_start=self._dual_start,
+            minimize=minimize,
         )
         # solutions
         self._x = np.asarray(info.get("X")) if info.get("X") is not None else None
@@ -380,8 +377,8 @@ def optimize(self):
         # objectives & gaps
         primal_obj_eff = info.get("PrimalObj")
         dual_obj_eff   = info.get("DualObj")
-        self._objval = sign * primal_obj_eff if primal_obj_eff is not None else None
-        self._dualobj = sign * dual_obj_eff if dual_obj_eff is not None else None
+        self._objval = primal_obj_eff if primal_obj_eff is not None else None
+        self._dualobj = dual_obj_eff if dual_obj_eff is not None else None
         self._gap = info.get("ObjectiveGap")
         self._rel_gap = info.get("RelativeObjectiveGap")
         # status & counters
@@ -398,8 +395,8 @@ def optimize(self):
         self._max_d_ray = info.get("MaxDualRayInfeas")
         p_ray_lin_eff  = info.get("PrimalRayLinObj")
         d_ray_obj_eff  = info.get("DualRayObj")
-        self._p_ray_lin_obj = sign * p_ray_lin_eff if p_ray_lin_eff is not None else None
-        self._d_ray_obj = sign * d_ray_obj_eff if d_ray_obj_eff is not None else None
+        self._p_ray_lin_obj = p_ray_lin_eff if p_ray_lin_eff is not None else None
+        self._d_ray_obj = d_ray_obj_eff if d_ray_obj_eff is not None else None
 
     def _clear_solution_cache(self) -> None:
         """

python_bindings/_core_bindings.cpp

@@ -464,7 +464,8 @@ static py::dict solve_once(py::object A,
                            py::object constraint_upper_bound,    // u  (optional → inf)
                            py::object params = py::none(),       // PDHG parameters (optional → default)
                            py::object primal_start = py::none(), // warm start primal solution (optional)
-                           py::object dual_start = py::none()    // warm start dual solution (optional)
+                           py::object dual_start = py::none(),   // warm start dual solution (optional)
+                           bool minimize = true                  // objective sense (true → minimize)
 )
 {
     // parse matrix
@@ -492,13 +493,14 @@ static py::dict solve_once(py::object A,
     }
 
     // build problem
-    lp_problem_t *prob = create_lp_problem(c_ptr,      // objective vector
-                                           &view.desc, // constraint matrix
-                                           l_ptr,      // constraint lower bound
-                                           u_ptr,      // constraint upper bound
-                                           lb_ptr,     // variable lower bound
-                                           ub_ptr,     // variable upper bound
-                                           c0_ptr      // objective constant
+    lp_problem_t *prob = create_lp_problem(c_ptr,                                                       // objective vector
+                                           &view.desc,                                                  // constraint matrix
+                                           l_ptr,                                                       // constraint lower bound
+                                           u_ptr,                                                       // constraint upper bound
+                                           lb_ptr,                                                      // variable lower bound
+                                           ub_ptr,                                                      // variable upper bound
+                                           c0_ptr,                                                      // objective constant
+                                           minimize ? OBJECTIVE_SENSE_MINIMIZE : OBJECTIVE_SENSE_MAXIMIZE // objective sense
     );
     if (!prob)
     {
@@ -595,5 +597,6 @@ PYBIND11_MODULE(_cupdlpx_core, m)
           py::arg("constraint_upper_bound") = py::none(),
           py::arg("params") = py::none(),
           py::arg("primal_start") = py::none(),
-          py::arg("dual_start") = py::none());
+          py::arg("dual_start") = py::none(),
+          py::arg("minimize") = true);
 }

src/cupdlpx.c

@@ -29,7 +29,8 @@ lp_problem_t *create_lp_problem(const double *objective_c,
                                 const double *con_ub,
                                 const double *var_lb,
                                 const double *var_ub,
-                                const double *objective_constant)
+                                const double *objective_constant,
+                                objective_sense_t objective_sense)
 {
     lp_problem_t *prob = (lp_problem_t *)safe_malloc(sizeof(lp_problem_t));
     prob->primal_start = NULL;
@@ -105,6 +106,7 @@ lp_problem_t *create_lp_problem(const double *objective_c,
 
     // default fill values
     prob->objective_constant = objective_constant ? *objective_constant : 0.0;
+    prob->objective_sense = objective_sense;
     fill_or_copy(&prob->objective_vector, prob->num_variables, objective_c, 0.0);
     fill_or_copy(&prob->variable_lower_bound, prob->num_variables, var_lb, -INFINITY);
     fill_or_copy(&prob->variable_upper_bound, prob->num_variables, var_ub, INFINITY);

src/mps_parser.c

@@ -534,8 +534,7 @@ lp_problem_t *read_mps_file(const char *filename)
     prob->num_variables = state.col_map.size;
     prob->num_constraints = state.row_map.size;
     prob->constraint_matrix_num_nonzeros = state.coo_matrix.nnz;
-    prob->objective_constant =
-        (state.objective_sense == OBJECTIVE_SENSE_MAXIMIZE) ? -state.objective_constant : state.objective_constant;
+    prob->objective_constant = state.objective_constant;
     prob->objective_sense = state.objective_sense;
 
     prob->objective_vector = state.objective_coeffs;
@@ -553,14 +552,6 @@ lp_problem_t *read_mps_file(const char *filename)
     state.constraint_lower_bounds = NULL;
     state.constraint_upper_bounds = NULL;
 
-    if (state.objective_sense == OBJECTIVE_SENSE_MAXIMIZE)
-    {
-        for (int i = 0; i < prob->num_variables; ++i)
-        {
-            prob->objective_vector[i] *= -1.0;
-        }
-    }
-
     if (mps_coo_to_csr(prob, &state.coo_matrix, prob->num_constraints) != 0)
     {
         fprintf(stderr, "ERROR: Failed to convert matrix to CSR format.\n");

src/presolve.c

@@ -189,6 +189,10 @@ void pslp_postsolve(const cupdlpx_presolve_info_t *info, cupdlpx_result_t *resul
     result->num_reduced_nonzeros = info->presolver->reduced_prob->nnz;
     result->presolve_status = info->presolve_status;
 
+    free(result->primal_solution);
+    free(result->dual_solution);
+    free(result->reduced_cost);
+
     result->primal_solution = (double *)safe_malloc(original_prob->num_variables * sizeof(double));
     result->dual_solution = (double *)safe_malloc(original_prob->num_constraints * sizeof(double));
     result->reduced_cost = (double *)safe_malloc(original_prob->num_variables * sizeof(double));
@@ -217,9 +221,8 @@ void pslp_postsolve(const cupdlpx_presolve_info_t *info, cupdlpx_result_t *resul
             obj += original_prob->objective_vector[i] * result->primal_solution[i];
         }
         obj += original_prob->objective_constant;
-        double objective_sign = (original_prob->objective_sense == OBJECTIVE_SENSE_MAXIMIZE) ? -1.0 : 1.0;
-        result->primal_objective_value = objective_sign * obj;
-        result->dual_objective_value = objective_sign * obj;
+        result->primal_objective_value = obj;
+        result->dual_objective_value = obj;
     }
     // if (info->presolver->stats != NULL) {
     //     result->presolve_stats = *(info->presolver->stats);

src/solver.cu

@@ -62,7 +62,8 @@ static cupdlpx_result_t *create_result_from_state(pdhg_solver_state_t *state, co
 static void perform_restart(pdhg_solver_state_t *state, const pdhg_parameters_t *params);
 static void initialize_step_size_and_primal_weight(pdhg_solver_state_t *state, const pdhg_parameters_t *params);
 static pdhg_solver_state_t *initialize_solver_state(const lp_problem_t *working_problem,
-                                                    const pdhg_parameters_t *params);
+                                                    const pdhg_parameters_t *params,
+                                                    objective_sense_t original_objective_sense);
 static void compute_fixed_point_error(pdhg_solver_state_t *state);
 void pdhg_solver_state_free(pdhg_solver_state_t *state);
 void rescale_info_free(rescale_info_t *info);
@@ -127,28 +128,33 @@ static void sync_step_sizes_to_gpu(pdhg_solver_state_t *state);
 void sync_inner_count_to_gpu(pdhg_solver_state_t *state);
 static void check_params_validity(const pdhg_parameters_t *params);
 
-cupdlpx_result_t *optimize(const pdhg_parameters_t *params, lp_problem_t *original_problem)
+cupdlpx_result_t *optimize(const pdhg_parameters_t *params, const lp_problem_t *original_problem)
 {
     check_params_validity(params);
+
     print_initial_info(params, original_problem);
 
-    cupdlpx_presolve_info_t *presolve_info = NULL;
-    const lp_problem_t *working_problem = original_problem;
+    lp_problem_t preprocessed_problem = preprocess_problem(original_problem, params);
+    const lp_problem_t *working_problem = &preprocessed_problem;
 
+    cupdlpx_presolve_info_t *presolve_info = NULL;
     if (params->presolve)
     {
-        presolve_info = pslp_presolve(original_problem, params);
+        presolve_info = pslp_presolve(&preprocessed_problem, params);
         if (presolve_info->problem_solved_during_presolve)
         {
-            cupdlpx_result_t *result = create_result_from_presolve(presolve_info, original_problem);
+            cupdlpx_result_t *result = create_result_from_presolve(presolve_info, &preprocessed_problem);
             cupdlpx_presolve_info_free(presolve_info);
+            restore_original_objective_sense(result, original_problem->objective_sense);
             pdhg_final_log(result, params);
+            free_preprocessed_problem(&preprocessed_problem, original_problem);
             return result;
         }
         working_problem = presolve_info->reduced_problem;
     }
 
-    pdhg_solver_state_t *state = initialize_solver_state(working_problem, params);
+    pdhg_solver_state_t *state =
+        initialize_solver_state(working_problem, params, original_problem->objective_sense);
     display_iteration_stats(state, params->verbose);
 
     initialize_step_size_and_primal_weight(state, params);
@@ -244,17 +250,20 @@ cupdlpx_result_t *optimize(const pdhg_parameters_t *params, lp_problem_t *origin
         feasibility_polish(params, state);
     }
 
-    cupdlpx_result_t *result = create_result_from_state(state, original_problem);
+    cupdlpx_result_t *result = create_result_from_state(state, &preprocessed_problem);
 
     if (params->presolve && presolve_info)
     {
-        pslp_postsolve(presolve_info, result, original_problem);
+        pslp_postsolve(presolve_info, result, &preprocessed_problem);
         cupdlpx_presolve_info_free(presolve_info);
     }
 
-    pdhg_final_log(result, params);
     pdhg_solver_state_free(state);
     CUDA_CHECK(cudaGetLastError());
+
+    restore_original_objective_sense(result, original_problem->objective_sense);
+    pdhg_final_log(result, params);
+    free_preprocessed_problem(&preprocessed_problem, original_problem);
     return result;
 }
 
@@ -314,7 +323,8 @@ __global__ void compute_and_rescale_reduced_cost_kernel(double *__restrict__ red
 }
 
 static pdhg_solver_state_t *initialize_solver_state(const lp_problem_t *working_problem,
-                                                    const pdhg_parameters_t *params)
+                                                    const pdhg_parameters_t *params,
+                                                    objective_sense_t original_objective_sense)
 {
     pdhg_solver_state_t *state = (pdhg_solver_state_t *)safe_calloc(1, sizeof(pdhg_solver_state_t));
 
@@ -327,7 +337,7 @@ static pdhg_solver_state_t *initialize_solver_state(const lp_problem_t *working_
     state->num_variables = n_vars;
     state->num_constraints = n_cons;
     state->objective_constant = working_problem->objective_constant;
-    state->objective_sign = (working_problem->objective_sense == OBJECTIVE_SENSE_MAXIMIZE) ? -1.0 : 1.0;
+    state->original_objective_sign = (original_objective_sense == OBJECTIVE_SENSE_MAXIMIZE) ? -1.0 : 1.0;
 
     state->constraint_matrix = (cu_sparse_matrix_csr_t *)safe_malloc(sizeof(cu_sparse_matrix_csr_t));
     state->constraint_matrix_t = (cu_sparse_matrix_csr_t *)safe_malloc(sizeof(cu_sparse_matrix_csr_t));
@@ -1261,8 +1271,8 @@ static cupdlpx_result_t *create_result_from_state(pdhg_solver_state_t *state, co
     results->cumulative_time_sec = state->cumulative_time_sec;
     results->relative_primal_residual = state->relative_primal_residual;
     results->relative_dual_residual = state->relative_dual_residual;
-    results->primal_objective_value = state->objective_sign * state->primal_objective_value;
-    results->dual_objective_value = state->objective_sign * state->dual_objective_value;
+    results->primal_objective_value = state->primal_objective_value;
+    results->dual_objective_value = state->dual_objective_value;
     results->objective_gap = state->objective_gap;
     results->relative_objective_gap = state->relative_objective_gap;
     results->max_primal_ray_infeasibility = state->max_primal_ray_infeasibility;