holobench 1.3.5__py3-none-any.whl → 1.23.0__py3-none-any.whl

bencher/example/example_workflow.py

@@ -1,189 +0,0 @@
-# pylint: disable=duplicate-code
-
-
-import numpy as np
-
-import bencher as bch
-
-
-class VolumeSample(bch.ParametrizedSweep):
-    """A class to represent a 3D point in space."""
-
-    x = bch.FloatSweep(
-        default=0, bounds=[-1.0, 1.0], doc="x coordinate of the sample volume", samples=9
-    )
-    y = bch.FloatSweep(
-        default=0, bounds=[-2.0, 2.0], doc="y coordinate of the sample volume", samples=10
-    )
-    z = bch.FloatSweep(
-        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=11
-    )
-
-    surf_x = bch.FloatSweep(
-        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=9
-    )
-
-    surf_y = bch.FloatSweep(
-        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=11
-    )
-
-
-class VolumeResult(bch.ParametrizedSweep):
-    """A class to represent the properties of a volume sample."""
-
-    # value = bch.ResultVar("ul", doc="The scalar value of the 3D volume field")
-    p1_dis = bch.ResultVar("m", direction=bch.OptDir.minimize, doc="The distance to p1")
-    p2_dis = bch.ResultVar("m", direction=bch.OptDir.minimize, doc="The distance to p2")
-    total_dis = bch.ResultVar(
-        "m", direction=bch.OptDir.minimize, doc="The total distance to all points"
-    )
-    surf_value = bch.ResultVar(
-        "ul", direction=bch.OptDir.maximize, doc="The scalar value of the 3D volume field"
-    )
-    # occupancy = bch.ResultVar("occupied", doc="If the value is > 0.5 this point is considered occupied")
-
-
-p1 = np.array([0.4, 0.6, 0.0])
-p2 = np.array([-0.8, -0.2, 0.0])
-surf_x_max = 0.5
-surf_y_max = -0.2
-
-
-def bench_fn(point: VolumeSample) -> VolumeResult:
-    """This function takes a 3D point as input and returns distance of that point to the origin.
-
-    Args:
-        point (VolumeSample): Sample point
-
-    Returns:
-        VolumeResult: Value at that point
-    """
-
-    cur_point = np.array([point.x, point.y, point.z])
-
-    output = VolumeResult()
-    output.p1_dis = np.linalg.norm(p1 - cur_point)
-    output.p2_dis = np.linalg.norm(p2 - cur_point)
-    output.total_dis = output.p1_dis + output.p2_dis
-
-    output.surf_value = output.total_dis + np.linalg.norm(
-        np.array(
-            [np.cos(point.surf_x - surf_x_max), 2 * np.cos(point.surf_y - surf_y_max), point.z]
-        )
-    )
-
-    return output
-
-
-def example_floats2D_workflow(run_cfg: bch.BenchRunCfg, bench: bch.Bench = None) -> bch.Bench:
-    """Example of how to perform a 3D floating point parameter sweep
-
-    Args:
-        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
-
-    Returns:
-        Bench: results of the parameter sweep
-    """
-    if bench is None:
-        bench = bch.Bench("Bencher_Example_Floats", bench_fn, VolumeSample)
-
-    # run_cfg.debug = False
-
-    res = bench.plot_sweep(
-        input_vars=[VolumeSample.param.x, VolumeSample.param.y],
-        result_vars=[
-            VolumeResult.param.total_dis,
-            VolumeResult.param.p1_dis,
-            VolumeResult.param.p2_dis,
-        ],
-        const_vars=[VolumeSample.param.z.with_const(0)],
-        title="Float 2D Example",
-        run_cfg=run_cfg,
-    )
-    recovered_p1 = res.get_optimal_vec(VolumeResult.param.p1_dis, res.bench_cfg.input_vars)
-    print(f"recovered p1: {recovered_p1}, distance: {np.linalg.norm(recovered_p1 - p1[:2])}")
-    # within tolerance of sampling
-    # assert np.linalg.norm(recovered_p1 - p1[:2]) < 0.15
-
-    recovered_p2 = res.get_optimal_vec(VolumeResult.param.p2_dis, res.bench_cfg.input_vars)
-    print(f"recovered p2: {recovered_p2} distance: {np.linalg.norm(recovered_p2 - p2[:2])}")
-    # within tolerance of sampling
-    # assert np.linalg.norm(recovered_p2 - p2[:2]) < 0.15
-
-    run_cfg.use_optuna = True
-    for rv in res.bench_cfg.result_vars:
-        bench.plot_sweep(
-            input_vars=[VolumeSample.param.surf_x, VolumeSample.param.surf_y],
-            result_vars=[
-                VolumeResult.param.surf_value,
-            ],
-            const_vars=res.get_optimal_inputs(rv, True),
-            title=f"Slice of 5D space for {rv.name}",
-            description="""This example shows how to sample 3 floating point variables and plot a 3D vector field of the results.""",
-            run_cfg=run_cfg,
-        )
-
-    return bench
-
-
-def example_floats3D_workflow(run_cfg: bch.BenchRunCfg, bench: bch.Bench = None) -> bch.Bench:
-    """Example of how to perform a 3D floating point parameter sweep
-
-    Args:
-        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
-
-    Returns:
-        Bench: results of the parameter sweep
-    """
-    if bench is None:
-        bench = bch.Bench("Bencher_Example_Floats", bench_fn, VolumeSample)
-
-    # run_cfg.debug = False
-
-    res = bench.plot_sweep(
-        input_vars=[VolumeSample.param.x, VolumeSample.param.y, VolumeSample.param.z],
-        result_vars=[
-            VolumeResult.param.total_dis,
-            VolumeResult.param.p1_dis,
-            VolumeResult.param.p2_dis,
-            # get_optimal_inputsm.occupancy,
-        ],
-        title="Float 3D Example",
-        description="""This example shows how to sample 3 floating point variables and plot a volumetric representation of the results.  The benchmark function returns the distance to the origin""",
-        post_description="Here you can see concentric shells as the value of the function increases with distance from the origin. The occupancy graph should show a sphere with radius=0.5",
-        run_cfg=run_cfg,
-    )
-
-    recovered_p1 = res.get_optimal_vec(VolumeResult.param.p1_dis, res.bench_cfg.input_vars)
-    print(f"recovered p1: {recovered_p1}, distance: {np.linalg.norm(recovered_p1 - p1)}")
-    # within tolerance of sampling
-    # assert np.linalg.norm(recovered_p1 - p1) < 0.15
-
-    recovered_p2 = res.get_optimal_vec(VolumeResult.param.p2_dis, res.bench_cfg.input_vars)
-    print(f"recovered p2: {recovered_p2} distance: {np.linalg.norm(recovered_p2 - p2)}")
-    # within tolerance of sampling
-    # assert np.linalg.norm(recovered_p2 - p2) < 0.15
-
-    run_cfg.use_optuna = True
-    for rv in res.bench_cfg.result_vars:
-        bench.plot_sweep(
-            input_vars=[VolumeSample.param.surf_x, VolumeSample.param.surf_y],
-            result_vars=[
-                VolumeResult.param.surf_value,
-            ],
-            const_vars=res.get_optimal_inputs(rv, True),
-            title=f"Slice of 5D space for {rv.name}",
-            description="""This example shows how to sample 3 floating point variables and plot a 3D vector field of the results.""",
-            run_cfg=run_cfg,
-        )
-
-    return bench
-
-
-if __name__ == "__main__":
-    ex_run_cfg = bch.BenchRunCfg()
-
-    bench_ex = example_floats2D_workflow(ex_run_cfg)
-    example_floats3D_workflow(ex_run_cfg, bench_ex)
-
-    bench_ex.report.show()

