QkTarget

typedef struct QkTarget QkTarget

Un mappage d'instructions et de propriétés représentant les contraintes particulières d'un backend. Son but est de fournir au compilateur des informations qui lui permettent de compiler un circuit d'entrée en un autre circuit optimisé en tenant compte des spécifications du site QkTarget. Cette structure représente une interface de bas niveau avec la principale structure de données Target en Rust, qui représente la classe de base pour son homologue Python, Target.

Voici un exemple de fonctionnement de cette structure :

#include <qiskit.h>
#include <math.h>

// Create a Target with 2 qubits
QkTarget *target = qk_target_new(2);
// Create an entry for a CX Gate with qargs (0, 1) and properties
// duration = 0.0123
// error = NaN
uint32_t qargs[2] = {0, 1};
QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
qk_target_entry_add_property(entry, qargs, 2, 0.0123, NAN);

// Add a CX Gate to the target
qk_target_add_instruction(target, entry);

// Add a global H gate
qk_target_add_instruction(target, qk_target_entry_new(QkGate_H));

// Free the created target.
qk_target_free(target);

L'API C cible ne prend actuellement en charge que les ajouts d'instances QkGate sans paramètres ou avec des paramètres fixes. La prise en charge des paramètres réguliers sera ajoutée à l'avenir. La fonctionnalité continuera à s'étendre au fil du temps, à mesure que nous améliorerons nos capacités en matière de modèle de données Rust.

Types de données

QkInstructionProperties

struct QkInstructionProperties

Représentation des propriétés d'instruction d'une opération cible.

double durée

La durée, en secondes, de l'instruction sur l'ensemble spécifié de qubits. Sera défini sur NaN si la propriété n'est pas définie.

double erreur

Taux d'erreur moyen pour l'instruction sur l'ensemble spécifié de qubits. Sera défini sur NaN si la propriété n'est pas définie.

QkTargetOp

struct QkTargetOp

Représentation d'une opération identifiée au sein de la cible.

Cette structure est créée de manière native par l'API Target sous-jacente et les utilisateurs ne doivent pas y écrire directement ni essayer de libérer ses attributs manuellement, car cela entraînerait un comportement indéfini. Pour libérer cette structure, les utilisateurs doivent appeler qk_target_op_clear à la place.

QkOperationKind op_type

Identifiant de l'opération en cours.

char *nom

Nom de l'opération.

uint32_t num_qubits

Le nombre de qubits pris en charge par cette opération. Par défaut, (uint32_t)-1 dans le cas d'un variadic.

const QkParam **params

Les paramètres associés à cette opération, tels que QkParam. S'il n'y a pas de paramètres, cette valeur sera représentée par un NULL pointeur.

uint32_t num_params

Nombre de paramètres pris en charge par cette opération. Par défaut, (uint32_t)-1 dans le cas d'un variadic.

Fonctions

qk_target_new

QkTarget *qk_target_new(uint32_t num_qubits)

Construire un nouveau QkTarget avec le nombre de qubits donné. Le nombre de qubits est appelé à changer si une instruction est ajoutée avec des propriétés qui s'appliquent à une collection de qargs dans laquelle tout indice est supérieur au nombre de qubits spécifié

Exemple

QkTarget *target = qk_target_new(5);

Paramètres

num_qubits - Le nombre de qubits que le site QkTarget prendra explicitement en charge.

Retours

Un pointeur sur le nouveau QkTarget

qk_target_borrow_from_python

QkTarget *qk_target_borrow_from_python(PyObject *ob)

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

Cette opération emprunte une référence à un objet de type Python et en extrait le QkTarget 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_target_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é.

Retours

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

qk_target_convert_from_python

int qk_target_convert_from_python(PyObject *object, void *address)

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

Cette fonction emprunte une référence à Python et en extrait le QkTarget 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 1, 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_target_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.

Retours

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

qk_target_num_qubits

