Examples

This page contains example implementations of devices and other components of the software stack that use QDMI. All examples distributed with QDMI are contained in the examples/ directory in the repository.

Implementing a Device

Below you find mock implementations of a QDMI device in C++.

Note

Keep in mind, that even though the interface is defined in C, the device can be implemented in C++ or any other language that supports the C ABI.

Basic String Properties

Every device has to provide a name, its version, and the implemented QDMI library version through the query interface. The corresponding properties are

• QDMI_DEVICE_PROPERTY_NAME
• QDMI_DEVICE_PROPERTY_VERSION
• QDMI_DEVICE_PROPERTY_LIBRARYVERSION

All of those properties are of type char* (string). Since they are properties of the device, they are returned by the QDMI_device_session_query_device_property function. Below you find the respective implementation in C++.

int CXX_QDMI_device_session_query_device_property(
    CXX_QDMI_Device_Session session, const QDMI_Device_Property prop,
    const size_t size, void *value, size_t *size_ret) {
  if (session == nullptr || (value != nullptr && size == 0) ||
      (prop >= QDMI_DEVICE_PROPERTY_MAX &&
       prop < QDMI_DEVICE_PROPERTY_CUSTOM1)) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (session->status != CXX_QDMI_DEVICE_SESSION_STATUS::INITIALIZED) {
    return QDMI_ERROR_BADSTATE;
  }
  ADD_STRING_PROPERTY(QDMI_DEVICE_PROPERTY_NAME, "C++ Device with 5 qubits",
                      prop, size, value, size_ret)
  // NOLINTNEXTLINE(misc-include-cleaner)
  ADD_STRING_PROPERTY(QDMI_DEVICE_PROPERTY_VERSION, CXX_QDMI_DEVICE_VERSION,
                      prop, size, value, size_ret)
  // NOLINTNEXTLINE(misc-include-cleaner)
  ADD_STRING_PROPERTY(QDMI_DEVICE_PROPERTY_LIBRARYVERSION, QDMI_VERSION, prop,
                      size, value, size_ret)
  return QDMI_ERROR_NOTSUPPORTED;
} 

Both implementations use an auxiliary macro to add the string properties to the device. For an explanation of the macro, see the next section Auxiliary Macros.

Auxiliary Macros

The following macro is used to add string properties to the device. The macro is used, e.g., in the implementation of the QDMI_device_session_query_device_property function.

#define ADD_STRING_PROPERTY(prop_name, prop_value, prop, size, value,          \
                            size_ret)                                          \
  {                                                                            \
    if ((prop) == (prop_name)) {                                               \
      if ((value) != nullptr) {                                                \
        if ((size) < strlen(prop_value) + 1) {                                 \
          return QDMI_ERROR_INVALIDARGUMENT;                                   \
        }                                                                      \
        strncpy(static_cast<char *>(value), prop_value, size);                 \
        static_cast<char *>(value)[size - 1] = '\0';                           \
      }                                                                        \
      if ((size_ret) != nullptr) {                                             \
        *size_ret = strlen(prop_value) + 1;                                    \
      }                                                                        \
      return QDMI_SUCCESS;                                                     \
    }                                                                          \
  } 

A similar macro is defined for other (fixed length) data types, for example, int, double.

#define ADD_SINGLE_VALUE_PROPERTY(prop_name, prop_type, prop_value, prop,      \
                                  size, value, size_ret)                       \
  {                                                                            \
    if ((prop) == (prop_name)) {                                               \
      if ((value) != nullptr) {                                                \
        if ((size) < sizeof(prop_type)) {                                      \
          return QDMI_ERROR_INVALIDARGUMENT;                                   \
        }                                                                      \
        *static_cast<prop_type *>(value) = prop_value;                         \
      }                                                                        \
      if ((size_ret) != nullptr) {                                             \
        *size_ret = sizeof(prop_type);                                         \
      }                                                                        \
      return QDMI_SUCCESS;                                                     \
    }                                                                          \
  } 

