Boucles conditionnelles

Comme la plupart des langages de programmation classiques, Q# prend en charge les boucles qui s’interrompent en fonction d’une condition : les boucles pour lesquelles le nombre d’itérations est inconnu et peut varier d’une exécution à l’autre. Comme la séquence d’instructions est inconnue au moment de la compilation, le compilateur traite ces boucles conditionnelles d’une manière particulière dans un runtime quantique.

Important

Restrictions matérielles quantiques

Les boucles qui s’arrêtent en fonction d’une condition sont difficiles à traiter sur du matériel quantique si la condition dépend des résultats de mesure, car la longueur de la séquence d’instructions à exécuter n’est pas connue à l’avance.

Malgré leur présence fréquente dans certaines classes d’algorithmes quantiques, le matériel actuel ne fournit pas encore de prise en charge native pour ces types de constructions de flux de contrôle. L’exécution de ces types de boucles sur du matériel quantique peut potentiellement être prise en charge à l’avenir en imposant un nombre maximal d’itérations, ou à mesure que la prise en charge matérielle supplémentaire devient disponible. Toutefois, les simulateurs quantiques exécutent toutes les boucles basées sur des mesures.

Compilation de boucles

Tant que la condition ne dépend pas des mesures quantiques, les boucles conditionnelles sont traitées avec une compilation juste-à-temps avant l’envoi de la séquence d’instructions au processeur quantique. En particulier, l’utilisation des boucles conditionnelles au sein des fonctions ne pose aucun problème puisque le code au sein des fonctions peut toujours être exécuté sur du matériel conventionnel (non quantique). Q#, prend donc en charge l’utilisation de boucles traditionnelles while dans les fonctions.

Répéter l’expression

Lorsque vous exécutez des programmes sur des simulateurs quantiques, Q# vous permet d’exprimer un flux de contrôle qui dépend des résultats des mesures quantiques. Cette capacité permet des implémentations probabilistes susceptibles de réduire considérablement les coûts de calcul. Un exemple courant est le modèle de répétition jusqu’à réussite, qui répète un calcul jusqu’à ce qu’une certaine condition (dépendant généralement d’une mesure) soit satisfaite. De telles boucles repeat sont largement utilisées dans des classes particulières d’algorithmes quantiques. Q# dispose donc d’une construction de langage dédiée pour les exprimer, bien que leur exécution constitue toujours un défi sur le matériel quantique.

L’expression repeat prend la forme suivante

repeat {
    // ...
}
until condition
fixup {
    // ...
}

ou encore

repeat {
    // ...
}
until condition;

où condition est une expression arbitraire de type Bool.

La repeat boucle exécute un bloc d’instructions avant d’évaluer une condition. Si la condition a la valeur true, la boucle existe. Si la condition a la valeur false, un bloc supplémentaire d’instructions défini dans le cadre d’un bloc fixup facultatif, s’il est présent, est exécuté avant d’entrer dans l’itération de boucle suivante.

Boucle while

Une boucle plus familière pour les calculs classiques est la while boucle, qui se compose de la mot clé while, d’une expression de type Boolet d’un bloc d’instructions. Par exemple, si arr est un tableau d’entiers positifs,

mutable (item, index) = (-1, 0);
while index < Length(arr) && item < 0 {
    set item = arr[index];
    set index += 1;
}

Le bloc d’instructions est exécuté tant que la condition a la valeur true.