Verwenden der Numerics-BibliothekUsing the Numerics library

ÜbersichtOverview

Die Numerics-Bibliothek besteht aus drei Komponenten.The Numerics library consists of three components

  1. Einfache ganzzahlige Arithmetik mit ganzzahligen addern und ComparatorenBasic integer arithmetic with integer adders and comparators
  2. Allgemeine ganzzahlige Funktionalität , die auf Grundlage der grundlegenden Funktionalität basiert. Es umfasst Multiplikation, Division, Inversion usw. für ganze Zahlen mit und ohne Vorzeichen.High-level integer functionality that is built on top of the basic functionality; it includes multiplication, division, inversion, etc. for signed and unsigned integers.
  3. Arithmetische Funktionalität mit festem Punkt mit Initialisierung mit festem Punkt, Addition, Multiplikation, gegenseitiger Auswertung, polynomgebung und Messung.Fixed-point arithmetic functionality with fixed-point initialization, addition, multiplication, reciprocal, polynomial evaluation, and measurement.

Auf alle diese Komponenten kann mit einer einzelnen-Anweisung zugegriffen werden open :All of these components can be accessed using a single open statement:

open Microsoft.Quantum.Arithmetic;

TypenTypes

Die Numerics-Bibliothek unterstützt die folgenden Typen:The numerics library supports the following types

  1. LittleEndian: Ein Qubit-Array qArr : Qubit[] , das eine Ganzzahl darstellt, wobei qArr[0] das unwichtigste Bit bezeichnet.LittleEndian: A qubit array qArr : Qubit[] that represents an integer where qArr[0] denotes the least significant bit.
  2. SignedLittleEndian: Identisch LittleEndian mit, mit der Ausnahme, dass es sich um eine ganze Zahl mit Vorzeichen handelt, die in zwei-SignedLittleEndian: Same as LittleEndian except that it represents a signed integer stored in two's complement.
  3. FixedPoint: Stellt eine reelle Zahl dar, die aus einem Qubit qArr2 : Qubit[] -Array und einer binären Punktposition besteht pos , die die Anzahl der binären Ziffern links vom binären Punkt zählt.FixedPoint: Represents a real number consisting of a qubit array qArr2 : Qubit[] and a binary point position pos, which counts the number of binary digits to the left of the binary point. qArr2wird auf die gleiche Weise wie gespeichert SignedLittleEndian .qArr2 is stored in the same way as SignedLittleEndian.

Operationen (Operations)Operations

Für jeden der drei oben genannten Typen stehen eine Vielzahl von Vorgängen zur Verfügung:For each of the three types above, a variety of operations is available:

  1. LittleEndian

    • AdditionAddition
    • VergleichComparison
    • MultiplikationMultiplication
    • QuadrierenSquaring
    • Division (mit Rest)Division (with remainder)
  2. SignedLittleEndian

    • AdditionAddition
    • VergleichComparison
    • Inversion von Modulo 2Inversion modulo 2's complement
    • MultiplikationMultiplication
    • QuadrierenSquaring
  3. FixedPoint

    • Vorbereitung/Initialisierung für klassische WertePreparation / initialization to a classical values
    • Addition (klassische Konstante oder andere Quantum-Fixpunkte)Addition (classical constant or other quantum fixed-point)
    • VergleichComparison
    • MultiplikationMultiplication
    • QuadrierenSquaring
    • Polynomial Evaluation with Spezialisierung for even and Odd FunctionsPolynomial evaluation with specialization for even and odd functions
    • Gegenseitige (1/x)Reciprocal (1/x)
    • Messung (klassisches Double)Measurement (classical Double)

Weitere Informationen und eine ausführliche Dokumentation zu den einzelnen Vorgängen finden Sie in der Referenz Dokumentation für die Q #-Bibliothek unter docs.Microsoft.com .For more information and detailed documentation for each of these operations, see the Q# library reference docs at docs.microsoft.com

Beispiel: Hinzufügen einer GanzzahlSample: Integer addition

Als einfaches Beispiel angenommen, der Vorgang ist $ $ \ket x\ket y\mapsto \ket x\ket {x + y} $ $, d. h. ein Vorgang, der eine n-Qubit-Ganzzahl $x $ und ein n-oder (n + 1)-Qubit-Register $y $ als Eingabe annimmt. letztere wird der Summe $ (x + y)As a basic example, consider the operation $$ \ket x\ket y\mapsto \ket x\ket{x+y} $$ that is, an operation that takes an n-qubit integer $x$ and an n- or (n+1)-qubit register $y$ as input, the latter of which it maps to the sum $(x+y)$. Beachten Sie, dass die Summe berechnet wird, Modulo $2 ^ n $, wenn $y $ in einem $n $-Bit-Register gespeichert wird.Note that the sum is computed modulo $2^n$ if $y$ is stored in an $n$-bit register.