Another macro is defined for list properties of the data types above.

#define ADD_LIST_PROPERTY(prop_name, prop_type, prop_values, prop, size,       \
                          value, size_ret)                                     \
  {                                                                            \
    if ((prop) == (prop_name)) {                                               \
      if ((value) != nullptr) {                                                \
        if ((size) < (prop_values).size() * sizeof(prop_type)) {               \
          return QDMI_ERROR_INVALIDARGUMENT;                                   \
        }                                                                      \
        memcpy(static_cast<void *>(value),                                     \
               static_cast<const void *>((prop_values).data()),                \
               (prop_values).size() * sizeof(prop_type));                      \
      }                                                                        \
      if ((size_ret) != nullptr) {                                             \
        *size_ret = (prop_values).size() * sizeof(prop_type);                  \
      }                                                                        \
      return QDMI_SUCCESS;                                                     \
    }                                                                          \
  } 

The usage of the two latter macros is demonstrated in the following sections.

Integer or Enumeration Properties

The following two examples demonstrate how to return integer or enumeration properties of the device.

int CXX_QDMI_device_session_query_device_property(
    CXX_QDMI_Device_Session session, const QDMI_Device_Property prop,
    const size_t size, void *value, size_t *size_ret) {
  ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_STATUS, QDMI_Device_Status,
                            CXX_QDMI_get_device_status(), prop, size, value,
                            size_ret)
  ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_QUBITSNUM, size_t, 5, prop,
                            size, value, size_ret)
  return QDMI_ERROR_NOTSUPPORTED;
} 

List Properties

Some properties are returned as a list of various data types. The following example shows how to return the coupling map of the device as a list of QDMI_Site pairs. The pairs are flattened into a single list of QDMI_Site's.

constexpr std::array<const CXX_QDMI_Site_impl_d *, 20>
    DEVICE_COUPLING_MAP = {
      CXX_DEVICE_SITES[0], CXX_DEVICE_SITES[1],
      CXX_DEVICE_SITES[1], CXX_DEVICE_SITES[0],
      CXX_DEVICE_SITES[1], CXX_DEVICE_SITES[2],
      CXX_DEVICE_SITES[2], CXX_DEVICE_SITES[1],
      CXX_DEVICE_SITES[2], CXX_DEVICE_SITES[3],
      CXX_DEVICE_SITES[3], CXX_DEVICE_SITES[2],
      CXX_DEVICE_SITES[3], CXX_DEVICE_SITES[4],
      CXX_DEVICE_SITES[4], CXX_DEVICE_SITES[3],
      CXX_DEVICE_SITES[4], CXX_DEVICE_SITES[0],
      CXX_DEVICE_SITES[0], CXX_DEVICE_SITES[4]};
int CXX_QDMI_device_session_query_device_property(
    CXX_QDMI_Device_Session session, const QDMI_Device_Property prop,
    const size_t size, void *value, size_t *size_ret) {
  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_SITES, CXX_QDMI_Site, CXX_DEVICE_SITES,
                    prop, size, value, size_ret)
  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_OPERATIONS, CXX_QDMI_Operation,
                    CXX_DEVICE_OPERATIONS, prop, size, value, size_ret)
  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_COUPLINGMAP, CXX_QDMI_Site,
                    DEVICE_COUPLING_MAP, prop, size, value, size_ret)
 
  // The example device never requires calibration.
  ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_NEEDSCALIBRATION, size_t, 0,
                            prop, size, value, size_ret)
 
  ADD_SINGLE_VALUE_PROPERTY(
      QDMI_DEVICE_PROPERTY_PULSESUPPORT, QDMI_Device_Pulse_Support_Level,
      QDMI_DEVICE_PULSE_SUPPORT_LEVEL_NONE, prop, size, value, size_ret)
 
  ADD_STRING_PROPERTY(QDMI_DEVICE_PROPERTY_LENGTHUNIT, "um", prop, size, value,
                      size_ret)
  ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_LENGTHSCALEFACTOR, double, 1.0,
                            prop, size, value, size_ret)
 
  ADD_STRING_PROPERTY(QDMI_DEVICE_PROPERTY_DURATIONUNIT, "us", prop, size,
                      value, size_ret)
  ADD_SINGLE_VALUE_PROPERTY(QDMI_DEVICE_PROPERTY_DURATIONSCALEFACTOR, double,
                            0.001, prop, size, value, size_ret)
 
  ADD_LIST_PROPERTY(QDMI_DEVICE_PROPERTY_SUPPORTEDPROGRAMFORMATS,
                    QDMI_Program_Format, SUPPORTED_PROGRAM_FORMATS, prop, size,
                    value, size_ret)
  return QDMI_ERROR_NOTSUPPORTED;
} 

