# Using the Quantum Numerics library

## Overview

The Numerics library consists of three components

1. Basic integer arithmetic with integer adders and comparators
2. 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. Fixed-point arithmetic functionality with fixed-point initialization, addition, multiplication, reciprocal, polynomial evaluation, and measurement.

All of these components can be accessed using a single open statement:

open Microsoft.Quantum.Arithmetic;


## Types

The numerics library supports the following types

1. LittleEndian: A qubit array qArr : Qubit[] that represents an integer where qArr[0] denotes the least significant bit.
2. SignedLittleEndian: Same as LittleEndian except that it represents a signed integer stored in two's complement.
3. 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 is stored in the same way as SignedLittleEndian.

## Operations

For each of the three types above, a variety of operations is available:

1. LittleEndian

• Comparison
• Multiplication
• Squaring
• Division (with remainder)
2. SignedLittleEndian

• Comparison
• Inversion modulo 2's complement
• Multiplication
• Squaring
3. FixedPoint

• Preparation / initialization to a classical values
• Addition (classical constant or other quantum fixed-point)
• Comparison
• Multiplication
• Squaring
• Polynomial evaluation with specialization for even and odd functions
• Reciprocal (1/x)
• Measurement (classical Double)

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 that the sum is computed modulo $2^n$ if $y$ is stored in an $n$-bit register.

Using the Quantum Development Kit, this operation can be applied as follows:

operation TestMyAddition(xValue : Int, yValue : Int, n : Int) : Unit {
use (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);

// ... (use the result)

}


## Sample: Evaluating smooth functions

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.

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. 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);


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

The second, EvaluateEvenPolynomialFxP, and the third, EvaluateOddPolynomialFxP, are specializations for the cases of even and odd functions, respectively. 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 Q#, these two cases can be handled as follows:

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


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

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


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

## More samples

You can find more samples in the main samples repository.

To get started, clone the repo and open the Numerics subfolder:

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


Then, cd into one of the sample folders and run the sample via

dotnet run