QkCircuit

QkCircuit *qk_circuit_new(uint32_t num_qubits, uint32_t num_clbits)

Construisez un nouveau circuit avec le nombre donné de qubits et de clbits.

Exemple

QkCircuit *empty = qk_circuit_new(100, 100);

Paramètres

• num_qubits - Le nombre de qubits que le circuit contient.
• num_clbits - Le nombre de clbits que le circuit contient.

Returns

Un pointeur sur le circuit créé.

void qk_circuit_add_quantum_register(QkCircuit *circuit, const QkQuantumRegister *reg)

Ajouter un registre quantique à un circuit quantique donné

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr = qk_quantum_register_new(1024, "my_little_register");
qk_circuit_add_quantum_register(qc, qr);
qk_quantum_register_free(qr);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit et si reg n'est pas un pointeur valide et non nul vers QkQuantumRegister.

Paramètres

• circuit - Un pointeur sur le circuit.
• reg - Un pointeur sur le registre quantique

size_t qk_circuit_num_quantum_registers(const QkCircuit *circuit)

Déterminez le nombre de registres quantiques présents dans le circuit.

Renvoie le nombre de registres quantiques qui ont été ajoutés au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr1 = qk_quantum_register_new(2, "qr1");
QkQuantumRegister *qr2 = qk_quantum_register_new(3, "qr2");
qk_circuit_add_quantum_register(qc, qr1);
qk_circuit_add_quantum_register(qc, qr2);

size_t num_qregs = qk_circuit_num_quantum_registers(qc);
printf("Number of quantum registers: %zu\n", num_qregs);  // Prints: 2

qk_quantum_register_free(qr1);
qk_quantum_register_free(qr2);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

Le nombre de registres quantiques dans le circuit.

const QkQuantumRegister *qk_circuit_get_quantum_register(const QkCircuit *circuit, size_t qreg_idx)

Renvoie le registre quantique correspondant à l'index spécifié.

Renvoie un pointeur emprunté vers le registre quantique situé à l'index spécifié. Le pointeur renvoyé reste valide tant que le circuit existe et n'est pas modifié. L'appelant ne doit pas libérer le pointeur renvoyé.

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr1 = qk_quantum_register_new(2, "qr1");
qk_circuit_add_quantum_register(qc, qr1);

const QkQuantumRegister *retrieved = qk_circuit_get_quantum_register(qc, 0);

qk_quantum_register_free(qr1);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit, ou si qreg_idx est hors limites (supérieur ou égal au nombre de registres quantiques du circuit).

Paramètres

• circuit - Un pointeur sur le circuit.
• qreg_idx – L'index du registre quantique à récupérer.

Returns

Un pointeur emprunté vers le registre quantique à l'index spécifié. Ne libérez pas ce pointeur.

void qk_circuit_add_classical_register(QkCircuit *circuit, const QkClassicalRegister *reg)

Ajouter un registre classique à un circuit quantique donné

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr = qk_classical_register_new(24, "my_big_register");
qk_circuit_add_classical_register(qc, cr);
qk_classical_register_free(cr);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit et si reg n'est pas un pointeur valide et non nul vers QkClassicalRegister.

Paramètres

• circuit - Un pointeur sur le circuit.
• reg - Un pointeur sur le registre classique

size_t qk_circuit_num_classical_registers(const QkCircuit *circuit)

Déterminez le nombre de registres classiques présents dans le circuit.

Renvoie le nombre de registres classiques qui ont été ajoutés au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr1 = qk_classical_register_new(2, "cr1");
QkClassicalRegister *cr2 = qk_classical_register_new(3, "cr2");
qk_circuit_add_classical_register(qc, cr1);
qk_circuit_add_classical_register(qc, cr2);

size_t num_cregs = qk_circuit_num_classical_registers(qc);
printf("Number of classical registers: %zu\n", num_cregs);  // Prints: 2

qk_classical_register_free(cr1);
qk_classical_register_free(cr2);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

Le nombre de registres classiques dans le circuit.

const QkClassicalRegister *qk_circuit_get_classical_register(const QkCircuit *circuit, size_t creg_idx)

Renvoie le registre classique à l'index spécifié.

Renvoie un pointeur emprunté vers le registre classique situé à l'index spécifié. Le pointeur renvoyé reste valide tant que le circuit existe et n'est pas modifié. L'appelant ne doit pas libérer le pointeur renvoyé.

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr1 = qk_classical_register_new(2, "cr1");
qk_circuit_add_classical_register(qc, cr1);

const QkClassicalRegister *retrieved = qk_circuit_get_classical_register(qc, 0);

qk_classical_register_free(cr1);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit, ou si creg_idx est hors limites (supérieur ou égal au nombre de registres classiques du circuit).

Paramètres

• circuit - Un pointeur sur le circuit.
• creg_idx – L'index du registre classique à récupérer.

Returns

Un pointeur emprunté vers le registre classique à l'index spécifié. Ne libérez pas ce pointeur.

QkCircuit *qk_circuit_copy(const QkCircuit *circuit)

Créer une copie d'un site QkCircuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 100);
QkCircuit *copy = qk_circuit_copy(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit à copier.

Returns

Un nouveau pointeur sur une copie de l'entrée circuit.

uint32_t qk_circuit_num_qubits(const QkCircuit *circuit)

Obtenir le nombre de qubits que contient le circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 100);
uint32_t num_qubits = qk_circuit_num_qubits(qc);  // num_qubits==100

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

Le nombre de qubits sur lesquels le circuit est défini.

uint32_t qk_circuit_num_clbits(const QkCircuit *circuit)

