XInt x is the type of fixed-length integers, but using elements of type x instead of bits. It is an abstract type, and details of its implementation is not exposed to user-level code.

The type of fixed-length m-qubit quantum integers. This is a circuit execution time value.

The type of fixed-length m-bit classical integer inputs. This is a circuit execution time value.

The type of fixed-length m-bit integer parameters. Values of this type are parameters, i.e., they are classical and known at circuit generation time.

Unlike values of type QDInt and CInt, a value of type IntM may have an indeterminate length. This happens, for example, if the value is specified by means of an integer literal (e.g., 17), which does not carry length information. In such cases, the value can only be used when it can be deduced from the context. For example, such values may be used for terminating or controlling a QDInt, but not for initializing a QDInt.

Convert a QDInt to a list of qubits. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Convert a list of qubits to a QDInt. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Convert a QDInt to a list of qubits. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Convert a list of qubits to a QDInt. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Return the length of a QDInt, in bits.

Extend a QDInt to the given length without changing its (unsigned) value. This is done by adding the required number of high bits initialized to 0. It is an error to call this function when the new length is shorter than the old one.

Extend a QDInt to the given length without changing its (signed) value. This is done by adding the required number of high bits initialized to copies of the sign bit. It is an error to call this function when the new length is shorter than the old one.

Convert a CInt to a list of qubits. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Convert a list of qubits to a CInt. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Convert a CInt to a list of bits. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Convert a list of bits to a CInt. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Return the length of a CInt, in bits.

Extend a CInt to the given length without changing its (unsigned) value. This is done by adding the required number of high bits initialized to 0. It is an error to call this function when the new length is shorter than the old one.

Extend a CInt to the given length without changing its (signed) value. This is done by adding the required number of high bits initialized to copies of the sign bit. It is an error to call this function when the new length is shorter than the old one.

Convert an IntM to a list of booleans. The conversion is big-headian, i.e., the head of the list holds the most significant digit. As usual, False is 0 and True is 1. It is an error to apply this operation to an IntM whose length is indeterminate.

Convert a boolean list to an IntM. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Return the size of an IntM, or Nothing if indeterminate.

Convert an IntM of length m to an Integer in the range {0, …, 2^m-1}. If the IntM has indeterminate length, return the original Integer.

Convert an IntM of length m to an Integer in the range {-2^m-1, …, 2^m-1-1}. If the IntM has indeterminate length, return the original Integer.

Create an IntM of the given length and value. Leave the length indeterminate if it is given as Nothing.

Create an IntM of indeterminate length from an Integer.

Create an IntM of the specified length (first argument) and value (second argument).

Try to set the length of an IntM to that of another XInt value (which could be a QDInt, a CInt, or another IntM). This will fail with an error if both numbers already have determinate lengths that don't coincide. In this case, the string argument is used as an error message.

Return the interval [x..y], with x and y regarded as signed values of type IntM.

Return the interval [x..y], with x and y regarded as unsigned values of type IntM.

Extend an IntM to the given length without changing its (unsigned) value. This is done by adding the required number of high bits initialized to 0. It is an error to call this function when the new length is shorter than the old one.

Extend an IntM to the given length without changing its (signed) value. This is done by adding the required number of high bits initialized to copies of the sign bit. It is an error to call this function when the new length is shorter than the old one.

Return a piece of shape data to represent an m-qubit quantum integer. Please note that the data can only be used as shape; it will be undefined at the leaves.

Return a piece of shape data to represent an m-bit CInt. Please note that the data can only be used as shape; it will be undefined at the leaves.

Return the size of a XInt, or Nothing if indeterminate.

From a XInt, which must be of determinate length, extract a list of xs. The conversion is big-headian, i.e., the head of the list holds the most significant digit. It is an error to call this function with an XInt of indeterminate length.

Create a XInt x from a list of xs. The conversion is big-headian, i.e., the head of the list holds the most significant digit.