Program-Format Execution Features

The QDMI_device_session_query_program_features function reports atomic execution features for one exact program-format descriptor. The following example device reports two unrestricted OpenQASM features and forward branching with a maximum nesting depth of one. Its QIR Base descriptors return a successful empty list because they support no optional feature beyond the QIR Base baseline.

constexpr std::array<QDMI_Program_Feature, 3> QASM2_FEATURES{
    {QDMI_PROGRAM_FEATURE_UNCONSTRAINED(
         QDMI_PROGRAM_FEATURE_MID_CIRCUIT_MEASUREMENT, 0),
     QDMI_PROGRAM_FEATURE_UNCONSTRAINED(
         QDMI_PROGRAM_FEATURE_MEASURED_QUBIT_REUSE, 0),
     QDMI_Program_Feature{
         .id = QDMI_PROGRAM_FEATURE_FORWARD_BRANCHING,
         .value = 0,
         .constraint_id =
             QDMI_PROGRAM_CONSTRAINT_MAX_CONTROL_FLOW_NESTING_DEPTH,
         .constraint_value = 1}}};
int CXX_QDMI_device_session_query_program_features(
    CXX_QDMI_Device_Session session, const QDMI_Program_Format *format,
    const size_t size, QDMI_Program_Feature *value, size_t *size_ret) {
  if (session == nullptr || format == nullptr || !Valid_format(*format)) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (session->status != CXX_QDMI_DEVICE_SESSION_STATUS::INITIALIZED) {
    return QDMI_ERROR_BADSTATE;
  }
  if (!Supported_format(*format)) {
    return QDMI_ERROR_NOTSUPPORTED;
  }
 
  const auto copy = [&](const auto &features) {
    const size_t required = sizeof(features);
    if (size_ret != nullptr) {
      *size_ret = required;
    }
    if (value == nullptr) {
      return QDMI_SUCCESS;
    }
    if (size < required) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    std::ranges::copy(features, value);
    return QDMI_SUCCESS;
  };
  if (QDMI_program_format_equal(format, &QASM2_FORMAT) != 0) {
    return copy(QASM2_FEATURES);
  }
  if (size_ret != nullptr) {
    *size_ret = 0U;
  }
  return QDMI_SUCCESS;
} 

Each QDMI_Program_Feature record carries a feature ID, a feature-specific value, and an optional typed constraint. Records for one feature and value form one conjunctive group. An empty constraint ID means unrestricted support. Use QDMI_PROGRAM_FEATURE_UNCONSTRAINED to initialize such a record. Unknown or malformed constraints make the group unusable. The returned list is complete. Returning QDMI_ERROR_NOTSUPPORTED keeps feature metadata unknown. Requirements guaranteed by a standard descriptor remain implicit.

Complex Properties

The properties that are returned by QDMI_device_session_query_operation_property may depend on the actual site. The available QDMI_Operation's and QDMI_Site's, first, need to be retrieved through QDMI_device_session_query_device_property. With the handles for a QDMI_Operation and QDMI_Site, corresponding properties can be queried. The following example demonstrates how different properties of operations, for example, varying fidelities of two-qubit gates can be returned.