Obtenir le nombre de clbits que contient le circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 50);
uint32_t num_clbits = qk_circuit_num_clbits(qc);  // num_clbits==50

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

Le nombre de clbits sur lequel le circuit est défini.

size_t qk_circuit_num_param_symbols(const QkCircuit *circuit)

Calculez le nombre de symboles non liés dans QkParam les objets du circuit.

Exemple

QkCircuit *qc = qk_circuit_new(2, 0);
QkParam *x = qk_param_new_symbol("x");
QkParam *y = qk_param_new_symbol("y");

uint32_t q0[1] = {0};
const QkParam *rx_param[1] = {x};
const QkParam *ry_param[1] = {y};

qk_circuit_parameterized_gate(qc, QkGate_RX, q0, rx_param);
qk_circuit_parameterized_gate(qc, QkGate_RY, q0, ry_param);

// check the number of QkParam symbols
size_t num_symbols = qk_circuit_num_param_symbols(qc); // == 2

qk_param_free(x);
qk_param_free(y);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

Le nombre de symboles QkParam non liés dans le circuit.

QkParam *qk_circuit_global_phase(const QkCircuit *circuit)

Récupérez la phase globale du circuit.

Cette fonction renvoie une copie de la phase globale du circuit; cette valeur doit être libérée via :c:func:qk_param_free après utilisation.

Exemple

QkCircuit *qc = qk_circuit_new(100, 100);
QkParam *phase = qk_circuit_global_phase(qc);
qk_param_free(phase);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit.

Returns

La phase mondiale du circuit.

QkExitCode qk_circuit_set_global_phase(QkCircuit *circuit, const QkParam *phase)

Réglez la phase globale du circuit.

Cette fonction copie la nouvelle phase globale lors de sa définition; l'appelant conserve donc la propriété de cette QkParam phase, et la valeur de celle-ci doit être libérée via :c:func:qk_param_free après sa définition.

Exemple

QkCircuit *qc = qk_circuit_new(100, 100);
QkParam *new_global_phase = qk_param_from_double(1.23);
qk_circuit_set_global_phase(qc, new_global_phase);
qk_param_free(new_global_phase);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit et si phase n'est pas un pointeur valide et non nul vers un QkParam.

Paramètres

• circuit - Un pointeur sur le circuit.
• phase – Un pointeur vers la phase globale à définir.

Returns

QkExitCode_Success une fois la phase globale correctement définie. En cas d'échec, QkExitCode_ParameterNameConflict indique qu'un nouveau symbole de paramètre est en conflit de nom avec un symbole existant. QkExitCode_ParameterError décrit d'autres erreurs générales pouvant survenir lors de la recherche des symboles de paramètres.

void qk_circuit_free(QkCircuit *circuit)

Libérer le circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 100);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est ni null ni un pointeur valide vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit à libérer.

QkExitCode qk_circuit_gate(QkCircuit *circuit, QkGate gate, const uint32_t *qubits, const double *params)

Ajoutez une adresse QkGate au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);

Sécurité

Les types qubits et params sont censés être des pointeurs vers un tableau de uint32_t et double respectivement, dont la longueur correspond aux attentes de la porte standard. Si le tableau n'est pas suffisamment long, le comportement de cette fonction est indéfini car elle lira en dehors des limites du tableau. Il peut s'agir d'un pointeur nul s'il n'y a pas de qubits ou de paramètres pour une porte donnée. Vous pouvez consulter qk_gate_num_qubits et qk_gate_num_params pour déterminer le nombre de qubits et de paramètres requis pour une porte donnée.

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter la porte.
• gate - Le site StandardGate à ajouter au circuit.
• qubits - Le pointeur sur le tableau d'indices de qubits uint32_t sur lequel ajouter la porte. Il peut s'agir d'un pointeur nul s'il n'y a pas de qubits pour gate (par exemple QkGate_GlobalPhase).
• params - Pointeur vers le tableau de valeurs double à utiliser pour les paramètres de la porte. Il peut s'agir d'un pointeur nul s'il n'y a pas de paramètres pour gate (par exemple QkGate_H).

Returns

Un code de sortie.

QkExitCode qk_circuit_parameterized_gate(QkCircuit *circuit, QkGate gate, const uint32_t *qubits, const QkParam *const *params)

Ajouter un QkGate avec QkParam* paramètres au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 0);
QkParam *theta = qk_param_new_symbol("theta");
uint32_t qubit[1] = {0};
const QkParam* params[1] = {theta};
qk_circuit_parameterized_gate(qc, QkGate_RX, qubit, params); // add RX(theta) to the circuit

Sécurité

Les qubits``params types et doivent être respectivement un pointeur vers QkParam* un tableau de uint32_t et, dont la longueur correspond aux spécifications de la porte standard. Si le tableau n'est pas assez long, le comportement de cette fonction est indéfini, car elle tentera de lire des données en dehors des limites du tableau. Il peut s'agir d'un pointeur nul s'il n'y a ni qubits ni paramètres pour une porte donnée. Vous pouvez consulter qk_gate_num_qubits et qk_gate_num_params pour déterminer le nombre de qubits et de paramètres nécessaires pour une porte donnée.

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit, ou si l'un des éléments du params tableau n'est pas un pointeur valide et non nul vers un QkParam.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter la porte.
• porte – Celle QkGate à ajouter au circuit.
• qubits - Le pointeur sur le tableau d'indices de qubits uint32_t sur lequel ajouter la porte. Il peut s'agir d'un pointeur nul s'il n'y a pas de qubits pour gate (par exemple QkGate_GlobalPhase).
• params – Le pointeur vers le tableau de QkParam* paramètres à utiliser pour les paramètres de la porte. Il peut s'agir d'un pointeur nul s'il n'y a pas de paramètres ( gate par exemple QkGate_H).

