Usando a biblioteca numéricaUsing the Numerics library

Descrição geralOverview

A biblioteca numérica é composta por três componentesThe Numerics library consists of three components

  1. Aritmética de inteiros básicos com suplementos inteiros e comparadoresBasic integer arithmetic with integer adders and comparators
  2. Funcionalidade de número inteiro de alto nível que é construída em cima da funcionalidade básica; inclui multiplicação, divisão, inversão, etc. para inteiros assinados e não assinados.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. Funcionalidade aritmética de ponto fixo com inicialização de ponto fixo, adição, multiplicação, avaliação recíproca, polinomial e medição.Fixed-point arithmetic functionality with fixed-point initialization, addition, multiplication, reciprocal, polynomial evaluation, and measurement.

Todos estes componentes podem ser acedidos através de uma única open declaração:All of these components can be accessed using a single open statement:

open Microsoft.Quantum.Arithmetic;

TiposTypes

A biblioteca numérica suporta os seguintes tiposThe numerics library supports the following types

  1. LittleEndian: Uma matriz qubit qArr : Qubit[] que representa um número inteiro onde qArr[0] denota a parte menos significativa.LittleEndian: A qubit array qArr : Qubit[] that represents an integer where qArr[0] denotes the least significant bit.
  2. SignedLittleEndian: O mesmo LittleEndian que representa um número inteiro assinado armazenado no complemento de dois.SignedLittleEndian: Same as LittleEndian except that it represents a signed integer stored in two's complement.
  3. FixedPoint: Representa um número real constituído por uma matriz de qubit qArr2 : Qubit[] e uma posição de ponto pos binário, que conta o número de dígitos binários à esquerda do ponto binário.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. qArr2 é armazenado da mesma forma que SignedLittleEndian . .qArr2 is stored in the same way as SignedLittleEndian.

OperaçõesOperations

Para cada um dos três tipos acima, está disponível uma variedade de operações:For each of the three types above, a variety of operations is available:

  1. LittleEndian

    • AdiçãoAddition
    • ComparaçãoComparison
    • MultiplicaçãoMultiplication
    • EsquartejarSquaring
    • Divisão (com o restante)Division (with remainder)
  2. SignedLittleEndian

    • AdiçãoAddition
    • ComparaçãoComparison
    • Complemento de inversão modulo 2Inversion modulo 2's complement
    • MultiplicaçãoMultiplication
    • EsquartejarSquaring
  3. FixedPoint

    • Preparação/ inicialização a valores clássicosPreparation / initialization to a classical values
    • Adição (constante clássica ou outro ponto fixo quântico)Addition (classical constant or other quantum fixed-point)
    • ComparaçãoComparison
    • MultiplicaçãoMultiplication
    • EsquartejarSquaring
    • Avaliação polinomial com especialização para funções par e ímparesPolynomial evaluation with specialization for even and odd functions
    • Recíproco (1/x)Reciprocal (1/x)
    • Medição (duplo clássico)Measurement (classical Double)

Para obter mais informações e documentação detalhada para cada uma destas operações, consulte os documentos de referência da Q# biblioteca em docs.microsoft.comFor more information and detailed documentation for each of these operations, see the Q# library reference docs at docs.microsoft.com

Amostra: Adição de inteirosSample: Integer addition

Como exemplo básico, considere a operação $$ \ket x\ket y\mapsto \ket x\ket{x+y} $00, isto é, uma operação que leva um número inteiro n-qubit $x$ e um registo n-ou (n+1)-qubit $y$ como entrada, a última das quais mapeia para a soma $(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)$. Note que a soma é computada modulo $2^n$ se $y$ for armazenado num registo de $n de $-bit.Note that the sum is computed modulo $2^n$ if $y$ is stored in an $n$-bit register.

Utilizando o Kit de Desenvolvimento Quântico, esta operação pode ser aplicada da seguinte forma: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)
    }
}

Amostra: Avaliação de funções suavesSample: Evaluating smooth functions

Para avaliar funções suaves como $\sin (x)$ num computador quântico, onde $x$ é um número quântico, FixedPoint a biblioteca numérica do Kit de Desenvolvimento Quântico fornece as operações EvaluatePolynomialFxP e 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.

O primeiro, EvaluatePolynomialFxP permite avaliar um polinómio do formulário $$ P(x) = a_0 + a_1x + a_2x^2 + \cdots + a_dx^d, $$ onde $d$ denota o grau.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. Para tal, tudo o que é necessário são os coeficientes polinómicos [a_0,..., a_d] (do Double[] tipo), a entrada x : FixedPoint e a saída y : FixedPoint (inicialmente zero):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);

O resultado, $P(x)=1+2x$, será armazenado em yFxP .The result, $P(x)=1+2x$, will be stored in yFxP.

A segunda, EvaluateEvenPolynomialFxP e a EvaluateOddPolynomialFxP terceira, são especializações para os casos de funções par e ímpares, respectivamente.The second, EvaluateEvenPolynomialFxP, and the third, EvaluateOddPolynomialFxP, are specializations for the cases of even and odd functions, respectively. Isto é, para uma função par/ímpar $f(x)$ e $$ P_{even}(x)=a_0 + a_1 x^2 + a_2 x^4 + \cdots + a_d x^{2d}, $$ $f(x)$ é aproximadamente bem por $P_{even}(x)$ ou $P_{odd}(x) := x\cdot P_{even}(x)$, respectivamente.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. Em Q# , estes dois casos podem ser tratados da seguinte forma:In Q#, these two cases can be handled as follows:

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

que avalia $P_{even}(x) = 1 + 2x^2$, ewhich evaluates $P_{even}(x) = 1 + 2x^2$, and

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

que avalia $P_{odd}(x) = x + 2x^3$.which evaluates $P_{odd}(x) = x + 2x^3$.

Mais exemplosMore samples

Pode encontrar mais amostras no repositório principal de amostras.You can find more samples in the main samples repository.

Para começar, clone o repo e abra a Numerics sub-página:To get started, clone the repo and open the Numerics subfolder:

git clone https://github.com/Microsoft/Quantum.git
cd Quantum/samples/numerics

Em seguida, cd em uma das pastas de amostra e executar a amostra atravésThen, cd into one of the sample folders and run the sample via

dotnet run