Expressions classiques

L'API C de Qiskit pour les expressions classiques offre des fonctionnalités permettant d'inspecter les expressions classiques utilisées dans Qiskit. Cette API permet aux utilisateurs de parcourir et d'examiner des arbres d'expressions à l'aide d'un ensemble d'énumérations, de structures et de fonctions d'accès. Vous pouvez examiner la structure des expressions, identifier les types de nœuds, consulter les informations relatives aux types et accéder aux propriétés détaillées de chaque nœud de l'arborescence d'expressions. À l'heure actuelle, les expressions classiques ne sont accessibles que via l'API de contrôle de flux, par exemple lors de l'interrogation de conditions composées d'expressions classiques.

Notez que les fonctions de cette API renvoient des pointeurs empruntés qui restent valides tant que l'arbre d'expression parent existe; il n'est donc pas nécessaire de libérer ces pointeurs.

Types de données

QkExprNodeKind

enum QkExprNodeKind

Les différents types de nœuds d'expression pouvant apparaître dans un arbre d'expression classique.

Valeurs :

QkExprNodeKind_Unary de l'enquêteur

Expression d'opération unaire (par exemple, NOT, négation)

QkExprNodeKind_Binary de l'enquêteur

Expression comportant des opérations binaires (par exemple, AND, OR, opérations arithmétiques)

QkExprNodeKind_Cast de l'enquêteur

Expression de conversion de type

QkExprNodeKind_Value de l'enquêteur

Expression de valeur littérale

QkExprNodeKind_Var de l'enquêteur

Expression de référence variable

QkExprNodeKind_Stretch de l'enquêteur

Expression étirée (liée au tempo)

QkExprNodeKind_Index de l'enquêteur

Expression avec indice/sous-indice

QkExprType

enum QkExprType

Les types de données pouvant être utilisés dans les expressions classiques.

Valeurs :

QkExprType_Bool de l'enquêteur

Type booléen

QkExprType_Duration de l'enquêteur

Type de durée

QkExprType_Float de l'enquêteur

Type à virgule flottante

QkExprType_Uint de l'enquêteur

Type entier non signé

QkExprTypeInfo

struct QkExprTypeInfo

La représentation complète du type de données utilisé pour une expression.

QkExprType ty

Le type d'expression

uint32_t largeur

Nombre de bits pour le type d'expression Uint

QkUnaryOpType

enum QkUnaryOpType

Les types d'opérations qu'une expression unaire peut contenir. Les valeurs commencent à 1 afin de respecter la convention « Python » du système d'expression classique.

Valeurs :

QkUnaryOpType_BitNot de l'enquêteur

Opération de NON bit à bit

QkUnaryOpType_LogicNot de l'enquêteur

Opération logique NON

QkUnaryOpType_Negate de l'enquêteur

Négation arithmétique

QkUnaryExprInfo

struct QkUnaryExprInfo

Décrit une expression unaire, en précisant son opérateur, son opérande, le type du résultat et si elle est une constante. Renvoyé par la qk_expr_unary_info fonction. Le operand champ est un pointeur emprunté vers l'opérande de l'expression d'opération unaire.

QkUnaryOpType op

L'opérateur unaire

const QkExprNode *opérande

Pointeur emprunté vers l'expression opérande

QkExprTypeInfo ty

Type de résultat de l'opération

constante de type booléen

Que l'expression soit constante

QkBinaryOpType

enum QkBinaryOpType

Les types d'opérations qu'une expression binaire peut contenir. Les valeurs commencent à 1, conformément à la convention d' Python.

Valeurs :

QkBinaryOpType_BitAnd de l'enquêteur

Opération de ET binaire

QkBinaryOpType_BitOr de l'enquêteur

Opération de OU bit à bit

QkBinaryOpType_BitXor de recenseur

Opération XOR bit à bit

QkBinaryOpType_LogicAnd de l'enquêteur

Opération logique ET

QkBinaryOpType_LogicOr de l'enquêteur

Opération logique OU

QkBinaryOpType_Equal de l'enquêteur

Comparaison des égalités

QkBinaryOpType_NotEqual de l'enquêteur

Comparaison des inégalités