Returns

QkExitCode_Success une fois l'ajout effectué. En cas d'échec, QkExitCode_ParameterNameConflict cela indique qu'un nouveau symbole de paramètre est en conflit de nom avec un symbole existant. QkExitCode_ParameterError décrit d'autres erreurs courantes pouvant survenir lors de la recherche des symboles de paramètres.

uint32_t qk_gate_num_qubits(QkGate gate)

Obtenir le nombre de qubits pour un QkGate.

Exemple

uint32_t num_qubits = qk_gate_num_qubits(QkGate_CCX);

Paramètres

• gate - Le site QkGate pour obtenir le nombre de qubits.

Returns

Le nombre de qubits sur lesquels la porte agit.

uint32_t qk_gate_num_params(QkGate gate)

Obtenir le nombre de paramètres pour une QkGate.

Exemple

uint32_t num_params = qk_gate_num_params(QkGate_R);

Paramètres

• gate - Le site QkGate pour obtenir le nombre de qubits.

Returns

Le nombre de paramètres de la porte.

QkExitCode qk_circuit_measure(QkCircuit *circuit, uint32_t qubit, uint32_t clbit)

Ajouter une mesure au circuit

Exemple

QkCircuit *qc = qk_circuit_new(100, 1);
qk_circuit_measure(qc, 0, 0);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter la mesure
• qubit - uint32_t pour le qubit à mesurer
• clbit - uint32_t pour le clbit dans lequel le résultat de la mesure doit être stocké

Returns

Un code de sortie.

QkExitCode qk_circuit_reset(QkCircuit *circuit, uint32_t qubit)

Ajouter une réinitialisation au circuit

Exemple

QkCircuit *qc = qk_circuit_new(100, 0);
qk_circuit_reset(qc, 0);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter la réinitialisation
• qubit - Le uint32_t pour le qubit à réinitialiser

Returns

Un code de sortie.

QkExitCode qk_circuit_barrier(QkCircuit *circuit, const uint32_t *qubits, uint32_t num_qubits)

Ajouter une barrière au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 1);
uint32_t qubits[5] = {0, 1, 2, 3, 4};
qk_circuit_barrier(qc, qubits, 5);

Sécurité

La longueur du tableau pointé par qubits doit être num_qubits. En cas de non-concordance, le comportement est indéfini.

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter la barrière.
• num_qubits - Le nombre de qubits de largeur de la barrière.
• qubits - Le pointeur sur le tableau d'indices de qubits uint32_t sur lequel ajouter la barrière.

Returns

Un code de sortie.

QkExitCode qk_circuit_unitary(QkCircuit *circuit, const QkComplex64 *matrix, const uint32_t *qubits, uint32_t num_qubits, bool check_input)

Ajouter une matrice unitaire arbitraire au circuit.

Exemple

QkComplex64 c0 = {0, 0};  // 0+0i
QkComplex64 c1 = {1, 0};  // 1+0i

const uint32_t num_qubits = 1;
QkComplex64 unitary[2*2] = {c0, c1,  // row 0
                            c1, c0}; // row 1

QkCircuit *circuit = qk_circuit_new(1, 0);  // 1 qubit circuit
uint32_t qubit[1] = {0};  // qubit to apply the unitary on
qk_circuit_unitary(circuit, unitary, qubit, num_qubits, true);

Sécurité

Le comportement est indéfini si l'un des éléments suivants n'est pas respecté :

• circuit est un pointeur valide et non nul vers un fichier QkCircuit
• matrix est un pointeur aligné vers des valeurs 4**num_qubits QkComplex64 initialisées
• qubits est un pointeur aligné vers des valeurs num_qubits uint32_t initialisées

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter l'unité.
• matrix - Un pointeur sur le tableau QkComplex64 représentant la matrice unitaire. Il doit s'agir d'une matrice unitaire à majorité de lignes de dimension 2 ^ num_qubits x 2 ^ num_qubits. Plus explicitement : le (i, j)-ème élément est donné par matrix[i * 2^n + j]. Le contenu de matrix est copié à l'intérieur de cette fonction avant d'être ajouté au circuit, de sorte que l'appelant reste propriétaire de la mémoire originale vers laquelle matrix pointe et peut la réutiliser après l'appel, et l'appelant est responsable de sa libération.
• qubits - Un pointeur sur un tableau d'indices de qubits, de longueur num_qubits.
• num_qubits - Le nombre de qubits sur lesquels l'unité agit.
• check_input - Si elle est vraie, la fonction vérifie que la matrice est unitaire. Si la valeur est False, l'appelant doit s'assurer que la matrice est unitaire. Si la matrice n'est pas unitaire, il s'agit d'un comportement indéfini qui entraînera un circuit corrompu.

Returns

Un code de sortie.

void qk_circuit_inst_unitary(QkCircuit *circuit, size_t index, QkComplex64 *out)

Recopiez la matrice unitaire correspondant à une instruction donnée du circuit.

Génère une exception si l'instruction à l'index indiqué n'est pas une opération unitaire.

Sécurité

Le comportement est indéfini si l'une des conditions suivantes n'est pas respectée : si circuit n'est pas un pointeur valide et non nul vers un QkCircuit, si index dépasse les limites du nombre d'instructions du circuit, si out n'est pas valide pour 4**num_qubits écritures de QkComplex64.

Paramètres

• circuit – Un pointeur vers le circuit à partir duquel extraire l'opérateur unitaire.
• index – L'index de l'instruction pour laquelle on souhaite obtenir la matrice unitaire.
• out – Pointeur alloué et aligné dans lequel écrire la matrice unitaire.

