Arithmetic tools (jasp-compatible)

[diehoq]

This PR introduces a set of arithmetic utility functions for QuantumFloats

New Functions Added:

1. q_min – returns the minimum of two QuantumFloat values
2. q_max – returns the maximum of two QuantumFloat values
3. q_floor – computes the floor of a QuantumFloat
4. q_ceil – computes the ceiling of a QuantumFloat
5. q_fractional – extracts the fractional part of a QuantumFloat
6. q_round – rounds a QuantumFloat to the nearest integer
7. q_modf – splits a QuantumFloat into integer and fractional components

Additional Updates:

Comprehensive documentation for each new function
Corresponding unit tests

[positr0nium]

By using duplicate, you create a QuantumFloat that could potentially have non-integer values. The result of floor can however be an integer only. I guess it depends on the usecase whether this is unnecessary. What do you think @renezander90 @cjn10?

[diehoq]

I've thought about this and I think that, since the operation is out of place and the initial variable still exists, it makes more sense to preserve the same structure in the output variable in order to allow operations between them.

[positr0nium]

I think this can be made a bit more robust :)

res_mshape = [jnp.minimum(a.mshape[0], b.mshape[0]), jnp.maximum(a.mshape[1], b.mshape[1])]
new_msize = res_mshape[1] - res_mshape[0]
new_exponent = res_mshape[0]
res = QuantumFloat(new_msize, new_exponent)

[renezander90]

Yes :) This will now work for QuantumFloats of different shape. (But, not yet for signed.)

Could work for signed with:

res = QuantumFloat(new_msize, new_exponent, signed=a.signed | b.signed)

[positr0nium]

Same here as in q_max

[positr0nium]

This might be more efficient like this:

cx(a, res)

with conjugate(cx)(a,b):
    with control(c, 0):
        cx(b, res)

[renezander90]

But, this wouldn't work if an and b have different shape. With the proposed changes from above, this should work for QuantumFloats of different shape:

    with control(c):
        for i in jrange(a.size):
            cx(a[i], res[i + a.exponent - new_exponent])
    with control(c, 0):
        for i in jrange(b.size):
            cx(b[i], res[i + b.exponent - new_exponent])

[positr0nium]

The efficient approach should work on the digits where a and b overlap. On the disjoint digits, the straightforward way has to be employed.

[diehoq]

The extreme cases of the approach you suggest - no overlap and maximal overlap - will lead to a situation in which the cx is called with two empty lists of qubits. In this case the cx should not be appended to the circuit, but as of now this behaviour is simply not allowed.

[positr0nium]

Might be more elegant and give an in-built custom control to do this via conjugation

[positr0nium]

Nice work! Added a few comments within the changed files :) Thanks