Add QCMATRIX: parsing and quadratic-constraint model

cpp/libmps_parser/include/mps_parser/mps_data_model.hpp

@@ -262,6 +262,40 @@ class mps_data_model_t {
                                       const i_t* Q_offsets,
                                       i_t size_offsets);
 
+  /**
+   * @brief CSR of Q for one quadratic constraint (MPS QCMATRIX).
+   *
+   * @c constraint_row_index is the row index in the linear constraint matrix A (0-based),
+   * matching the order of non-objective rows in the ROWS section.
+   */
+  struct quadratic_constraint_matrix_t {
+    i_t constraint_row_index{};
+    std::vector<f_t> values;
+    std::vector<i_t> indices;
+    std::vector<i_t> offsets;
+  };
+
+  /**
+   * @brief Append one quadratic constraint matrix (QCMATRIX) in CSR format.
+   *
+   * @param constraint_row_index Row index in A (0-based), matching non-objective ROWS order.
+   * @param[in] Qc_values Values of the CSR representation; copied into the model.
+   * @param size_values Size of the Qc_values array.
+   * @param[in] Qc_indices Indices of the CSR representation; copied into the model.
+   * @param size_indices Size of the Qc_indices array.
+   * @param[in] Qc_offsets Offsets of the CSR representation; copied into the model.
+   * @param size_offsets Size of the Qc_offsets array.
+   */
+  void append_quadratic_constraint_matrix(i_t constraint_row_index,
+                                          const f_t* Qc_values,
+                                          i_t size_values,
+                                          const i_t* Qc_indices,
+                                          i_t size_indices,
+                                          const i_t* Qc_offsets,
+                                          i_t size_offsets);
+
+  const std::vector<quadratic_constraint_matrix_t>& get_quadratic_constraint_matrices() const;
+
   i_t get_n_variables() const;
   i_t get_n_constraints() const;
   i_t get_nnz() const;
@@ -306,6 +340,8 @@ class mps_data_model_t {
 
   bool has_quadratic_objective() const noexcept;
 
+  bool has_quadratic_constraints() const noexcept;
+
   /** whether to maximize or minimize the objective function */
   bool maximize_;
   /**
@@ -361,6 +397,9 @@ class mps_data_model_t {
   std::vector<i_t> Q_objective_indices_;
   std::vector<i_t> Q_objective_offsets_;
 
+  /** One CSR matrix per QCMATRIX block, in order of appearance in the file */
+  std::vector<quadratic_constraint_matrix_t> quadratic_constraint_matrices_;
+
 };  // class mps_data_model_t
 
 }  // namespace cuopt::mps_parser

cpp/libmps_parser/include/mps_parser/parser.hpp

@@ -23,6 +23,8 @@ namespace cuopt::mps_parser {
  * QPS files (for quadratic programming). QPS files are MPS files with additional
  * sections:
  * - QUADOBJ: Defines quadratic terms in the objective function
+ * - QMATRIX: Full symmetric quadratic objective matrix (alternative to QUADOBJ)
+ * - QCMATRIX: Symmetric quadratic terms for a named constraint row (QCQP)
  *
  * Note: Compressed MPS files .mps.gz, .mps.bz2 can only be read if the compression
  * libraries zlib or libbzip2 are installed, respectively.

cpp/libmps_parser/src/mps_data_model.cpp

@@ -9,6 +9,7 @@
 #include <utilities/error.hpp>
 
 #include <algorithm>
+#include <utility>
 
 namespace cuopt::mps_parser {
 
@@ -219,6 +220,54 @@ void mps_data_model_t<i_t, f_t>::set_quadratic_objective_matrix(const f_t* Q_val
   std::copy(Q_offsets, Q_offsets + size_offsets, Q_objective_offsets_.data());
 }
 
+template <typename i_t, typename f_t>
+void mps_data_model_t<i_t, f_t>::append_quadratic_constraint_matrix(i_t constraint_row_index,
+                                                                    const f_t* Qc_values,
+                                                                    i_t size_values,
+                                                                    const i_t* Qc_indices,
+                                                                    i_t size_indices,
+                                                                    const i_t* Qc_offsets,
+                                                                    i_t size_offsets)
+{
+  mps_parser_expects(
+    constraint_row_index >= 0, error_type_t::ValidationError, "constraint_row_index must be non-negative");
+
+  if (size_values != 0) {
+    mps_parser_expects(
+      Qc_values != nullptr, error_type_t::ValidationError, "Qc_values cannot be null");
+  }
+  if (size_indices != 0) {
+    mps_parser_expects(
+      Qc_indices != nullptr, error_type_t::ValidationError, "Qc_indices cannot be null");
+  }
+  mps_parser_expects(
+    Qc_offsets != nullptr, error_type_t::ValidationError, "Qc_offsets cannot be null");
+  mps_parser_expects(
+    size_offsets > 0, error_type_t::ValidationError, "size_offsets cannot be empty");
+
+  quadratic_constraint_matrix_t qcm;
+  qcm.constraint_row_index = constraint_row_index;
+  qcm.values.resize(size_values);
+  if (size_values > 0) {
+    std::copy(Qc_values, Qc_values + size_values, qcm.values.data());
+  }
+  qcm.indices.resize(size_indices);
+  if (size_indices > 0) {
+    std::copy(Qc_indices, Qc_indices + size_indices, qcm.indices.data());
+  }
+  qcm.offsets.resize(size_offsets);
+  std::copy(Qc_offsets, Qc_offsets + size_offsets, qcm.offsets.data());
+
+  quadratic_constraint_matrices_.push_back(std::move(qcm));
+}
+
+template <typename i_t, typename f_t>
+auto mps_data_model_t<i_t, f_t>::get_quadratic_constraint_matrices() const
+  -> const std::vector<quadratic_constraint_matrix_t>&
+{
+  return quadratic_constraint_matrices_;
+}
+
 template <typename i_t, typename f_t>
 const std::vector<f_t>& mps_data_model_t<i_t, f_t>::get_constraint_matrix_values() const
 {
@@ -460,6 +509,12 @@ bool mps_data_model_t<i_t, f_t>::has_quadratic_objective() const noexcept
   return !Q_objective_values_.empty();
 }
 
+template <typename i_t, typename f_t>
+bool mps_data_model_t<i_t, f_t>::has_quadratic_constraints() const noexcept
+{
+  return !quadratic_constraint_matrices_.empty();
+}
+
 // NOTE: Explicitly instantiate all types here in order to avoid linker error
 template class mps_data_model_t<int, float>;