Add analytic pulse function samplers

[taalexander]

Summary

Add analytic pulse sampler which convert an analytic pulse of signature:
def f(times: np.ndarray, *args, **kwargs) -> np.ndarray
to a discrete pulse:
def g(duration: int, *args, **kwargs) -> SamplePulse

These will be used to implement the discrete pulse library from analytic pulse functions.

Closes #1935.

Details and comments

Currently implemented samplers:

• left
• right
• midpoint

These are decorators that may be used like:

@pulse.samplers.left
def linear(x: np.ndarray, m: float, b: float) -> np.ndarray:
    """Linear test function
    Args:
        x: Input times.
        m: Slope.
        b: Intercept
    Returns:
        np.ndarray
    """
    return m*x+b

[nkanazawa1989]

Can you add name to sampler? just to have the same interface with functional_pulse.

[taalexander]

Since the sampler just returns a functional_pulse it already has the same interface as functional_pulse.

[ajavadia]

update documentation (n_times not defined anywhere)

[ajavadia]

seems like this function should be deleted.

[ajavadia]

can you help me understand this:

left_linear_pulse_fun = samplers.left(linear)
pulse = left_linear_pulse_fun(duration, m=m, b=b)

So linear is just a function (not a pulse yet). Why does it need to have the times argument, which is characteristic of a discrete pulse?

And then in the above, do we get an instance of a continuous pulse somewhere?

I may be a bit lost here but what benefit do decorators have over just something simple like pulse objects having methods

a_sample_pulse = a_continuous_pulse.sample(strategy='left')

[taalexander]

All samplers concern themselves with doing is taking a function whose input is a list of continuous times and outputting a function whose first input is a duration, and then wrapping with a FunctionalPulse. The times are characteristic of a continuous pulse and are an array of times to evaluate the continuous function with. Discrete pulses accept an integer duration. By sampling we now have an object that may be evaluated to return decorators.

The approach you suggest means having another type of Instruction class to handle. It makes plotting harder as well. I would like to go in this direction, in the long run, to support analytic pulses which have a duration and an underlying set of parameters (same parameters as parameterized circuits) that may then be sampled in the way you suggest to output a SamplePulse, or passed as an analytic pulse directly if supported by the backend.

WIth the current implementations samplers are used like

@pulse.sample.left
def linear(times, m, b):
    return m*times + b

duration = 10
m= 0.01
b = 0.0

sched += linear(duration, m, b)

[ajavadia]

Ok i'm fine moving forward. Tagged @kdk in case he has comments on the design, but I think we can also revisit later.