struct CXX_QDMI_Pair_hash {
  template <class T1, class T2>
  size_t operator()(const std::pair<T1, T2> &p) const {
    auto hash1 = std::hash<T1>{}(p.first);
    auto hash2 = std::hash<T2>{}(p.second);
    return hash1 ^ hash2;
  }
};
 
const std::unordered_map<
    const CXX_QDMI_Operation_impl_d *,
    std::unordered_map<
        std::pair<const CXX_QDMI_Site_impl_d *, const CXX_QDMI_Site_impl_d *>,
        double, CXX_QDMI_Pair_hash>>
    OPERATION_FIDELITIES = {
        {CXX_DEVICE_OPERATIONS[3],
         {{{CXX_DEVICE_SITES[0], CXX_DEVICE_SITES[1]}, 0.99},
          {{CXX_DEVICE_SITES[1], CXX_DEVICE_SITES[0]}, 0.99},
          {{CXX_DEVICE_SITES[1], CXX_DEVICE_SITES[2]}, 0.98},
          {{CXX_DEVICE_SITES[2], CXX_DEVICE_SITES[1]}, 0.98},
          {{CXX_DEVICE_SITES[2], CXX_DEVICE_SITES[3]}, 0.97},
          {{CXX_DEVICE_SITES[3], CXX_DEVICE_SITES[2]}, 0.97},
          {{CXX_DEVICE_SITES[3], CXX_DEVICE_SITES[4]}, 0.96},
          {{CXX_DEVICE_SITES[4], CXX_DEVICE_SITES[3]}, 0.96},
          {{CXX_DEVICE_SITES[4], CXX_DEVICE_SITES[0]}, 0.95},
          {{CXX_DEVICE_SITES[0], CXX_DEVICE_SITES[4]}, 0.95}}},
        // No need to specify single-qubit fidelities here
};
int CXX_QDMI_device_session_query_operation_property(
    CXX_QDMI_Device_Session session, CXX_QDMI_Operation operation,
    const size_t num_sites, const CXX_QDMI_Site *sites, const size_t num_params,
    const double *params, QDMI_Operation_Property prop, const size_t size,
    void *value, size_t *size_ret) {
  if (session == nullptr || operation == nullptr ||
      (sites != nullptr && num_sites == 0) ||
      (params != nullptr && num_params == 0) ||
      (value != nullptr && size == 0) ||
      (prop >= QDMI_OPERATION_PROPERTY_MAX &&
       prop < QDMI_OPERATION_PROPERTY_CUSTOM1)) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  // General properties
  ADD_STRING_PROPERTY(QDMI_OPERATION_PROPERTY_NAME,
                      OPERATION_PROPERTIES.at(operation).first.c_str(), prop,
                      size, value, size_ret)
  ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_ISZONED, bool, false, prop,
                            size, value, size_ret)
  if (operation == CXX_DEVICE_OPERATIONS[3]) {
    if (sites != nullptr && num_sites != 2) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_PARAMETERSNUM, size_t, 0,
                              prop, size, value, size_ret)
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_DURATION, uint64_t,
                              OPERATION_PROPERTIES.at(operation).second, prop,
                              size, value, size_ret)
    ADD_LIST_PROPERTY(QDMI_OPERATION_PROPERTY_SITES, CXX_QDMI_Site,
                      DEVICE_COUPLING_MAP, prop, size, value, size_ret)
    if (sites == nullptr) {
      ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_QUBITSNUM, size_t, 2,
                                prop, size, value, size_ret)
      return QDMI_ERROR_NOTSUPPORTED;
    }
 
    const std::pair site_pair = {sites[0], sites[1]};
    if (site_pair.first == site_pair.second) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    const auto it = OPERATION_FIDELITIES.find(operation);
    if (it == OPERATION_FIDELITIES.end()) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    const auto fit = it->second.find(site_pair);
    if (fit == it->second.end()) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_FIDELITY, double,
                              fit->second, prop, size, value, size_ret)
  } else if (operation == CXX_DEVICE_OPERATIONS[0] ||
             operation == CXX_DEVICE_OPERATIONS[1] ||
             operation == CXX_DEVICE_OPERATIONS[2]) {
    if ((sites != nullptr && num_sites != 1) ||
        (params != nullptr && num_params != 1)) {
      return QDMI_ERROR_INVALIDARGUMENT;
    }
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_DURATION, double, 0.01,
                              prop, size, value, size_ret)
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_QUBITSNUM, size_t, 1,
                              prop, size, value, size_ret)
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_PARAMETERSNUM, size_t, 1,
                              prop, size, value, size_ret)
    ADD_SINGLE_VALUE_PROPERTY(QDMI_OPERATION_PROPERTY_FIDELITY, double, 0.999,
                              prop, size, value, size_ret)
    ADD_LIST_PROPERTY(QDMI_OPERATION_PROPERTY_SITES, CXX_QDMI_Site,
                      CXX_DEVICE_SITES, prop, size, value, size_ret)
  }
  return QDMI_ERROR_NOTSUPPORTED;
} 