QkOperationKind qk_circuit_instruction_kind(const QkCircuit *circuit, size_t index)

Suivez le cours sur les circuits.

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit et si index dépasse les limites du nombre d'instructions du circuit.

Paramètres

• circuit – Un pointeur vers le circuit à partir duquel récupérer le type d'instruction.
• index – L'index de l'instruction dont on souhaite connaître le type.

Returns

Une valeur QkOperationKind d'énumération représentant le type d'instruction à l'index indiqué.

QkOpCounts qk_circuit_count_ops(const QkCircuit *circuit)

Renvoie une liste de noms de chaînes de caractères pour les instructions d'un circuit et leur nombre.

Pour libérer correctement la mémoire allouée par la structure, vous devez appeler qk_opcounts_clear. L'abandon de la structure QkOpCounts sans le faire laissera le tableau stocké de QkOpCount alloué et produira une fuite de mémoire.

Exemple

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubits[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubits, NULL);
QkOpCounts counts = qk_circuit_count_ops(qc);
// .. once done
qk_opcounts_clear(&counts);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur vers le circuit pour lequel les comptes doivent être obtenus.

Returns

Une structure QkOpCounts contenant le nombre d'opérations du circuit.

size_t qk_circuit_num_instructions(const QkCircuit *circuit)

Renvoie le nombre total d'instructions dans le circuit.

Exemple

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);
size_t num = qk_circuit_num_instructions(qc); // 1

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit pour lequel le nombre total d'instructions doit être obtenu.

Returns

Le nombre total d'instructions dans le circuit.

void qk_circuit_get_instruction(const QkCircuit *circuit, size_t index, QkCircuitInstruction *instruction)

Renvoie les détails de l'instruction pour une instruction dans le circuit.

Cette fonction est utilisée pour obtenir les détails d'une instruction donnée dans le circuit.

Cette fonction alloue de la mémoire en interne pour le site QkCircuitInstruction fourni et il vous incombe donc d'appeler qk_circuit_instruction_clear pour la libérer.

Exemple

QkCircuitInstruction inst;
QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);
qk_circuit_get_instruction(qc, 0, &inst);
qk_circuit_instruction_clear(&inst);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit. La valeur de index doit être inférieure à la valeur renvoyée par qk_circuit_num_instructions , sinon la fonction panique. Le comportement est indéfini si instruction n'est pas un pointeur valide et non nul vers une allocation de mémoire disposant de suffisamment d'espace pour QkCircuitInstruction.

Paramètres

• circuit - Un pointeur sur le circuit pour lequel les détails de l'instruction doivent être obtenus.
• index - L'index de l'instruction pour obtenir les détails de l'instruction.
• instruction - Un pointeur vers l'endroit où écrire la QkCircuitInstruction

void qk_circuit_pauli_product_rotation(QkCircuit *circuit, const QkPauliProductRotation *rotation, const uint32_t *qubits)

Appliquer un QkPauliProductRotation à un circuit.

Exemple

// build a IXYZ Pauli rotation
bool x[4] = {false, true, true, false};
bool z[4] = {false, false, true, true};
QkParam *angle = qk_param_from_double(1.0);
QkPauliProductRotation rotation = {x, z, 4, angle};
// append it to a circuit
QkCircuit *circuit = qk_circuit_new(10, 1);
uint32_t qubits[4] = {0, 1, 2, 3};
qk_circuit_pauli_product_rotation(circuit, &rotation, qubits);
// do something with the circuit... and then free it
qk_param_free(angle);
qk_circuit_free(circuit);

Sécurité

Le comportement est indéfini si l'un des éléments suivants n'est pas respecté :

• circuit est un pointeur valide et non nul vers un fichier QkCircuit
• rotation est un pointeur valide et non nul vers un objet cohérent QkPauliProductRotation. Plus précisément, les tableaux de rotation->z rotation->x données et doivent comporter rotation->len éléments.
• qubits est un pointeur aligné vers des valeurs rotation->len uint32_t initialisées.

Paramètres

• circuit – Le circuit auquel appliquer l'opération.
• rotation – Un pointeur vers la rotation QkPauliProductRotation à appliquer.
• qubits – Un pointeur vers le tableau de qubits.

QkExitCode qk_circuit_inst_pauli_product_rotation(const QkCircuit *circuit, size_t index, QkPauliProductRotation *instruction)

Récupérer les QkPauliProductRotation données d'une instruction de circuit.

Pour un circuit comportant une QkPauliProductRotation instruction à l'index index, cette fonction attribuera au instruction pointeur une copie des QkPauliProductRotation données. Notez que ces données sont indépendantes du circuit et doivent être libérées manuellement à l'aide de qk_pauli_product_rotation_clear.

Si l'instruction à l'adresse indiquée index** n'est pas** une instruction QkPauliProductRotation, cette fonction renvoie QkExitCode_InvalidOperationKind une erreur. Vous pouvez vérifier que l'instruction est du bon type à l'aide de qk_circuit_instruction_kind.

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit. La valeur de index doit être inférieure à celle renvoyée par; qk_circuit_num_instructions sinon, cette fonction provoquera une exception. Le comportement est indéfini si instruction n'est pas un pointeur valide et non nul vers une allocation de mémoire disposant d'un espace suffisant pour un QkPauliProductRotation.

Paramètres

• circuit – Un pointeur vers le circuit à partir duquel récupérer les détails de l'instruction.
• index – L'index des instructions du circuit.
• instruction – Un pointeur vers une zone de mémoire allouée QkPauliProductRotation pour stocker les données.

Returns