bencher/example/experimental/example_bokeh_plotly.py

@@ -1,38 +0,0 @@
-import holoviews as hv
-import numpy as np
-import panel as pn
-
-# hv.extension("bokeh", "plotly")
-backend1 = "plotly"
-# backend1 = "matplotlib"
-backend2 = "bokeh"
-
-# matplotlib.use("agg")
-
-# hv.extension(backend1, backend2)
-hv.extension(backend2, backend1)
-
-# hv.extension(backend1)
-
-# opts.defaults(opts.Surface(backend=backend1), opts.HeatMap(backend=backend2))
-
-# hv.output(opts.Surface(backend=backend1), opts.HeatMap(backend=backend2))
-# hv.output(surface.opts(fig_size=200, backend='matplotlib'), backend='matplotlib')
-
-main = pn.Row()
-
-# hv.output(backend="plotly")
-
-dat = np.ones([10, 10])
-# main.append(hv.Surface(dat))
-
-surf = hv.Surface(dat)
-main.append(hv.render(surf, backend=backend1))
-
-
-# hv.output(backend="bokeh")
-heat = hv.HeatMap(dat)
-heat *= hv.Text(0, 0, "I only work with bokeh and matplotlib")
-main.append(heat)
-
-main.show()

bencher/example/experimental/example_hover_ex.py