Submitting a Job

One crucial part of QDMI is that it allows submitting a job to the device for execution. The following example provides a mock implementation of the necessary functions to submit a job. The first example shows a mock implementation of QDMI_device_session_create_device_job.

int CXX_QDMI_device_session_create_device_job(CXX_QDMI_Device_Session session,
                                              CXX_QDMI_Device_Job *job) {
  if (session == nullptr || job == nullptr) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (session->status != CXX_QDMI_DEVICE_SESSION_STATUS::INITIALIZED) {
    return QDMI_ERROR_BADSTATE;
  }
 
  *job = new CXX_QDMI_Device_Job_impl_d;
  (*job)->session = session;
  // set job id to random number for demonstration purposes
  (*job)->id = CXX_QDMI_generate_job_id();
  (*job)->status = QDMI_JOB_STATUS_CREATED;
  return QDMI_SUCCESS;
} 

The function QDMI_device_job_set_parameter allows setting different parameters for the job, for example, the number of shots (QDMI_JOB_PARAMETER_SHOTSNUM).

int CXX_QDMI_device_job_set_parameter(CXX_QDMI_Device_Job job,
                                      const QDMI_Device_Job_Parameter param,
                                      const size_t size, const void *value) {
  if (job == nullptr || (value != nullptr && size == 0) ||
      (param >= QDMI_DEVICE_JOB_PARAMETER_MAX &&
       param < QDMI_DEVICE_JOB_PARAMETER_CUSTOM1)) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (job->status != QDMI_JOB_STATUS_CREATED) {
    return QDMI_ERROR_BADSTATE;
  }
  switch (param) {
  case QDMI_DEVICE_JOB_PARAMETER_PROGRAMFORMAT:
    if (value != nullptr) {
      if (size != sizeof(QDMI_Program_Format)) {
        return QDMI_ERROR_INVALIDARGUMENT;
      }
      const auto format = *static_cast<const QDMI_Program_Format *>(value);
      if (!Valid_format(format)) {
        return QDMI_ERROR_INVALIDARGUMENT;
      }
      if (!Supported_format(format)) {
        return QDMI_ERROR_NOTSUPPORTED;
      }
      if (QDMI_program_format_equal(&job->format, &format) == 0) {
        job->programs.clear();
      }
      job->format = format;
    }
    return QDMI_SUCCESS;
  case QDMI_DEVICE_JOB_PARAMETER_SHOTSNUM:
    if (value != nullptr) {
      job->num_shots = *static_cast<const size_t *>(value);
    }
    return QDMI_SUCCESS;
  default:
    return QDMI_ERROR_NOTSUPPORTED;
  }
} 

The function QDMI_device_job_set_programs submits an ordered list of programs with one exact format and one job-wide shot count. The function copies the complete list before it returns. The job has one lifecycle, and result index i corresponds to input program i. A device can execute the programs in any order. The job is done only after every program succeeds. One program failure fails the job, and cancellation applies to the complete job. QDMI does not expose partial results. Use QDMI_device_job_get_results with the input index to retrieve one program's result.