QkBinaryOpType_Less de l'enquêteur

Moins que la comparaison

QkBinaryOpType_LessEqual de l'enquêteur

Comparaison « inférieur ou égal à »

QkBinaryOpType_Greater de l'enquêteur

Supérieur à la comparaison

QkBinaryOpType_GreaterEqual de l'enquêteur

Comparaison « supérieur ou égal à »

QkBinaryOpType_ShiftLeft de l'enquêteur

Opération de décalage vers la gauche

QkBinaryOpType_ShiftRight de l'enquêteur

Opération de décalage vers la droite

QkBinaryOpType_Add de l'enquêteur

Opération d'addition

QkBinaryOpType_Sub de l'enquêteur

Opération de soustraction

QkBinaryOpType_Mul de l'enquêteur

Opération de multiplication

QkBinaryOpType_Div de l'enquêteur

Opération de division

QkBinaryExprInfo

struct QkBinaryExprInfo

Décrit une expression binaire, notamment son opérateur, ses opérandes, le type de résultat et si elle est une constante. Renvoyé par la qk_expr_binary_info fonction. Les left champs et right sont des pointeurs empruntés vers les opérandes de l'expression d'opération binaire.

QkBinaryOpType op

L'opérateur binaire

const QkExprNode *left

Expression de pointeur emprunté vers l'opérande de gauche

const QkExprNode *right

Expression de pointeur emprunté vers l'opérande de droite

QkExprTypeInfo ty

Type de résultat de l'opération

constante de type booléen

Que l'expression soit constante

QkCastExprInfo

struct QkCastExprInfo

Décrit une expression de conversion, en précisant l'opérande, le type cible, s'il s'agit d'une conversion implicite et si elle est constante. Renvoyé par la qk_expr_cast_info fonction. Le operand champ est un pointeur emprunté vers l'opérande de l'expression de transtypage.

const QkExprNode *opérande

Pointeur emprunté vers l'expression opérande faisant l'objet d'un transtypage

QkExprTypeInfo ty

Type de cible de la transformation

bool implicite

Que la conversion soit implicite (automatique) ou explicite

constante de type booléen

Que l'expression soit constante

QkIndexExprInfo

struct QkIndexExprInfo

Décrit une expression d'index, en précisant la cible, l'index, le type de résultat et si elle est constante. Renvoyé par la qk_expr_index_info fonction. Les target champs et index sont des pointeurs empruntés vers la cible et l'index de l'expression d'opération d'indexation.

const QkExprNode *target

Pointeur emprunté vers l'expression cible en cours d'indexation

const QkExprNode *index

Pointeur emprunté vers l'expression d'index

QkExprTypeInfo ty

Type de résultat de l'opération d'indexation

constante de type booléen

Que l'expression soit constante

QkDurationType

enum QkDurationType

Représente les différentes unités de temps utilisées dans les expressions de durée.

Valeurs :

QkDurationType_Dt de recenseur

Unités de temps du système

QkDurationType_Ps de l'enquêteur

Picosecondes

QkDurationType_Ns de l'enquêteur

Nanosecondes

QkDurationType_Us de l'enquêteur

Microsecondes

QkDurationType_Ms de recenseur

Millisecondes

QkDurationType_S de l'enquêteur

Secondes

QkDurationValue syndicale

#include <types.h>

Une union permettant de stocker soit les unités de temps système (dt) sous forme d'entier, soit le temps réel sous forme de nombre à virgule flottante.

Cette union fait partie de la QkDurationInfo structure et ne doit pas être utilisée directement.

int64_t dt

QkDurationType_DtUnités de temps du système (actives lorsque ty est activé QkDurationInfo )

à un rythme accéléré

Valeur en temps réel (active pour tous les autres types de durée)

QkDurationInfo

struct QkDurationInfo

La représentation complète d'une valeur de durée.

Ce ty champ sert de critère permettant de déterminer quel champ de l'union value est actif.

Lorsqu'il est initialisé depuis le langage C, il incombe à l'utilisateur de s'assurer que :

Lorsque ty vaut QkDurationType_Dt, la durée est stockée sous forme d'entier dans value.dt.
Pour tous les autres types de durée, la durée est stockée sous forme de valeur à virgule flottante dans value.time.