@@ -1,45 +0,0 @@
-# pylint: skip-file  #this is experimental still
-
-
-from bokeh.models import HoverTool
-import pandas as pd
-from hvplot import pandas  # noqa
-import holoviews as hv
-import panel as pn
-
-datadict = dict(
-    x=[1, 5],
-    y=[4, 10],
-    img=[
-        "https://raw.githubusercontent.com/holoviz/panel/master/doc/_static/logo_horizontal.png",
-        "https://raw.githubusercontent.com/holoviz/panel/master/doc/_static/logo_stacked.png",
-    ],
-)
-
-
-hover = HoverTool(
-    tooltips="""
-    <div>
-        <div>
-            <img src="@img" width=100 style="float: left; margin: 0px 15px 15px 0px; border="2"></img>
-        <div>
-            <span style="font-size: 15px;">Location</span>
-            <span style="font-size: 10px; color: #696;">(@x, @y)</span>
-        </div>
-    </div>
-
-"""
-)
-
-df_test = pd.DataFrame.from_dict(datadict)
-
-
-hvds = hv.Dataset(df_test)
-
-pt = hv.Scatter(hvds, kdims=["x"], vdims=["y"], hover_cols=["img"], tools=[hover])
-
-pn.Row(pt).show()
-
-# pt =df_test.hvplot.scatter(x="x", y="y", hover_cols=["img"], tools=[hover])
-
-# pt.show()

bencher/example/experimental/example_hvplot_explorer.py

@@ -1,39 +0,0 @@
-# THIS IS NOT A WORKING EXAMPLE YET
-# pylint: disable=duplicate-code
-import hvplot
-import bencher as bch
-from bencher import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
-
-bench = bch.Bench("Bencher_Example_Simple", bench_function, ExampleBenchCfgIn)
-
-
-if __name__ == "__main__":
-    bench_out = bench.plot_sweep(
-        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.offset],
-        result_vars=[ExampleBenchCfgOut.param.out_sin],
-        title="Float 1D Example",
-        description="""Bencher is a tool to make it easy to explore how input parameter affect a range of output metrics.  In these examples we are going to benchmark an example function which has been selected to show the features of bencher.
-        The example function takes an input theta and returns the absolute value of sin(theta) and cos(theta) +- various types of noise.
-
-        def bench_function(cfg: ExampleBenchCfgIn) -> ExampleBenchCfgOut:
-            "Takes an ExampleBenchCfgIn and returns a ExampleBenchCfgOut output"
-            out = ExampleBenchCfgOut()
-            noise = calculate_noise(cfg)
-            offset = 0.0
-
-            postprocess_fn = abs if cfg.postprocess_fn == PostprocessFn.absolute else negate_fn
-
-            out.out_sin = postprocess_fn(offset + math.sin(cfg.theta) + noise)
-            out.out_cos = postprocess_fn(offset + math.cos(cfg.theta) + noise)
-            return out
-        """,
-        post_description="Here you can see the output plot of sin theta between 0 and pi.  In the tabs at the top you can also view 3 tabular representations of the data",
-        run_cfg=bch.BenchRunCfg(
-            auto_plot=True,
-            use_cache=False,
-            repeats=2,
-        ),
-    )
-
-    hvexplorer = hvplot.explorer(bench_out.get_dataframe())
-    hvexplorer.show()

bencher/example/experimental/example_interactive.py

