# discretize_stf

Graph.discretize_stf(stf, duration, segment_count, sample_count_per_segment=1, *, name=None)

Create a piecewise-constant function by discretizing a sampleable function.

Use this function to create a piecewise-constant approximation to a sampleable function (obtained, for example, by filtering an initial piecewise-constant function).

Parameters:
• stf (Stf) – The sampleable function $$v(t)$$ to discretize. The values of the function can have any shape. You can also provide a batch of functions, in which case the discretization is applied to each element of the batch.

• duration (float) – The duration $$\tau$$ over which discretization should be performed. The resulting piecewise-constant function has this duration.

• segment_count (int) – The number of segments $$N$$ in the resulting piecewise-constant function.

• sample_count_per_segment (int, optional) – The number of samples $$M$$ of the sampleable function to take when calculating the value of each segment in the discretization. Defaults to 1.

• name (str or None, optional) – The name of the node.

Returns:

The piecewise-constant function $$w(t)$$ obtained by discretizing the sampleable function (or batch of piecewise-constant functions, if you provided a batch of sampleable functions).

Return type:

Pwc

convolve_pwc

Create an Stf by convolving a Pwc with a kernel.

identity_stf

Create an Stf representing the identity function.

sample_stf

Sample an Stf at given times.

utils.filter_and_resample_pwc()

Filter a Pwc with a sinc filter and resample it.

Notes

The resulting function $$w(t)$$ is piecewise-constant with $$N$$ segments, meaning it has segment values $$\{w_n\}$$ such that $$w(t)=w_n$$ for $$t_{n-1}\leq t\leq t_n$$, where $$t_n= n \tau/N$$.

Each segment value $$w_n$$ is the average of samples of $$v(t)$$ at the midpoints of $$M$$ equally sized subsegments between $$t_{n-1}$$ and $$t_n$$:

$w_n = \frac{1}{M} \sum_{m=1}^M v\left(t_{n-1} + \left(m-\tfrac{1}{2}\right) \frac{\tau}{MN} \right).$

For more information on Stf nodes see the Working with time-dependent functions in Boulder Opal topic.

Examples

Create discretized Gaussian signal.

>>> times = graph.identity_stf()
>>> gaussian_signal = graph.exp(- (times - 5e-6) ** 2 / 2e-6 ** 2) / 2e-6
>>> discretized_gamma_signal = graph.discretize_stf(
...     stf=gaussian_signal, duration=10e-6, segment_count=256, name="gamma"
... )
>>> discretized_gamma_signal
<Pwc: name="gamma", operation_name="discretize_stf", value_shape=(), batch_shape=()>


Refer to the How to create dephasing and amplitude robust single-qubit gates user guide to find the example in context.