Remove wrong exception of unsupported QCQP (#1493)

We were wrongly throwing an exception when the rotated cones and quadratic objectives were present. 

## Issue

Authors:
  - Rajesh Gandham (https://github.com/rg20)

Approvers:
  - Yuwen Chen (https://github.com/yuwenchen95)
  - Miles Lubin (https://github.com/mlubin)

URL: #1493

Author: rg20

cpp/src/barrier/cusparse_view.cu

@@ -114,13 +114,14 @@ void my_cusparsespmv_preprocess(cusparseHandle_t handle,
 }
 #endif
 
-static cusparseSpMVAlg_t get_spmv_alg(int num_rows)
+static cusparseSpMVAlg_t get_spmv_alg([[maybe_unused]] int num_rows)
 {
-  // The older version of ALG2 has a bug with single row matrices
-  if (num_rows == 1 &&
-      (CUSPARSE_VER_MAJOR * 1000 + CUSPARSE_VER_MINOR * 100 + CUSPARSE_VER_PATCH < 12603)) {
-    return CUSPARSE_SPMV_CSR_ALG1;
-  }
+  // ALG2 has a bug in cuSPARSE < 13.0 where beta=1 accumulate mode ignores existing y values.
+  // ALG1 uses a deterministic row-split algorithm, while ALG2 uses a merge-based
+  // algorithm that may be faster but can use atomics. ALG1 is safe for reproducibility.
+  constexpr int cusparse_version =
+    CUSPARSE_VER_MAJOR * 1000 + CUSPARSE_VER_MINOR * 100 + CUSPARSE_VER_PATCH;
+  if (cusparse_version < 13000) { return CUSPARSE_SPMV_CSR_ALG1; }
   return CUSPARSE_SPMV_CSR_ALG2;
 }
 

cpp/src/barrier/translate_soc.hpp

@@ -871,11 +871,6 @@ void convert_quadratic_constraints_to_second_order_cones(
 
   // Convert rotated SOC cones to standard SOC cones.
   if (!rotated_cones.empty()) {
-    cuopt_expects(user_problem.Q_values.empty(),
-                  error_type_t::ValidationError,
-                  "Rotated SOC conversion is currently not supported when the objective has "
-                  "quadratic terms");
-
     const f_t inf        = std::numeric_limits<f_t>::infinity();
     const f_t inv_sqrt_2 = f_t(1) / std::sqrt(f_t(2));
     const f_t half       = f_t(0.5);

cpp/tests/socp/general_quadratic_test.cu

@@ -12,6 +12,8 @@
 #include <cuopt/error.hpp>
 #include <cuopt/mathematical_optimization/io/parser.hpp>
 #include <cuopt/mathematical_optimization/optimization_problem_interface.hpp>
+#include <cuopt/mathematical_optimization/pdlp/solver_settings.hpp>
+#include <cuopt/mathematical_optimization/solve.hpp>
 #include <dual_simplex/solve.hpp>
 #include <dual_simplex/user_problem.hpp>
 #include <linear_algebra/sparse_matrix.hpp>
@@ -907,4 +909,40 @@ TEST(general_quadratic, rotated_soc_heads_free_rejected)
     cuopt::logic_error);
 }
 
+// Test QCQP with rotated SOC constraint and quadratic objective using high-level API.
+// This is the recommended way to solve QCQP problems.
+// minimize (1/2)*x^2 - x   (quadratic objective)
+// subject to x^2 - 2*t*u <= 0  (rotated SOC)
+//            t = 1, u = 0.5
+// Optimal: x = 1, objective = -0.5
+TEST(general_quadratic, qcqp_rotated_soc)
+{
+  raft::handle_t handle{};
+
+  auto problem = io::read_lp_from_string<i_t, f_t>(R"LP(
+Minimize
+  - x + [ x ^2 ] / 2
+Subject To
+  t_eq: t = 1
+  u_eq: u = 0.5
+  rsoc: [ x ^2 - 2 t * u ] <= 0
+Bounds
+  x free
+  t >= 0
+  u >= 0
+End
+)LP");
+
+  ASSERT_TRUE(problem.has_quadratic_objective());
+  ASSERT_TRUE(problem.has_quadratic_constraints());
+  ASSERT_EQ(problem.get_quadratic_constraints().size(), 1u);
+
+  pdlp_solver_settings_t<i_t, f_t> settings;
+  auto solution = solve_lp(&handle, problem, settings);
+
+  EXPECT_EQ(solution.get_termination_status(), pdlp_termination_status_t::Optimal);
+  // Optimal: x=1, objective = (1/2)*1 - 1 = -0.5
+  EXPECT_NEAR(solution.get_objective_value(), -0.5, 1e-4);
+}
+
 }  // namespace cuopt::mathematical_optimization::barrier::test