@@ -1,75 +0,0 @@
-# import holoviews as hv
-# import numpy as np
-# import param
-# from holoviews import opts, streams
-# from holoviews.plotting.links import DataLink
-
-# import panel as pn
-
-# hv.extension("bokeh")
-
-# datasets = {
-#     "data1": np.random.randint(1, 10, size=(4, 2)),
-#     "data2": np.random.randint(1, 10, size=(4, 2)),
-# }
-
-# other_data = {i: np.random.randint(1, 10, size=(100, 100)) for i in range(4)}
-
-
-# class Explorer(param.Parameterized):
-#     dataset = param.ObjectSelector(default=list(datasets.keys())[0], objects=list(datasets.keys()))
-
-#     lines = param.Boolean(default=False)
-
-#     # streams
-#     stream = param.ClassSelector(
-#         default=streams.PointDraw(drag=False, add=False), class_=(streams.PointDraw), precedence=-1
-#     )
-
-#     selection = param.ClassSelector(
-#         default=streams.Selection1D(), class_=(streams.Selection1D), precedence=-1
-#     )
-
-#     @param.depends("dataset")
-#     def load_file(self):
-#         name = self.dataset
-#         datum = datasets[name]
-#         scatter = hv.Scatter(datum).opts(size=8)
-
-#         # update the PointDraw/Selection1D sources/data
-#         self.stream.source = scatter
-#         self.selection.source = scatter
-#         self.stream.update(data=scatter.columns())  # reset PointDraw data
-#         self.selection.update(index=[])  # reset selection index
-
-#         table = hv.Table(scatter).opts(index_position=False, editable=True, selectable=True)
-#         DataLink(scatter, table)
-
-#         return (scatter + table).opts(
-#             opts.Scatter(tools=["tap", "hover", "box_select"]), opts.Table(editable=True)
-#         )
-
-#     @param.depends("dataset", "selection.index", "lines")
-#     def view(self):
-#         """update 3rd plot whenever dataset, selection.index, or lines is changed"""
-#         if self.selection.index == []:
-#             return None
-#         else:
-#             # modify with your "other" data
-#             if self.lines is True:
-#                 return hv.Path(other_data[self.selection.index[0]]).opts(shared_axes=False)
-
-#         return hv.operation.datashader.regrid(
-#             hv.Image(other_data[self.selection.index[0]]),
-#             upsample=True,
-#             interpolation="bilinear",
-#         ).opts(shared_axes=False)
-
-#     @param.depends("stream.data", watch=True)
-#     def update_data(self):
-#         """update dataset whenever a point is deleted using PointDraw"""
-#         datasets[self.dataset] = np.vstack((self.stream.data["x"], self.stream.data["y"])).T
-
-
-# explorer = Explorer()
-# pn.Row(pn.Column(explorer.param, explorer.view), explorer.load_file).show()

bencher/example/experimental/example_streamnd.py

@@ -1,49 +0,0 @@
-# pylint: skip-file  #this is experimental still
-
-
-import time
-import numpy as np
-import holoviews as hv
-from holoviews import streams
-import panel as pn
-
-hv.extension("bokeh")
-
-# Step 1: Set up your initial data
-# For demonstration purposes, let's create a simple initial Image plot.
-
-# Initial data (replace this with your actual data source)
-initial_data = np.random.rand(10, 10)
-
-# Create an Image plot from the initial data
-initial_plot = hv.Image(initial_data)
-
-
-# Step 2: Create a callback function to update the plot with new data
-def update_plot(new_data):
-    # Update the Image plot with the new data
-    new_plot = hv.Image(new_data)
-    return new_plot
-
-
-# Step 3: Create a DynamicMap that triggers the update_plot callback
-# The DynamicMap will automatically update the plot when new_data changes.
-dmap = hv.DynamicMap(
-    update_plot, streams=[streams.Stream.define("NewData", new_data=initial_data)()]
-)
-
-# Display the initial plot and start streaming updates
-layout = initial_plot + dmap
-layout = layout.cols(1)
-
-# Simulate streaming updates by continuously updating the new_data stream
-for i in range(10):
-    # Replace this line with your actual data source/streaming mechanism
-    new_data = np.random.rand(10, 10)
-    # Update the new_data stream to trigger the DynamicMap callback
-    dmap.event(NewData=new_data)
-    # Sleep for a specified interval
-    time.sleep(1)
-
-
-pn.Row(dmap).show()