QkExitCode_Success si la donnée a été écrite dans l'instruction, ou QkExitCode_InvalidOperationKind si l'index ne pointait pas vers un QkPauliProductRotation.

void qk_circuit_pauli_product_measurement(QkCircuit *circuit, const QkPauliProductMeasurement *measurement, const uint32_t *qubits, uint32_t clbit)

Appliquer un QkPauliProductMeasurement à un circuit.

Exemple

// build a XZ Pauli measurement
bool x[2] = {true, false};
bool z[2] = {false, true};
QkPauliProductMeasurement measure = {x, z, 2, false};
// append it to a circuit
QkCircuit *circuit = qk_circuit_new(10, 1);
uint32_t qubits[2] = {0, 2};
uint32_t clbit = 0;
qk_circuit_pauli_product_measurement(circuit, &measure, qubits, clbit);
// do something with the circuit... and then free it
qk_circuit_free(circuit);

Sécurité

Le comportement est indéfini si l'un des éléments suivants n'est pas respecté :

• circuit est un pointeur valide et non nul vers un fichier QkCircuit
• measurement est un pointeur valide et non nul vers un objet cohérent QkPauliProductMeasurement. Plus précisément, les tableaux de measurement->z measurement->x données et doivent comporter measurement->len éléments.
• qubits est un pointeur aligné vers des valeurs rotation->len uint32_t initialisées.

Paramètres

• circuit – Le circuit auquel appliquer l'opération.
• mesure – Un pointeur vers la mesure QkPauliProductMeasurement à appliquer.
• qubits – Un pointeur vers le tableau de qubits.
• clbit – Un élément unique uint32_t spécifiant le qubit de mesure.

QkExitCode qk_circuit_inst_pauli_product_measurement(const QkCircuit *circuit, size_t index, QkPauliProductMeasurement *instruction)

Récupérer les QkPauliProductMeasurement données d'une instruction de circuit.

Pour un circuit comportant une QkPauliProductMeasurement instruction à l'index index, cette fonction attribuera au instruction pointeur une copie des QkPauliProductMeasurement données. Notez que ces données, qui existent indépendamment du circuit, doivent être libérées manuellement à l'aide de qk_pauli_product_measurement_clear.

Si l'instruction à l'adresse indiquée index** n'est pas** une instruction QkPauliProductMeasurement, cette fonction renvoie QkExitCode_InvalidOperationKind une erreur. Vérifiez que l'instruction est du type approprié à l'aide de qk_circuit_instruction_kind.

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un QkCircuit. La valeur de index doit être inférieure à celle renvoyée par; qk_circuit_num_instructions sinon, cette fonction provoquera une exception. Le comportement est indéfini si instruction n'est pas un pointeur valide et non nul vers une allocation de mémoire disposant d'un espace suffisant pour un QkPauliProductMeasurement.

Paramètres

• circuit – Un pointeur vers le circuit à partir duquel récupérer les détails de l'instruction.
• index – L'index des instructions du circuit.
• instruction – Un pointeur vers une zone de mémoire allouée QkPauliProductMeasurement pour stocker les données.

Returns

QkExitCode_Success si la donnée a été écrite dans l'instruction, ou QkExitCode_InvalidOperationKind si l'index ne pointait pas vers un QkPauliProductMeasurement.

void qk_circuit_instruction_clear(QkCircuitInstruction *inst)

Efface les données de l'objet instruction de circuit.

Cette fonction ne libère pas l'allocation pour le pointeur QkCircuitInstruction fourni, elle libère uniquement les allocations internes pour les données contenues dans l'instruction. Vous êtes responsable de l'allocation et de la libération de l'allocation réelle utilisée pour stocker un QkCircuitInstruction.

Exemple

QkCircuitInstruction *inst = malloc(sizeof(QkCircuitInstruction));
QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t q0[1] = {0};
qk_circuit_gate(qc, QkGate_H, q0, NULL);
qk_circuit_get_instruction(qc, 0, inst);
qk_circuit_instruction_clear(inst); // clear internal allocations
free(inst); // free struct
qk_circuit_free(qc); // free the circuit

Sécurité

Le comportement est indéfini si inst n'est pas un pointeur valide et non nul vers QkCircuitInstruction.

Paramètres

• inst - Un pointeur sur l'instruction à libérer.

void qk_opcounts_clear(QkOpCounts *op_counts)

Effacer le contenu d'une liste de comptage des opérations de circuit.

Sécurité

Le comportement est indéfini si op_counts n'est pas l'objet renvoyé par qk_circuit_count_ops.

Paramètres

• op_counts - La liste des décomptes d'opérations renvoyée par qk_circuit_count_ops.

QkExitCode qk_circuit_delay(QkCircuit *circuit, uint32_t qubit, double duration, QkDelayUnit unit)

Ajouter une instruction de retard au circuit.

Exemple

QkCircuit *qc = qk_circuit_new(1, 0);
qk_circuit_delay(qc, 0, 100.0, QkDelayUnit_NS);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit auquel ajouter le délai.
• qubit - L'indice uint32_t du qubit auquel appliquer le délai.
• duration - La durée du délai.
• unit - Une énumération représentant l'unité de la durée.

Returns

Un code de sortie.

char *qk_circuit_draw(const QkCircuit *circuit, const QkCircuitDrawerConfig *config)

Dessinez le schéma sous forme de texte.

Exemple

QkCircuit *circuit = qk_circuit_new(2, 1);

qk_circuit_gate(circuit, QkGate_H, (uint32_t[]){0}, NULL);
qk_circuit_gate(circuit, QkGate_CX, (uint32_t[]){0, 1}, NULL);
qk_circuit_measure(circuit, 0, 0);
qk_circuit_measure(circuit, 1, 0);