QkDurationType ty

Le type d'unité de durée (critère de sélection pour l'union)

QkDurationValue valeur

La valeur de la durée

Fonctions

qk_expr_kind

QkExprNodeKind qk_expr_kind(const QkExprNode *expr)

Renvoie le type d'un nœud d'expression classique.

Exemple

QKExprNodeKind kind = qk_expr_kind(expr);

Sécurité

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

Paramètres

expr – Un pointeur vers le nœud d'expression à analyser.

Retours

L'énumération de type indiquant quelle variante expr d'expression concrète contient.

qk_expr_binary_info

QkBinaryExprInfo qk_expr_binary_info(const QkExprNode *expr)

Extraire des informations à partir d'un nœud d'expression binaire.

Génère une exception si expr ne pointe pas vers un nœud d'expression binaire.

Exemple

QkBinaryExprInfo info = qk_expr_binary_info(expr);
const QkExprNode *lhs = info.left;
const QkExprNode *rhs = info.right;

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression binaire.

Retours

Une QkBinaryExprInfo structure décrivant l'opérateur, les opérandes, le type du résultat et indiquant si l'expression est une constante.

qk_expr_unary_info

QkUnaryExprInfo qk_expr_unary_info(const QkExprNode *expr)

Extraire des informations à partir d'un nœud d'expression unaire.

Génère une erreur si expr ne pointe pas vers un nœud d'expression unaire.

Exemple

QkUnaryExprInfo info = qk_expr_unary_info(expr);
QkUnaryOpType op = info.op;

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression unaire.

Retours

Une QkUnaryExprInfo structure décrivant l'opérateur, l'opérande, le type du résultat et indiquant si l'expression est une constante.

qk_expr_cast_info

QkCastExprInfo qk_expr_cast_info(const QkExprNode *expr)

Extraire des informations à partir d'un nœud d'expression de conversion.

Génère une exception si expr ne pointe pas vers un nœud d'expression de conversion.

Exemple

QkCastExprInfo info = qk_expr_cast_info(expr);
const QkExprNode *operand = info.operand;

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression de conversion.

Retours

Une QkCastExprInfo structure décrivant l'opérande, le type de destination, si le transtypage est implicite et si l'expression est une constante.

qk_expr_index_info

QkIndexExprInfo qk_expr_index_info(const QkExprNode *expr)

Extraire des informations à partir d'un nœud d'expression d'index.

Génère une erreur si expr ne pointe pas vers un nœud d'expression d'index.

Exemple

QkIndexExprInfo info = qk_expr_index_info(expr);
const QkExprNode *target = info.target;
const QkExprNode *index = info.index;

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression d'index.

Retours

Une QkIndexExprInfo structure décrivant la cible indexée, l'expression d'index, le type de résultat et indiquant si l'expression est constante.

qk_expr_as_value

const QkValue *qk_expr_as_value(const QkExprNode *expr)

Renvoie une vue sur la valeur sous-jacente du nœud d'expression.

Génère une erreur si expr ne pointe pas vers un nœud d'expression de valeur.

Exemple

const QkValue *value = qk_expr_as_value(expr);

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression de valeur.

Retours

Un pointeur vers la valeur QkValue stockée à l'intérieur de expr.

qk_expr_as_var

const QkVar *qk_expr_as_var(const QkExprNode *expr)

Renvoie une vue sur la variable sous-jacente du nœud d'expression.

Génère une erreur si expr ne pointe pas vers un nœud d'expression variable.

Exemple

const QkVar *var = qk_expr_as_var(expr);

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression variable.

Retours

Un pointeur vers la valeur QkVar stockée à l'intérieur de expr.

qk_expr_as_stretch

const QkStretch *qk_expr_as_stretch(const QkExprNode *expr)

Renvoie une vue sur la partie sous-jacente du nœud d'expression.

Génère une erreur si expr ne pointe pas vers un nœud d'expression d'étirement.

Exemple

const QkStretch *stretch = qk_expr_as_stretch(expr);

Sécurité

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

Paramètres

