Structure du code
Le language Q# est compatible avec le paradigme de programmation fonctionnel. En effet la programmation quantique n'est pas utilisée pour élaborer des systèmes informatiques complet comme des solutions web ou mobile. La programmation quantique est utilisée pour exploiter les avantages des calculateurs quantiques et des algorithmes quantiques.
Elle utilise tout de même des notions de la programmation objet comme on a pu le voir dans le précedent article avec l'utilisation de types, et de variables.
Cependant on peut noter l'absence de l'utilisation de classes comme on a l'habitude d'en créer en programmation objet. Les objets en Q# sont simplement des instances d'un type particulier.
Écrire un code en Q#, c'est écrire un ensemble de méthode statiques (voir la partie Méthode et Fonctions de mon précédent article) dans lequel on peut combiner du code quantique et classique comme bon nous semble.
En passant en revue comment un code Q# est structuré, on se rend compte qu'il y a beacoup de similitudes entre Q# et les langages classiques. Voyons ensemble les similitues qu'on peut trouver chez Q#.
Les points similaires avec les languages classiques
Structures de contrôle
Comme dans tous les langages de programmation il existe 3 façons principales de contrôler le flux du code. Il ya les instructions if, les boucles for et les boucles repeat-until (qui sont semblables aux boucles do-while). Voici des exemples tirés du site *stem.mitre.org*
if
if someBool
{
// Do something
}
elif someOtherBool
{
// Do something else
}
else
{
// Do a third thing
}
boucles for
let length = Length(intArray);
for i in 0..length - 1
{
// Do something with i
}
boucles qui parcour un tableau
let length = Length(intArray);
for i in 0..length - 1
{
// Do something with i
}
Manipualtion des variables
D'abord Q# est un language qui fait la distinction entre les variables mutables et immuables. Autrement dit les variables qui peuvent être modifiée après sa définition et les variables qui ne peuvent pas l'être. On retrouve cette particularité dans d'autre language de programmation comme kotlin, swift ou Rust.
On définit une variable immuable avec le mot clé let de la manière qui suit :
let var1 = 0;
On définit une variable mutable avec le mot mutable de la manière qui suit :
mutable var2 = "hello world";
Les deux exemples montrent comment on différencie une variable immuable d'une variable mutable, mais souligne aussi que le typage peut être assigné par inférence. C'st à dire que le compilateur peut deviner de manière logique le type d'une variable sans qu'on ait à le préciser.
En effet, ici var1 va être considéré comme un Int par défaut quand le compilateur va voir la valeur qui lui est assigné (ici 0). Var2 lui va être considéré comme un String.
Si on veut modifier une variable mutable au cours du programme, il suffit d'utiliser le mot clé *set* comme le montre l'exemple qui suit :
set var2 = $"var1 = {IntAsString(var1)}";
Autres similitudes
Q# comme d'autre language classique peut supporter les tuple et les arrays. Les tuples permettent de contenir plusieurs objets différents. On les utilise pour regrouper des valeurs dans une seule variable ou pour retourner plusieurs éléments d'une opération.
Les Arrays en Q# fonctionnent de la même manière que dans les autres languages.
Porte Quantique à Qubit unique
Dans la programmation quantique on suit un modèle dit *circuit quantique*. Un circuit quantique est une représentation graphique d'une série d'opérations quantiques appliquées à un ensemble de qubit.
En développant des codes quantiques, on joue avec ce qu'on appelle des portes quantique. Une porte quantique est l'équivalent dans l'informatique quantique d'une opération logique dans l'informatique classique. Les portes quantiques sont des opérations unitaires qui agissent sur les qubits. Chaque porte quantique effectue une transformation unitaire sur l'état des qubits sur lesquels elle agit. Les portes quantiques sont essentielles pour réaliser des calculs quantiques et manipuler l'information quantique de manière contrôlée. Les portes sont utilisées pour construire des algorithmes quantiques et réaliser des opérations de traitement de l'information quantique.
Les portes quantiques en Q# prennent alors la forme d'opérations qui vont prendre un qubit en argument. Par exemple en appelant une opération X qui prend le qubit qubit en paramètre de cette manière: X(qubit);
On va dire que la porte quantique X est appliquée au qubit spécifié.
note : on mesure un qubit avec l'opération M. Par exemple :
let mesureQubit = M(qubit);
Allouer des Qubits
Q# nous aide merveilleusement bien à gérer les qubit. On a pas à se soucier de la gestion manuelle des allocations et la libération des qubits. On a juste à utiliser l'instruction use pour obtenir un qubit quand on en a besoin.
Lorsqu'on utilise l'instruction use, Q# s'occupe automatiquement de l'allocation d'un qubit disponible pour nous. Nous n'avons pas à nous soucier de savoir quels qubits sont déjà utilisés ou disponibles. Q# gère tout cela pour vous en arrière-plan.
Voici comment utiliser l'instruction use :
use(qubit = Qubit())
{
// Do something with the qubit
Reset(qubit);
}
tant qu'on est à l'intérieur du bloc using, le qubit alloué reste disponible pour notre usage. On peut effectuer des opérations sur ce qubit et même le passer en tant qu'argument à d'autres opérations sans se préoccuper de la destruction du qubit.En effet, une fois que vous sortez de la portée du bloc using, le qubit est automatiquement libéré, ce qui signifie qu'il est prêt à être réutilisé pour d'autres calculs quantiques.
Conclusion
Pour résumer cette deuxième partie, Q# repose sur un paradigme de programmation fonctionnel. C'est un language dans lequel on peut trouver beaucoup de poonts commun avec les languages classiques. Ce qui permet de coupler la programmmation quantique et classique.
On a vu dans cette deuxième partie de l'apprentissage de la synthaxe comment manipuler les variables, cmment marchaient les structures de contrôle et surtout on a découvert le principe de porte quantiques, et comment fonctionnait la gestion de l'allocation des Qubits.
L'objectif pour le prochain article, c'est de comprendre tous algorithmes proposés par azure Quantum.
Ressources
Intro to Q#, https://stem.mitre.org/quantum/software-tools/intro-qsharp.html#arrays (Page consultée le 15 mars 2024)
Commentaires