QkCircuitDrawerConfig config = {false, true, 0};

char *circ_str = qk_circuit_draw(circuit, &config);

printf("%s", circ_str);

qk_str_free(circ_str);
qk_circuit_free(circuit);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers une structure QkCircuit, ou si config n'est pas NULL et est un pointeur non valide vers une QkCircuitDrawerConfig structure.

Paramètres

• circuit – Un pointeur vers le circuit à dessiner.

• config – Un pointeur vers la QkCircuitDrawerConfig structure ou NULL. Si la valeur est NULL, le tiroir utilisera les valeurs par défaut suivantes :

  • bundle_cregs = true
  • merge_wires = true
  • fold = 0

Returns

Un pointeur vers une chaîne terminée par un caractère nul contenant la représentation du circuit. Vous devez utiliser qk_str_free pour libérer la mémoire allouée une fois que vous avez terminé.

QkDag *qk_circuit_to_dag(const QkCircuit *circuit)

Convertir un circuit donné en un graphe acyclique dirigé (DAG).

Le nouveau DAG est copié à partir du circuit; la référence circuit d'origine appartient toujours à l'appelant et doit toujours être libérée avec qk_circuit_free. Vous devez libérer le DAG renvoyé avec qk_dag_free lorsque vous avez terminé de l'utiliser.

Exemple

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr = qk_quantum_register_new(3, "qr");
qk_circuit_add_quantum_register(qc, qr);
qk_quantum_register_free(qr);

QkDag *dag = qk_circuit_to_dag(qc);

qk_dag_free(dag);
qk_circuit_free(qc);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit – Pointeur vers le circuit à partir duquel créer le DAG.

Returns

Un pointeur vers le nouveau DAG.

QkCircuit *qk_circuit_copy_empty_like(const QkCircuit *circuit, QkVarsMode vars_mode, QkBlocksMode blocks_mode)

Renvoie une copie de soi-même avec la même structure, mais vide.

Cette structure comprend :

• phase globale
• tous les qubits et clbits, y compris les registres.

Exemple

QkCircuit *qc = qk_circuit_new(10, 10);
for (int i = 0; i < 10; i++) {
    qk_circuit_measure(qc, i, i);
    uint32_t qubits[1] = {i};
    qk_circuit_gate(qc, QkGate_H, qubits, NULL);
}

// As the circuit does not contain any control-flow instructions,
// vars_mode and blocks_mode do not have any effect.
QkCircuit *copy = qk_circuit_copy_empty_like(qc, QkVarsMode_Alike, QkBlocksMode_Drop);

size_t num_copy_instructions = qk_circuit_num_instructions(copy); // 0

// do something with the copy

qk_circuit_free(qc);
qk_circuit_free(copy);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers QkCircuit.

Paramètres

• circuit - Un pointeur sur le circuit à copier.
• vars_mode – Mode de gestion des variables classiques.
• blocks_mode – Mode de gestion des blocs.

Returns

Le pointeur vers le circuit copié.

double qk_circuit_estimate_fidelity(const QkCircuit *circuit, const QkTarget *target)

Évaluer la fidélité d'un circuit physique.

Cette fonction calcule le produit des taux d'erreur de chaque porte du circuit afin d'estimer la fidélité de celui-ci. Cette méthode n'a pas pour but de fournir une simulation réaliste de la fidélité de l'exécution sur du matériel réel. Il est conçu pour fournir une estimation du fonctionnement du transpileur en fonction du niveau de fidélité associé aux différentes heuristiques utilisées lors de son exécution. En général, cela ne sert qu'à comparer entre elles les différentes sorties de compilation afin d'estimer laquelle permettrait d'obtenir une exécution de meilleure qualité sur le matériel.

Sécurité

QkCircuit Le comportement est indéfini si circuit et target ne sont pas respectivement des pointeurs valides et non nuls vers et QkTarget .

Paramètres

• circuit – Un pointeur vers le circuit dont on souhaite estimer la fidélité.
• target – Un pointeur vers la cible sur laquelle le circuit sera exécuté. Cela permet de déterminer les taux d'erreur des instructions du circuit.

Returns

La fidélité calculée du circuit. Cela renverra « NaN » si le circuit n'est pas physique, ce qui signifie que certaines circuit instructions ne sont pas prises en charge par target.

QkControlFlowInstruction *qk_circuit_get_control_flow_instruction(const QkCircuit *circuit, size_t inst_idx, const QkControlFlowInstruction *parent_cf)

Récupérer une instruction de flux de contrôle provenant d'un circuit à l'index spécifié.

Cette fonction renvoie un pointeur vers une structure opaque QkControlFlowInstruction contenant des informations sur une instruction de contrôle de flux située à l'index spécifié. L'instruction à l'adresse inst_idx doit être une instruction de contrôle de flux (par exemple : IfElse,, ForLoop, etc.).

Exemple

QkCircuit *circuit = ...; // Assume circuit contains a control flow instruction at index 0
QkControlFlowInstruction *cf_inst = qk_circuit_get_control_flow_instruction(circuit, 0, NULL);
QkControlFlowKind kind = qk_control_flow_kind(cf_inst);
qk_control_flow_instruction_free(cf_inst);

Sécurité

Le comportement est indéfini si circuit n'est pas un pointeur valide vers un QkCircuit objet, si inst_idx n'est pas un index valide dans la liste d'instructions du circuit, ou si l'instruction située à l'adresse inst_idx n'est pas une instruction de contrôle de flux. Si parent_cf n'est pas nul, il doit s'agir d'un pointeur valide vers un QkControlFlowInstruction.