Mit dem Quantum Development Kit kann dieser Vorgang wie folgt angewendet werden:Using the Quantum Development Kit, this operation can be applied as follows:

operation TestMyAddition(xValue : Int, yValue : Int, n : Int) : Unit {
    using ((xQubits, yQubits) = (Qubit[n], Qubit[n]))
    {
        let x = LittleEndian(xQubits); // define bit order
        let y = LittleEndian(yQubits);
        
        ApplyXorInPlace(xValue, x); // initialize values
        ApplyXorInPlace(yValue, y);
        
        AddI(x, y); // perform addition x+y into y
        
        // ... (use the result)
    }
}

Beispiel: Auswerten von Smooth FunctionsSample: Evaluating smooth functions

Zum Auswerten von Smooth-Funktionen wie z. b. $ \sin (x) $ auf einem Quantum-Computer, bei dem $x $ eine Quantum- FixedPoint Zahl ist, stellt die-Numerics-Bibliothek des Quantum Development Kits die Vorgänge EvaluatePolynomialFxP und bereit Evaluate[Even/Odd]PolynomialFxP .To evaluate smooth functions such as $\sin(x)$ on a quantum computer, where $x$ is a quantum FixedPoint number, the Quantum Development Kit numerics library provides the operations EvaluatePolynomialFxP and Evaluate[Even/Odd]PolynomialFxP.

Mit dem ersten, EvaluatePolynomialFxP , kann ein Polynoms der Form $ $ P (x) = a_0 + a_1x + a_2x ^ 2 + \cdots + a_dx ^ d, $ $ ausgewertet werden, wobei $d $ den Gradangibt.The first, EvaluatePolynomialFxP, allows to evaluate a polynomial of the form $$ P(x) = a_0 + a_1x + a_2x^2 + \cdots + a_dx^d, $$ where $d$ denotes the degree. Dazu benötigen Sie lediglich die Polynomen [a_0,..., a_d] (vom Typ Double[] ), die Eingabe x : FixedPoint und die Ausgabe y : FixedPoint (anfänglich NULL):To do so, all that is needed are the polynomial coefficients [a_0,..., a_d] (of type Double[]), the input x : FixedPoint and the output y : FixedPoint (initially zero):

EvaluatePolynomialFxP([1.0, 2.0], x, y);

Das Ergebnis, $P (x) = 1 + 2x $, wird in gespeichert yFxP .The result, $P(x)=1+2x$, will be stored in yFxP.

Die zweite, EvaluateEvenPolynomialFxP und der dritte, EvaluateOddPolynomialFxP , sind Spezialisierungs Fälle für die Fälle der geraden bzw. ungeraden Funktionen.The second, EvaluateEvenPolynomialFxP, and the third, EvaluateOddPolynomialFxP, are specializations for the cases of even and odd functions, respectively. Das heißt, bei einer geraden/ungeraden Funktion $f (x) $ und $ $ P_ {even} (x) = a_0 + A_1 x ^ 2 + a_2 x ^ 4 + \cdots + a_d x ^ {2D}, $ $ $f (x) $ ist für $P _ {even} (x) $ oder $P _ {Odd} (x): = x\cdot P_ {even} (x) $ gleich gut.That is, for an even/odd function $f(x)$ and $$ P_{even}(x)=a_0 + a_1 x^2 + a_2 x^4 + \cdots + a_d x^{2d}, $$ $f(x)$ is approximated well by $P_{even}(x)$ or $P_{odd}(x) := x\cdot P_{even}(x)$, respectively. In f # können diese beiden Fälle wie folgt behandelt werden:In Q#, these two cases can be handled as follows:

EvaluateEvenPolynomialFxP([1.0, 2.0], x, y);

wertet $P _ {even} (x) = 1 + 2x ^ 2 $ aus, undwhich evaluates $P_{even}(x) = 1 + 2x^2$, and

EvaluateOddPolynomialFxP([1.0, 2.0], x, y);

, der $P _ {Odd} (x) = x + 2X ^ 3 $ auswertet.which evaluates $P_{odd}(x) = x + 2x^3$.

Weitere BeispieleMore samples

Weitere Beispiele finden Sie im hauptbeispielrepository.You can find more samples in the main samples repository.

Klonen Sie zunächst das Repository, und öffnen Sie den Numerics Unterordner:To get started, clone the repo and open the Numerics subfolder:

git clone https://github.com/Microsoft/Quantum.git
cd Quantum/Numerics

cdIn einem der Beispiel Ordner, und führen Sie das Beispiel über aus.Then, cd into one of the sample folders and run the sample via

dotnet run