expr – Un pointeur vers un nœud d'expression « stretch ».

Retours

Un pointeur vers la valeur QkStretch stockée à l'intérieur de expr.

qk_value_type_info

QkExprTypeInfo qk_value_type_info(const QkValue *value)

Renvoie les informations de type d'une valeur.

Exemple

QkExprTypeInfo type_info = qk_value_type_info(value);

Sécurité

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

Paramètres

valeur – Un pointeur vers l'élément QkValue à inspecter.

Retours

Une QkExprTypeInfo structure contenant les informations relatives au type de valeur.

qk_value_duration_info

QkDurationInfo qk_value_duration_info(const QkValue *value)

Extraire les informations structurées d'une valeur de durée.

Génère une erreur si value ne pointe pas vers une valeur de durée.

Exemple

QkDurationInfo info = qk_value_duration_info(value);

Sécurité

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

Paramètres

valeur – Un pointeur vers une valeur de durée.

Retours

Une QkDurationInfo structure contenant l'unité de durée et la valeur brute.

qk_value_float

double qk_value_float(const QkValue *value)

Extraire la valeur à virgule flottante d'un QkValue.

Génère une erreur si value ne pointe pas vers une valeur de type float.

Exemple

double raw = qk_value_float(value);

Sécurité

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

Paramètres

valeur – Un pointeur vers une valeur de type float.

Retours

La double valeur stockée dans value.

qk_value_uint

uint64_t qk_value_uint(const QkValue *value)

Extraire la valeur entière non signée d'un QkValue de type QkExprType_Uint.

Vous devriez utiliser qk_value_type_info pour vous assurer que la valeur tient dans uint64_t avant d'appeler cette fonction.

Génère une exception si value ne pointe pas vers une QkExprType_Uint valeur ou si l'entier stocké ne tient pas dans uint64_t.

Exemple

uint64_t raw = qk_value_uint(value);

Sécurité

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

Paramètres

value – Un pointeur vers une valeur de type uint.

Retours

La valeur entière convertie en uint64_t.

qk_value_bool

bool qk_value_bool(const QkValue *value)

Extraire la valeur d'un QkValue de type QkExprType_Bool.

Génère une exception si value ne pointe pas vers une valeur de type booléen.

Exemple

bool raw = qk_value_bool(value);

Sécurité

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

Paramètres

valeur – Un pointeur vers une valeur de type booléen.

Retours

true si la représentation en nombre entier stockée est différente de zéro, sinon false.

qk_var_name

char *qk_var_name(const QkVar *var)

Renvoie le nom d'une variable sous la forme d'une chaîne C nouvellement allouée.

Exemple

char *name = qk_var_name(var);
if (name != NULL) {
    // Use the name...
    qk_str_free(name);
}

Sécurité

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

Paramètres

var – Un pointeur vers la variable à analyser.

Retours

Une chaîne terminée par un caractère nul contenant le nom de la variable, ou NULL si var celle-ci fait référence à une variable non autonome (c'est-à-dire basée sur un bit classique ou un registre classique). La fonction appelante est propriétaire de la chaîne renvoyée et doit la libérer à l'aide de qk_str_free.

qk_var_type_info

QkExprTypeInfo qk_var_type_info(const QkVar *var)

Renvoie toutes les informations relatives au type d'une variable.

Génère une exception si var est un peu variable, ce qui n'est pas encore pris en charge par cette API.

Exemple

QkExprTypeInfo type_info = qk_var_type_info(var);

Sécurité

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

Paramètres

var – Un pointeur vers la variable à analyser.

Retours

Une QkExprTypeInfo structure contenant les informations relatives au type de la variable.

qk_stretch_name

char *qk_stretch_name(const QkStretch *stretch)

Renvoie le nom d'un segment.

Exemple

char *name = qk_stretch_name(stretch);
// Use the name...
qk_str_free(name);

Sécurité

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

Paramètres

stretch – Un pointeur vers le segment à analyser.

Retours

Une chaîne de caractères terminée par un caractère nul contenant le nom du tronçon. La fonction appelante est propriétaire de la chaîne renvoyée et doit la libérer à l'aide de qk_str_free.

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

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