Paramètres

• circuit – Un pointeur vers le circuit contenant l'instruction de flux de contrôle.
• inst_idx – L'index de l'instruction dans la liste des instructions du circuit.
• parent_cf – Un pointeur vers l'instruction de flux de contrôle englobante, ou NULL si cette instruction se trouve au niveau supérieur du circuit. Cela permet de calculer les correspondances correctes entre les qubits et les clbits par rapport au circuit de niveau supérieur.

Returns

Un pointeur vers un objet nouvellement alloué QkControlFlowInstruction .

void qk_control_flow_instruction_free(QkControlFlowInstruction *cf_inst)

Libérer un QkControlFlowInstruction objet.

Exemple

QkCircuit *circuit = ...; // Assume circuit contains a control flow instruction at index 0
QkControlFlowInstruction *cf_inst = qk_circuit_get_control_flow_instruction(circuit, 0, NULL);
qk_control_flow_instruction_free(cf_inst);

Sécurité

Le comportement est indéfini si cf_inst n'est pas un pointeur valide renvoyé par qk_circuit_get_control_flow_instruction, ou si cette fonction est appelée plus d'une fois sur le même pointeur.

Paramètres

• cf_inst – Un pointeur vers l'instruction de flux de contrôle à libérer.

PyObject *qk_circuit_to_python(QkCircuit *qc)

Transférez la propriété d'un QkCircuit objet à Python.

L'objet Python obtenu n 'est pas l'objet QuantumCircuitlui-même, mais son contenu interne CircuitData, auquel on accède généralement sous la forme QuantumCircuit._data .. Vous pouvez utiliser qk_circuit_to_python_full pour créer un objet QuantumCircuit complet.