Convert an integer to a bit list. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Convert a bit list to an integer. The conversion is little-headian, i.e., the head of the list holds the least significant digit.

Quantum analogue of Haskell’s Num type class. This provides basic addition, subtraction, multiplication, sign operations, and conversion from integers.

Increment a QDInt in place. O(ℓ) gates.

Implementation note: currently tries to minimize gate count, at the cost of a rather long Quipper description. Can the latter be reduced without increasing the former?

Decrement a QDInt in place. Inverse of q_increment. O(ℓ).

Add one QDInt onto a second, in place; i.e. (x,y) ↦ (x,x+y). Arguments are assumed to be of equal size. O(ℓ) gates.

Subtract one QDInt from a second, in place; i.e. (x,y) ↦ (x,y–x). Arguments are assumed to be of equal size. O(ℓ) gates.

Negate a (signed) QDInt in place. O(ℓ).

Add a parameter IntM and a QDInt, into a fresh QDInt: (x, y) ↦ (y, x+y). The parameter x must be of the same length as y, or x can also be of undetermined length. O(ℓ).

Subtract a parameter IntM from a QDInt, into a fresh QDInt. The IntM cannot be shorter than the QDInt (that would give ill-defined behavior), but can be of undetermined length. O(ℓ).

Add a parameter IntM onto a QDInt, in place; i.e. (x,y) ↦ x+y. The parameter x must be of the same length as y, or x can also be of undetermined length. O(ℓ).

Subtract a parameter IntM from a QDInt, in place; i.e. (x,y) ↦ (x,x-y). x cannot be shorter than y. O(l) gates.

Multiply a parameter IntM by a QDInt, into a fresh QDInt. The IntM cannot be shorter than the QDInt (that would give ill-defined behavior), but can be of undetermined length. O(ℓ).

Comparison of two QDInts, considered as unsigned. O(ℓ).

Comparison of two QDInts, considered as signed. Used in instance QOrd QDInt. O(ℓ).

Comparison of two QDInts, considered as signed. Used in instance QOrd QDInt. O(ℓ).

Text whether a QDInt is nonnegative. O(1)

Reduce one QDInt modulo another, in place, returning also the integer quotient, i.e. (x, y) ↦ (x mod y, y, x div y). All inputs and outputs are considered unsigned. Inputs are assumed to have the same length. Division by zero returns (x,0,-1).

O(ℓ²) gates, O(ℓ) qubits.

Reduce one QDInt modulo another, i.e. (x, y) ↦ (x, y, x mod y). All inputs and outputs are considered unsigned. Inputs are assumed to have the same length. If y = 0, returns (x,0,x).

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts, returning the quotient and remainder, i.e. (x,y) ↦ (x,y,x div y,x mod y). All inputs and outputs are considered unsigned. Inputs are assumed to have the same length. Division by zero returns (-1,x).

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts, returning just the quotient. All inputs/outputs considered unsigned. Inputs are assumed to have the same length. Division by zero returns –1.

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts into a fresh third, rounding towards –∞. The first argument is the numerator, and is assumed to be signed. The second argument is the denominator, and is assumed to be unsigned. The output is signed. Inputs are assumed to have the same length.

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts into a fresh third, rounding towards 0. The first argument is the numerator, and is assumed to be signed. The second argument is the denominator, and is assumed to be unsigned. The output is signed. Inputs are assumed to have the same length.

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts, returning the quotient, assuming that the second exactly divides the first and throwing an error otherwise. All inputs/outputs considered unsigned. Inputs are assumed to have the same length.

O(ℓ²) gates, O(ℓ) qubits.

Integer division of two QDInts, returning the quotient, assuming that the second exactly divides the first. The first argument is the numerator, considered signed. The second argument is the denominator, considered unsigned. The output is signed.

O(ℓ²) gates, O(ℓ) qubits.

Euclid's extended algorithm. q_ext_euclid a b: returns (a,b,x,y,d) such that ax + by = d = gcd(a,b).

Quantum lifting of the + operator.