bencher/example/experimental/example_streams.py

@@ -1,36 +0,0 @@
-# pylint: skip-file  #this is experimental still
-
-import numpy as np
-import holoviews as hv
-from holoviews import opts
-from holoviews import streams
-import panel as pn
-
-xs = np.linspace(-3, 3, 400)
-
-hv.extension("bokeh")
-
-
-def function(xs, time):
-    "Some time varying function"
-    return np.exp(np.sin(xs + np.pi / time))
-
-
-def integral(limit, time):
-    print(limit, time)
-    limit = -3 if limit is None else np.clip(limit, -3, 3)
-    curve = hv.Curve((xs, function(xs, time)))[limit:]
-    area = hv.Area((xs, function(xs, time)))[:limit]
-    summed = area.dimension_values("y").sum() * 0.015  # Numeric approximation
-    return area * curve * hv.VLine(limit) * hv.Text(limit + 0.8, 2.0, "%.2f" % summed)
-
-
-integral_streams = [streams.Stream.define("Time", time=1.0)(), streams.PointerX().rename(x="limit")]
-
-integral_dmap = hv.DynamicMap(integral, streams=integral_streams)
-
-integral_dmap.opts(
-    opts.Area(color="#fff8dc", line_width=2), opts.Curve(color="black"), opts.VLine(color="red")
-)
-
-pn.Row(integral_dmap).show()

bencher/example/experimental/example_template.py

@@ -1,40 +0,0 @@
-import holoviews as hv
-import numpy as np
-import panel as pn
-
-pn.extension(sizing_mode="stretch_width")
-
-ACCENT_COLOR = pn.template.FastListTemplate.accent_base_color
-XS = np.linspace(0, np.pi)
-
-
-def sine(freq, phase):
-    return (
-        hv.Curve((XS, np.sin(XS * freq + phase)))
-        .opts(responsive=True, min_height=400, title="Sine", color=ACCENT_COLOR)
-        .opts(line_width=6)
-    )
-
-
-def cosine(freq, phase):
-    return (
-        hv.Curve((XS, np.cos(XS * freq + phase)))
-        .opts(responsive=True, min_height=400, title="Cosine", color=ACCENT_COLOR)
-        .opts(line_width=6)
-    )
-
-
-freq_widget = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
-phase_widget = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
-
-sine = pn.bind(sine, freq=freq_widget, phase=phase_widget)
-cosine = pn.bind(cosine, freq=freq_widget, phase=phase_widget)
-
-template = pn.template.FastListTemplate(
-    site="Panel",
-    title="FastListTemplate",
-    sidebar=[pn.pane.Markdown("## Settings"), freq_widget, phase_widget],
-    main=[
-        pn.pane.HoloViews(hv.DynamicMap(sine) + hv.DynamicMap(cosine), sizing_mode="stretch_both")
-    ],
-).show()

bencher/example/experimental/example_updates.py