uint32_t qk_target_num_qubits(const QkTarget *target)

Renvoie le nombre de qubits de ce site QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
uint32_t num_qubits = qk_target_num_qubits(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

Le nombre de qubits que cette cible peut utiliser.

qk_target_dt

double qk_target_dt(const QkTarget *target)

Renvoie la valeur dt de cette QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
qk_target_set_dt(target, 10e-9);
double dt = qk_target_dt(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La valeur dt de ce site QkTarget ou NAN si elle n'est pas attribuée.

qk_target_granularity

uint32_t qk_target_granularity(const QkTarget *target)

Renvoie la valeur de granularité de cette QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
uint32_t granularity = qk_target_granularity(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La valeur granularity de ce QkTarget.

qk_target_min_length

uint32_t qk_target_min_length(const QkTarget *target)

Renvoie la valeur min_length de ce QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
size_t min_length = qk_target_min_length(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La valeur min_length de ce QkTarget.

qk_target_pulse_alignment

uint32_t qk_target_pulse_alignment(const QkTarget *target)

Renvoie la valeur pulse_alignment de ce QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
uint32_t pulse_alignment = qk_target_pulse_alignment(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La valeur pulse_alignment de ce QkTarget.

qk_target_acquire_alignment

uint32_t qk_target_acquire_alignment(const QkTarget *target)

Renvoie la valeur acquire_alignment de ce QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 0
uint32_t acquire_alignment = qk_target_pulse_alignment(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La valeur acquire_alignment de ce QkTarget.

qk_target_set_dt

QkExitCode qk_target_set_dt(QkTarget *target, double dt)

Définit la valeur dt de ce site QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
double dt = qk_target_set_dt(target, 10e-9);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
dt - La valeur dt pour la résolution temporelle de l'entrée du système.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_set_granularity

QkExitCode qk_target_set_granularity(QkTarget *target, uint32_t granularity)

Définit la valeur granularity de cette QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
qk_target_set_granularity(target, 2);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
granularité - Valeur de la résolution minimale de la porte d'impulsion en unités de dt.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_set_min_length

QkExitCode qk_target_set_min_length(QkTarget *target, uint32_t min_length)

Définit la valeur min_length de cette QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
qk_target_set_min_length(target, 3);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
min_length - La valeur minimale de la longueur de la porte d'impulsion en unités de dt.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_set_pulse_alignment

QkExitCode qk_target_set_pulse_alignment(QkTarget *target, uint32_t pulse_alignment)

Renvoie la valeur pulse_alignment de ce QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 1
qk_target_set_pulse_alignment(target, 4);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
pulse_alignment - valeur représentant une résolution temporelle de la porte.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_set_acquire_alignment

QkExitCode qk_target_set_acquire_alignment(QkTarget *target, uint32_t acquire_alignment)

Définit la valeur acquire_alignment de cette QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
// The value defaults to 0
qk_target_set_acquire_alignment(target, 5);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
acquire_alignment - valeur représentant une résolution temporelle de l'heure de début de l'instruction de mesure.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_copy

QkTarget *qk_target_copy(QkTarget *target)

Crée une copie du site QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
QkExitCode result = qk_target_add_instruction(target, entry);

QkTarget *copied = qk_target_copy(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget à copier.

Retours

Un pointeur sur la nouvelle copie de QkTarget.

qk_target_free

void qk_target_free(QkTarget *target)

Libérez le site QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
qk_target_free(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget à libérer.

qk_target_add_instruction

QkExitCode qk_target_add_instruction(QkTarget *target, QkTargetEntry *target_entry)

Ajoute une porte à l'adresse QkTarget par le biais d'une QkTargetEntry.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
QkExitCode result = qk_target_add_instruction(target, entry);

Sécurité

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

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

Paramètres

target - Un pointeur sur le site QkTarget.
target_entry - Pointeur sur le site QkTargetEntry. Le pointeur est libéré lorsqu'il est ajouté à QkTarget.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_update_property

QkExitCode qk_target_update_property(QkTarget *target, QkGate instruction, uint32_t *qargs, uint32_t num_qubits, double duration, double error)

Modifie les propriétés d'une porte dans le site QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
double params[1] = {3.1415};
QkTargetEntry *entry = qk_target_entry_new_fixed(QkGate_CRX, params, "crx_pi");
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

qk_target_update_property(target, QkGate_CRX, qargs, 2, 0.0012, 1.1);

Sécurité

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

Le type qargs est censé être un pointeur sur un tableau de uint32_t dont la longueur est spécifiée par num_qubits et doit correspondre à l'attente de la porte. 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 pour une porte donnée. Vous pouvez consulter le site qk_gate_num_qubits pour déterminer le nombre de qubits requis pour une porte donnée.

Paramètres

target - Un pointeur sur le site QkTarget.
instruction - L'instruction à modifier.
qargs - Le pointeur vers le tableau de valeurs uint32_t à utiliser comme qargs. Peut être NULL si elle est globale.
num_qubits - Le nombre de qubits de l'instruction...
duration - Durée de l'instruction en secondes sur l'ensemble spécifique de qubits.
error - Taux d'erreur moyen de l'instruction sur l'ensemble spécifique de qubits.

Retours

QkExitCode précisant si l'opération a réussi.

qk_target_num_instructions

size_t qk_target_num_instructions(const QkTarget *target)

Renvoie le nombre d'instructions suivies par un QkTarget.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *target_entry = qk_target_entry_new(QkGate_H);
qk_target_add_instruction(target, target_entry);

size_t num_instructions = qk_target_num_instructions(target);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.

Retours

La longueur de la cible.

qk_target_instruction_supported

bool qk_target_instruction_supported(const QkTarget *target, const char *operation_name, const uint32_t *qargs, QkParam **params)

Vérifie si l'instruction fournie et ses qargs sont pris en charge par ce Target.

Exemple

// Create a mock target with only a global crx entry
// and 3.14 as its rotation parameter.
QkTarget *target = qk_target_new(5);
QkTargetEntry *crx_entry = qk_target_entry_new_fixed(QkGate_CRX, (double[]){3.14});
qk_target_entry_add_property(crx_entry, NULL, 0, 0.0, 0.1);
qk_target_add_instruction(target, crx_entry);

// Check if target is compatible with a "crx" gate
// at [0, 1] with 3.14 rotation.
QkParam *params[1] = {qk_param_from_double(3.14)};
qk_target_instruction_supported(target, "crx", (uint32_t []){0, 1}, params);

// Free the pointers
qk_param_free(params[0]);
qk_target_free(target);

Sécurité

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

L'argument qargs doit être un pointeur vers un tableau dont u32int_t la longueur correspond à celle attendue par la porte. 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 pour une porte donnée. Vous pouvez vérifier qk_gate_num_qubits pour déterminer combien de qubits sont nécessaires pour une porte donnée.

L'argument params doit être un tableau dont QkParam la longueur correspond à celle attendue pour l'opération en question. Si le tableau n'est pas suffisamment long, le comportement sera indéfini, comme mentionné ci-dessus pour qargs l'argument. Vous pouvez toujours vérifier qk_gate_num_params dans le cas d'un QkGate.

Paramètres

cible – Un pointeur vers le Target.
operation_name – Nom de l'instruction à vérifier.
qargs - Le pointeur vers le tableau de valeurs uint32_t à utiliser comme qargs. Peut être NULL si elle est globale.
params – Pointeur vers un tableau de pointeurs QkParam d'objets en tant que paramètres à vérifier. Peut être NULL si aucun paramètre n'est présent.

Retours

Si l'instruction est prise en charge ou non.

qk_target_op_index

size_t qk_target_op_index(const QkTarget *target, const char *name)

Renvoie l'index à l'emplacement duquel se trouve une opération en fonction de son nom.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *target_entry = qk_target_entry_new(QkGate_H);
qk_target_add_instruction(target, target_entry);

size_t op_idx = qk_target_op_index(target, "h");

Sécurité

Le comportement est indéfini si QkTarget n'est pas un pointeur valide et non nul vers un QkTarget. Le comportement est indéfini si name n'est pas un pointeur vers une chaîne valide terminée par un caractère nul.

Paramètres

target - Un pointeur sur le site QkTarget.
nom – Le nom dont vous souhaitez obtenir l'index.

Retours

l'index dans lequel l'opération est la valeur maximale de size_t dans le cas où elle ne se trouve pas dans la cible.

qk_target_op_name

char *qk_target_op_name(const QkTarget *target, size_t index)

Renvoie le nom de l'opération stockée à cet index dans la carte de QkTarget portes de l'instance.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *target_entry = qk_target_entry_new(QkGate_H);
qk_target_add_instruction(target, target_entry);

char *op_name = qk_target_op_name(target, 0);
// Free after use
qk_str_free(op_name);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
index – L'index sous lequel la porte est stockée.

Retours

Nom de l'opération associée à l'index fourni.

qk_target_op_num_properties

size_t qk_target_op_num_properties(const QkTarget *target, size_t index)

Renvoie le nombre de propriétés définies pour l'opération spécifiée dans QkTarget l'instance, a.k.a. la longueur du plan cadastral. Panique si l'index d'opération n'est pas présent.

Exemple

QkTarget *target = qk_target_new(5);
QkTargetEntry *target_entry = qk_target_entry_new(QkGate_H);
qk_target_add_instruction(target, target_entry);

size_t num_props = qk_target_op_num_properties(target, 0);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
index – L'index dans lequel la porte est stockée.

Retours

Nombre de propriétés spécifiées pour l'opération associée à cet index.

qk_target_op_qargs_index

size_t qk_target_op_qargs_index(const QkTarget *target, size_t op_idx, const uint32_t *qargs)

Récupérer l'index auquel certains qargs sont stockés. Renvoie SIZE_MAX si introuvable.

Exemple

QkTarget *target = qk_target_new(5);

QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

size_t idx_0_1 = qk_target_op_qargs_index(target, 0, qargs);

Sécurité

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

Paramètres

target - Un pointeur sur le site QkTarget.
op_idx – L'index auquel l'opération est stockée.
qargs – Pointeur vers le tableau des indices uint32_t de qubits à vérifier, peut être un pointeur nul pour vérifier les propriétés globales.

Retours

L'index des qargs associés à l'instruction à l'index op_idx spécifié ou SIZE_MAX si les qargs ne sont pas présents.

qk_target_op_qargs

void qk_target_op_qargs(const QkTarget *target, size_t op_idx, size_t qarg_idx, uint32_t **qargs_out, uint32_t *qargs_len)

Récupérer les qargs pour l'opération par index.

Panique si l'un des indices est hors limites.

Exemple

QkTarget *target = qk_target_new(5);

QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

uint32_t *qargs_retrieved;
uint32_t qargs_length;
qk_target_op_qargs(target, 0, 0, &qargs_retrieved, &qargs_length);
if (qargs_retrieved) {
    // We should enter this branch.
    printf("Number of qargs: %lu\n", qargs_length);
} else {
    printf("Qargs are global\n");
}

Sécurité

Le comportement est indéfini si target n'est pas un pointeur valide et non nul vers un QkTarget. Le comportement est indéfini si each qargs_out ou ne qargs_len sont pas alignés et inscriptibles pour une seule valeur du type correct.

Paramètres

target - Un pointeur sur le site QkTarget.
op_idx – L'index auquel la porte est stockée.
qarg_idx – L'index dans lequel les qargs sont stockés.
qargs_out – Pointeur sortant vers un tableau de qubits. Si op_idx fait référence à une opération globale, un pointeur nul sera écrit. Le pointeur écrit est emprunté à la cible et ne doit pas être libéré. Une instruction zero-qargs écrira un pointeur non nul, mais invalide pour la lecture.
qargs_len – Pointeur sortant vers la longueur des qargs dans qargs_out. Si l'index est global, la longueur écrite n'est pas définie.

qk_target_op_props

void qk_target_op_props(const QkTarget *target, size_t op_idx, size_t qarg_idx, QkInstructionProperties *inst_props)

Récupérez les qargs pour l'opération stockée dans ses indices respectifs.

Panique si l'un des indices est hors limites.

Exemple

QkTarget *target = qk_target_new(5);

QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

QkInstructionProperties inst_props;
qk_target_op_props(target, 0, 0, &inst_props);

Sécurité

Le comportement est indéfini si target n'est pas un pointeur valide et non nul vers un QkTarget. Le comportement est indéfini si inst_props ne pointe pas vers une adresse de taille suffisante pour stocker QkInstructionProperties .

Paramètres

target - Un pointeur sur le site QkTarget.
op_idx – L'index dans lequel la porte est stockée.
qarg_idx – L'index dans lequel les qargs sont stockés.
inst_props – Pointeur permettant d'écrire QkInstructionProperties l'instance.

qk_target_op_get

void qk_target_op_get(const QkTarget *target, size_t index, QkTargetOp *out_op)

Récupère les informations relatives à une opération dans la cible via l'index. Si l'index n'est pas présent, cette fonction provoquera une panique. Vous pouvez vérifier le nombre QkTarget total d'instructions à l'aide de qk_target_num_instructions.

Exemple

QkTarget *target = qk_target_new(5);

QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

QkTargetOp op;
qk_target_op_get(target, 0, &op);

// Clean up after you're done
qk_target_op_clear(&op);

Sécurité

Le comportement est indéfini si target n'est pas un pointeur valide et non nul vers un QkTarget. Le comportement est indéfini si out_op ne pointe pas vers une adresse de taille suffisante pour stocker QkTargetOp .

Paramètres

target - Un pointeur sur le site QkTarget.
index – L'index dans lequel la porte est stockée.
out_op – Pointeur vers l'espace où QkTargetOp sera stocké.

qk_target_op_gate

QkGate qk_target_op_gate(const QkTarget *target, size_t index)

Tente de récupérer un QkGate en fonction de l'opération stockée dans un index. L'utilisateur est responsable de vérifier si cette opération est une porte dans la QkTarget via en utilisant qk_target_op_get. Sinon, cette fonction provoquera une panique.

Exemple

QkTarget *target = qk_target_new(5);

QkTargetEntry *entry = qk_target_entry_new(QkGate_CX);
uint32_t qargs[2] = {0, 1};
qk_target_entry_add_property(entry, qargs, 2, 0.0, 0.1);
qk_target_add_instruction(target, entry);

QkTargetOp op;
qk_target_op_get(target, 0, &op);

// Check if the operation is a gate;
if (op.op_type == QkOperationKind_Gate) {
    QkGate gate = qk_target_op_gate(target, 0);
    // Do something
}

// Clean up after you're done.
qk_target_op_clear(&op);

Sécurité

Le comportement est indéfini si le target pointeur est nul ou non aligné.

Paramètres

target – Pointeur vers Target l'instance.
index – L'index dans lequel se trouve l'opération.

Retours

L'énumération QkGate dans ledit index.

qk_target_op_clear

void qk_target_op_clear(QkTargetOp *op)

Efface l'objet QkTargetOp .

Sécurité

Le comportement sera indéfini si le pointeur est nul ou non aligné. Les données appartenant à un QkTargetOp proviennent de Rust et ne peuvent être libérées qu'à l'aide de cette fonction.

Paramètres

op – Le pointeur vers un QkTargetOp objet.

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.