Il n'est pas sûr d'utiliser le QkCircuit pointeur après avoir appelé cette fonction. En particulier, vous ne devez pas essayer de le nettoyer ou de le dégager. L'appelant doit être le propriétaire de l'objet QkCircuit, et non pas détenir une référence empruntée (par exemple, un objet QkCircuit * récupéré à partir de qk_circuit_borrow_from_python n'est pas considéré comme étant de sa propriété).

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un objet initialisé et appartenant à l'utilisateur QkCircuit.

Paramètres

• qc – L'objet concerné.

Returns

Une référence de type « owned- Python » à l'objet.

PyObject *qk_circuit_to_python_full(QkCircuit *qc)

Transférez la propriété d'un QkCircuit objet à Python et créez un QuantumCircuit.

Cela implique une logique supplémentaire dans l'espace d' Python s pour obtenir le complet QuantumCircuit, puisque ne QkCircuit correspond qu'au champ QuantumCircuit._data interne.

Il n'est pas sûr d'utiliser le QkCircuit pointeur après avoir appelé cette fonction. En particulier, vous ne devez pas essayer de le nettoyer ou de le dégager. L'appelant doit être le propriétaire de l'objet QkCircuit, et non pas détenir une référence empruntée (par exemple, un objet QkCircuit * récupéré à partir de qk_circuit_borrow_from_python n'est pas considéré comme étant de sa propriété).

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si circuit n'est pas un pointeur valide et non nul vers un objet initialisé et appartenant à l'utilisateur QkCircuit.

Paramètres

• qc – L'objet concerné.

Returns

Une référence de type « owned- Python » à l'objet.

QkCircuit *qk_circuit_borrow_from_python(PyObject *ob)

Récupérer un QkCircuit pointeur à partir d'un objet Python.

Notez que l'entrée de cette fonction ne doit pas être QuantumCircuit, mais la sortie de QuantumCircuit._data. Cela est nécessaire pour garantir le bon fonctionnement du comptage des références.

Cette opération emprunte une référence à un objet de type Python et en extrait le QkCircuit pointeur, à condition que celui-ci soit du type approprié. Le pointeur renvoyé est emprunté au ob pointeur. Si le type PyObject n'est pas correct, la valeur de retour est NULL et l'état d'exception de l'interpréteur Python est activé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_circuit_convert_from_python, qui est logiquement identique à cette fonction, mais qui peut être directement utilisé comme fonction de « conversion » pour la PyArg_Parse* famille de fonctions de conversion de l' Python.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si ob n'est pas un pointeur valide et non nul vers un objet de type Python.

Paramètres

• ob – Un objet de type « Python » emprunté.

Returns

Un pointeur vers l'objet natif, ou NULL si l'objet de l' Python ation n'est pas du bon type.

int qk_circuit_convert_from_python(PyObject *object, void *address)

Récupérer un QkCircuit pointeur à partir d'un objet Python.

Notez que l'entrée de cette fonction ne doit pas être QuantumCircuit, mais la sortie de QuantumCircuit._data. Cela est nécessaire pour garantir le bon fonctionnement du comptage des références.

Cette fonction emprunte une référence à Python et en extrait le QkCircuit pointeur vers address, si celui-ci est du type approprié. Le pointeur renvoyé est emprunté au object pointeur. Si PyObject n'est pas du type correct, la valeur de retour est 0, l'état d'exception de l'interpréteur Python est activé et address reste inchangé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_circuit_borrow_from_python, qui est logiquement identique à ceci, mais qui présente une syntaxe plus naturelle pour une utilisation directe.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si object n'est pas un pointeur valide et non nul vers un objet Python, ou si address n'est pas un pointeur vers des données modifiables du type approprié.

Paramètres

• objet – Un objet emprunté de type « Python ».
• adresse – Emplacement où enregistrer les données de sortie.

Returns

1 en cas de réussite, 0 en cas d'échec.

PyObject *qk_quantum_register_to_python(QkQuantumRegister *qr)

Transférez la propriété d'un QkQuantumRegister objet à Python.

Il n'est pas sûr d'utiliser le QkQuantumRegister pointeur après avoir appelé cette fonction. En particulier, vous ne devez pas essayer de le nettoyer ou de le dégager. L'appelant doit être le propriétaire de l'objet QkQuantumRegister, et non pas détenir une référence empruntée (par exemple, un objet QkQuantumRegister * récupéré à partir de qk_quantum_register_borrow_from_python n'est pas considéré comme étant de sa propriété).

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si qr n'est pas un pointeur valide et non nul vers un objet initialisé et appartenant à l'utilisateur QkQuantumRegister.

Paramètres

• qr – L'objet concerné.

Returns

Une référence de type « owned- Python » à l'objet.

const QkQuantumRegister *qk_quantum_register_borrow_from_python(PyObject *ob)

Récupérer un QkQuantumRegister pointeur à partir d'un objet Python.

Cette opération emprunte une référence à un objet de type Python et en extrait le QkQuantumRegister pointeur, à condition que celui-ci soit du type approprié. Le pointeur renvoyé est emprunté au ob pointeur. Si le type PyObject n'est pas correct, la valeur de retour est NULL et l'état d'exception de l'interpréteur Python est activé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_quantum_register_convert_from_python, qui est logiquement identique à cette fonction, mais qui peut être directement utilisé comme fonction de « conversion » pour la PyArg_Parse* famille de fonctions de conversion de l' Python.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si ob n'est pas un pointeur valide et non nul vers un objet de type Python.

Paramètres

• ob – Un objet de type « Python » emprunté.

Returns

Un pointeur vers l'objet natif, ou NULL si l'objet de l' Python ation n'est pas du bon type.

int qk_quantum_register_convert_from_python(PyObject *object, void *address)

Récupérer un QkQuantumRegister pointeur à partir d'un objet Python.

Cette fonction emprunte une référence à Python et en extrait le QkQuantumRegister pointeur vers address, si celui-ci est du type approprié. Le pointeur renvoyé est emprunté au object pointeur. Si PyObject n'est pas du type correct, la valeur de retour est 0, l'état d'exception de l'interpréteur Python est activé et address reste inchangé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_quantum_register_borrow_from_python, qui est logiquement identique à ceci, mais qui présente une syntaxe plus naturelle pour une utilisation directe.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si object n'est pas un pointeur valide et non nul vers un objet Python, ou si address n'est pas un pointeur vers des données modifiables du type approprié.

Paramètres

• objet – Un objet emprunté de type « Python ».
• adresse – Emplacement où enregistrer les données de sortie.

Returns

1 en cas de réussite, 0 en cas d'échec.

PyObject *qk_classical_register_to_python(QkClassicalRegister *cr)

Transférez la propriété d'un QkClassicalRegister objet à Python.

Il n'est pas sûr d'utiliser le QkClassicalRegister pointeur après avoir appelé cette fonction. En particulier, vous ne devez pas essayer de le nettoyer ou de le dégager. L'appelant doit être le propriétaire de l'objet QkClassicalRegister, et non pas détenir une référence empruntée (par exemple, un objet QkClassicalRegister * récupéré à partir de qk_classical_register_borrow_from_python n'est pas considéré comme étant de sa propriété).

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si cr n'est pas un pointeur valide et non nul vers un objet initialisé et appartenant à l'utilisateur QkClassicalRegister.

Paramètres

• cr – L'objet concerné.

Returns

Une référence de type « owned- Python » à l'objet.

const QkClassicalRegister *qk_classical_register_borrow_from_python(PyObject *ob)

Récupérer un QkClassicalRegister pointeur à partir d'un objet Python.

Cette opération emprunte une référence à un objet de type Python et en extrait le QkClassicalRegister pointeur, à condition que celui-ci soit du type approprié. Le pointeur renvoyé est emprunté au ob pointeur. Si le type PyObject n'est pas correct, la valeur de retour est NULL et l'état d'exception de l'interpréteur Python est activé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_classical_register_convert_from_python, qui est logiquement identique à cette fonction, mais qui peut être directement utilisé comme fonction de « conversion » pour la PyArg_Parse* famille de fonctions de conversion de l' Python.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si ob n'est pas un pointeur valide et non nul vers un objet de type Python.

Paramètres

• ob – Un objet de type « Python » emprunté.

Returns

Un pointeur vers l'objet natif, ou NULL si l'objet de l' Python ation n'est pas du bon type.

int qk_classical_register_convert_from_python(PyObject *object, void *address)

Récupérer un QkClassicalRegister pointeur à partir d'un objet Python.

Cette fonction emprunte une référence à Python et en extrait le QkClassicalRegister pointeur vers address, si celui-ci est du type approprié. Le pointeur renvoyé est emprunté au object pointeur. Si PyObject n'est pas du type correct, la valeur de retour est 0, l'état d'exception de l'interpréteur Python est activé et address reste inchangé.

Vous devez être connecté à un interpréteur Python pour pouvoir appeler cette fonction.

Vous pouvez également utiliser qk_classical_register_borrow_from_python, qui est logiquement identique à ceci, mais qui présente une syntaxe plus naturelle pour une utilisation directe.

Sécurité

L'appelant doit être connecté à un interprète d' Python. Le comportement est indéfini si object n'est pas un pointeur valide et non nul vers un objet Python, ou si address n'est pas un pointeur vers des données modifiables du type approprié.

Paramètres

• objet – Un objet emprunté de type « Python ».
• adresse – Emplacement où enregistrer les données de sortie.

Returns

1 en cas de réussite, 0 en cas d'échec.