int CXX_QDMI_device_job_set_programs(CXX_QDMI_Device_Job job,
                                     const QDMI_Program_Format *format,
                                     const size_t count, const size_t *sizes,
                                     const void *const *programs) {
  if (job == nullptr || format == nullptr || count == 0 ||
      !Valid_format(*format)) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (job->status != QDMI_JOB_STATUS_CREATED) {
    return QDMI_ERROR_BADSTATE;
  }
  if (!Supported_format(*format)) {
    return QDMI_ERROR_NOTSUPPORTED;
  }
  if (programs == nullptr) {
    return QDMI_SUCCESS;
  }
  if (sizes == nullptr) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
 
  std::vector<std::vector<char>> new_programs;
  try {
    new_programs.reserve(count);
    for (size_t i = 0; i < count; ++i) {
      if (!Valid_program(*format, sizes[i], programs[i])) {
        return QDMI_ERROR_INVALIDARGUMENT;
      }
      const auto *bytes = static_cast<const char *>(programs[i]);
      new_programs.emplace_back(bytes, bytes + sizes[i]);
    }
  } catch (const std::bad_alloc &) {
    return QDMI_ERROR_OUTOFMEM;
  } catch (const std::length_error &) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
 
  job->format = *format;
  job->programs = std::move(new_programs);
  return QDMI_SUCCESS;
} 

After the job is set up, it can be submitted to the device. The following example shows a mock implementation of QDMI_device_job_submit.

int CXX_QDMI_device_job_submit(CXX_QDMI_Device_Job job) {
  if (job == nullptr || job->status != QDMI_JOB_STATUS_CREATED) {
    return QDMI_ERROR_INVALIDARGUMENT;
  }
  if (job->programs.empty() || !Valid_format(job->format)) {
    return QDMI_ERROR_BADSTATE;
  }
 
  CXX_QDMI_set_device_status(QDMI_DEVICE_STATUS_BUSY);
  job->status = QDMI_JOB_STATUS_SUBMITTED;
  // here, the actual submission of the problem to the device would happen
  // ...
  // set job status to running for demonstration purposes
  job->status = QDMI_JOB_STATUS_RUNNING;
  // generate random result data
  size_t num_qubits = 0;
  CXX_QDMI_device_session_query_device_property(
      job->session, QDMI_DEVICE_PROPERTY_QUBITSNUM, sizeof(size_t), &num_qubits,
      nullptr);
  constexpr std::array<std::string_view, 4> shot_outputs{FLAT_SHOT_OUTPUT, "10",
                                                         "11", "00"};
  job->results.clear();
  job->results.resize(job->programs.size());
  for (size_t program_index = 0; program_index < job->results.size();
       ++program_index) {
    auto &result = job->results[program_index];
    size_t output_index = 0;
    if (job->programs.size() > 1) {
      const auto &program = job->programs.at(program_index);
      const auto marker =
          program.at(program.size() -
                     (job->format.encoding == QDMI_PROGRAM_ENCODING_TEXT &&
                              program.size() > 1
                          ? 2
                          : 1));
      output_index = static_cast<unsigned char>(marker) % shot_outputs.size();
    }
    result.shots.assign(job->num_shots,
                        std::string{shot_outputs.at(output_index)});
    // Generate random complex numbers and calculate the norm
    result.state_vec.reserve(1U << num_qubits);
    double norm = 0.0;
    for (size_t i = 0; i < 1U << num_qubits; ++i) {
      const auto &c = result.state_vec.emplace_back(CXX_QDMI_generate_real(),
                                                    CXX_QDMI_generate_real());
      norm += std::norm(c);
    }
    // Normalize the vector
    norm = std::sqrt(norm);
    for (auto &c : result.state_vec) {
      c /= norm;
    }
  }
  return QDMI_SUCCESS;
} 

For the full implementation of the example devices we refer to the respective source files in the QDMI repository, that is, cxx_device.cpp for the C++ implementation.