@@ -1,84 +0,0 @@
-# pylint: skip-file  #this is experimental still
-
-
-import numpy as np
-import pandas as pd
-import holoviews as hv
-import panel as pn
-
-# import streamz
-# import streamz.dataframe
-
-from holoviews import opts
-from holoviews.streams import Buffer
-
-from tornado.ioloop import PeriodicCallback
-from tornado import gen
-
-
-hv.extension("bokeh")
-
-
-count = 0
-buffer = Buffer(np.zeros((0, 2)), length=50)
-
-dataType = pd.DataFrame()
-
-
-@gen.coroutine
-def f():
-    global count
-    count += 1
-    buffer.send(np.array([[count, np.random.rand()]]))
-
-
-def plot(**kwargs):
-    # print(dat)
-    return hv.Curve(**kwargs)
-
-
-cb = PeriodicCallback(f, 1)
-cb.start()
-
-# dmap = hv.DynamicMap(hv.Curve, streams=[buffer]).opts(padding=0.1, width=600)
-dmap = hv.DynamicMap(plot, streams=[buffer]).opts(padding=0.1, width=600)
-
-pn.Row(dmap).show()
-
-
-example = pd.DataFrame({"x": [], "y": [], "count": []}, columns=["x", "y", "count"])
-dfstream = Buffer(example, length=100, index=False)
-
-
-def plot():
-    curve_dmap = hv.DynamicMap(hv.Curve, streams=[dfstream])
-    point_dmap = hv.DynamicMap(hv.Points, streams=[dfstream])
-    (curve_dmap * point_dmap).opts(
-        opts.Points(color="count", line_color="black", size=5, padding=0.1, xaxis=None, yaxis=None),
-        opts.Curve(line_width=1, color="black"),
-    )
-
-
-def gen_brownian():
-    x, y, count = 0, 0, 0
-    while True:
-        x += np.random.randn()
-        y += np.random.randn()
-        count += 1
-        yield pd.DataFrame([(x, y, count)], columns=["x", "y", "count"])
-
-
-@gen.coroutine
-def update_callback():
-    brownian = gen_brownian()
-    for i in range(2):
-        dfstream.send(next(brownian))
-
-
-cb = PeriodicCallback(update_callback, 1)
-cb.start()
-
-# update_button = pn.widgets.Button(name="Update Grid", button_type="primary")
-# update_button.on_click(update_callback)
-
-pn.Row(plot()).show()

bencher/example/experimental/example_vector.py

@@ -1,84 +0,0 @@
-# """Example on how to sweep over function with vector outputs"""
-
-# from math import cos, sin
-
-# import numpy as np
-
-# import bencher as bch
-
-
-# class OffsetCfg(bch.ParametrizedSweep):
-#     """A class for describing which parameters to sweep"""
-
-#     dc_offset = bch.FloatSweep(
-#         default=0,
-#         bounds=[0.0, 2.0],
-#         samples=4,
-#         units="v",
-#         doc="DC offset to add to the result of the signal",
-#     )
-#     phase_offset = bch.FloatSweep(
-#         default=0,
-#         bounds=[0.0, 3.14],
-#         samples=4,
-#         units="rad",
-#         doc="phase offset that is added to the input before passing to the trig function",
-#     )
-
-
-# class SweepResult(bch.ParametrizedSweep):
-#     """A class to describe the vector outputs of the benchmark function"""
-
-#     sin_sweep = bch.ResultList(
-#         index_name="time", index_units="s", units="v", doc="A list of values from a sin function"
-#     )
-#     cos_sweep = bch.ResultList(
-#         index_name="time", index_units="s", units="v", doc="A list of values from a cos function"
-#     )
-
-
-# def sin_sweep(cfg: OffsetCfg) -> SweepResult:
-#     """A function that returns vector outputs of the sin and cos functions
-
-#     Args:
-#         cfg (OffsetCfg): Options for phase and dc offset
-
-#     Returns:
-#         SweepResult: vectors with sin and cos results
-#     """
-#     res = SweepResult()
-#     print(type(res.sin_sweep))
-#     for i in np.arange(0, 6.28, 0.02):
-#         res.sin_sweep.append(sin(i + cfg.phase_offset) + cfg.dc_offset, i)
-#         # res.sin_sweep.indices.append(i)
-#     for i in np.arange(0, 3.28, 0.02):
-#         res.cos_sweep.append(cos(i + cfg.phase_offset) + cfg.dc_offset, i)
-#         # res.cos_sweep.indices.append(i)
-#     return res
-
-
-# def example_vector() -> bch.Bench:
-#     """Example on how to sweep over function with vector outputs"""
-#     bencher = bch.Bench("vector output example", sin_sweep, OffsetCfg)
-
-#     bencher.plot_sweep(
-#         title="Sweep DC offset",
-#         input_vars=[OffsetCfg.param.dc_offset],
-#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
-#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of dc offsets""",
-#         post_description="""The output shows stack of sin and cos functions as the dc offset increases""",
-#     )
-
-#     bencher.plot_sweep(
-#         title="Sweep phase offset",
-#         input_vars=[OffsetCfg.param.phase_offset],
-#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
-#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of phase offsets""",
-#         post_description="""The output shows different phases of the sin and cos functions""",
-#     )
-
-#     return bencher
-
-
-# if __name__ == "__main__":
-#     example_vector().plot()