holobench 1.25.2__py3-none-any.whl → 1.27.0__py3-none-any.whl

bencher/example/example_composable_container2.py

@@ -0,0 +1,160 @@
+import bencher as bch
+from PIL import Image, ImageDraw
+from bencher.video_writer import VideoWriter
+
+
+class BenchImageTest(bch.ParametrizedSweep):
+    character = bch.StringSweep(["a", "b", "c", "d", "e", "f"])
+    r = bch.IntSweep(default=255, bounds=[0, 255])
+    g = bch.IntSweep(default=255, bounds=[0, 255])
+    b = bch.IntSweep(default=255, bounds=[0, 255])
+    width = bch.IntSweep(default=100, bounds=[10, 100])
+    height = bch.IntSweep(default=100, bounds=[10, 100])
+
+    image = bch.ResultImage()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        img = Image.new("RGB", (self.width, self.height), color=(self.r, self.g, self.b))
+        ImageDraw.Draw(img).text(
+            (self.width / 2.0, self.height / 2.0),
+            self.character,
+            (0, 0, 0),
+            anchor="mm",
+            font_size=self.height,
+        )
+        self.image = bch.gen_image_path()
+        img.save(self.image)
+        return super().__call__(**kwargs)
+
+
+def bench_image(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchImageTest().to_bench(run_cfg, report)
+    bench.sweep_sequential(group_size=1)
+    return bench
+
+
+class BenchComposableContainerImage(BenchImageTest):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    # num_frames = bch.IntSweep(default=5, bounds=[1, 10])
+    # character = bch.StringSweep(["a", "b"])
+
+    text_vid = bch.ResultVideo()
+    frame_width = bch.ResultVar("pixels")
+    frame_height = bch.ResultVar("pixels")
+    duration = bch.ResultVar("S")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        # if self.labels:
+        # var_name = "sides"
+        # var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+
+        for c in ["a", "b"]:
+            res = super().__call__(character=c)
+            vr.append(res["image"])
+
+        vid = vr.render(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                # var_name=var_name,
+                # var_value=var_value,
+                max_frame_duration=2.0,
+                # max_frame_duration=1.,
+                # duration=1.
+            )
+        )
+
+        self.frame_width, self.frame_height = vid.size
+        self.duration = vid.duration
+        print("RES", self.frame_width, self.frame_height, self.duration)
+
+        self.text_vid = VideoWriter().write_video_raw(vid)
+        return self.get_results_values_as_dict()
+
+
+# class BenchComposableContainerVideo(bch.ParametrizedSweep):
+#     unequal_length = bch.BoolSweep()
+#     compose_method = bch.EnumSweep(bch.ComposeType)
+#     labels = bch.BoolSweep()
+#     polygon_vid = bch.ResultVideo()
+
+#     def __call__(self, **kwargs):
+#         self.update_params_from_kwargs(**kwargs)
+#         vr = bch.ComposableContainerVideo()
+#         for i in range(3, 5):
+#             num_frames = i * 10 if self.unequal_length else 5
+#             res = BenchComposableContainerImage().__call__(
+#                 compose_method=bch.ComposeType.sequence, sides=i, num_frames=num_frames
+#             )
+#             vr.append(res["polygon_vid"])
+
+#         self.polygon_vid = vr.to_video(bch.RenderCfg(compose_method=kwargs.get("compose_method")))
+#         return self.get_results_values_as_dict()
+
+
+def example_composable_container_image(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerImage().to_bench(run_cfg, report)
+    bench.result_vars = ["text_vid", "duration"]
+    # bench.result_vars = ["duration"]
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_table)
+
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    # bench.plot_sweep(input_vars=["compose_method", "labels"])
+
+    bench.plot_sweep(input_vars=["compose_method"])
+
+    # bench.compose_
+    # bench.plot_sweep(
+    # input_vars=[bch.p("num_frames", [2, 8, 20])],
+    # const_vars=dict(compose_method=bch.ComposeType.sequence),
+    # )
+
+    return bench
+
+
+# def example_composable_container_video(
+#     run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+# ) -> bch.Bench:
+#     bench = BenchComposableContainerVideo().to_bench(run_cfg, report)
+
+#     bench.result_vars = ["polygon_vid"]
+#     bench.add_plot_callback(bch.BenchResult.to_panes)
+#     bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+#     bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+#     bench.plot_sweep(input_vars=["compose_method", "labels"], const_vars=dict(unequal_length=True))
+
+#     res = bench.plot_sweep(
+#         input_vars=[],
+#         const_vars=dict(unequal_length=False, compose_method=bch.ComposeType.sequence),
+#         plot_callbacks=False,
+#     )
+
+#     bench.report.append(res.to_video_grid())
+
+#     return bench
+
+
+# if __name__ == "__main__":
+#     ex_run_cfg = bch.BenchRunCfg()
+#     ex_run_cfg.use_sample_cache = False
+#     # ex_run_cfg.level = 2
+#     ex_report = bch.BenchReport()
+#     example_composable_container_image(ex_run_cfg, report=ex_report)
+#     # example_composable_container_video(ex_run_cfg, report=ex_report)
+#     ex_report.show()
+
+
+if __name__ == "__main__":
+    bench_runner = bch.BenchRunner("ImageChar")
+    # bench_runner.add_run(bench_image)
+    bench_runner.add_run(example_composable_container_image)
+
+    bench_runner.run(level=6, show=True, use_cache=False)

bencher/example/example_consts.py

@@ -0,0 +1,39 @@
+"""This file contains examples for how to perform basic 2D benchmarking parameter sweeps"""
+
+import math
+import bencher as bch
+
+
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    offset = bch.FloatSweep(default=0, bounds=[0, 1], doc="Input angle offset", units="rad")
+    noise = bch.FloatSweep(default=0, bounds=[0, 1], doc="noise", units="rad")
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta) + self.offset + self.noise
+        return super().__call__(**kwargs)
+
+
+def example_2D_float_const(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    const_vars = SimpleFloat().get_input_defaults_override(offset=0.5)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    const_vars = SimpleFloat().get_input_defaults_override(noise=0.2)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    bench.plot_sweep(input_vars=["theta"], const_vars=dict(offset=0.3))
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_2D_float_const().report.show()

bencher/example/example_custom_sweep.py

@@ -0,0 +1,59 @@
+import bencher as bch
+
+
+class Square(bch.ParametrizedSweep):
+    """An example of a datatype with an integer and float parameter"""
+
+    x = bch.FloatSweep(
+        sample_values=[2, 3, 4, 7, 8, 9],
+        doc="An example of a user defines set of sweep values",
+    )
+    y = bch.IntSweep(
+        sample_values=[1, 2, 6], doc="An example of a user defines set of sweep values"
+    )
+
+    result = bch.ResultVar("ul", doc="Square of x")
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.x * self.x * self.y * 3
+        return self.get_results_values_as_dict()
+
+
+def example_custom_sweep(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    bencher = bch.Bench(
+        "benchmarking_example_custom_sweep", Square(), run_cfg=run_cfg, report=report
+    )
+    # bencher = bch.Bench("benchmarking_example_custom_sweep", call,run_cfg=run_cfg)
+
+    # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
+
+    bencher.plot_sweep(
+        title="Example User Defined Sweep 1D",
+        input_vars=[Square.param.x],
+        result_vars=[Square.param.result],
+        description="Sample the x parameter",
+    )
+
+    bencher.plot_sweep(
+        title="Example User Defined Sweep 2D",
+        description="By default bencher sweep all the variables in a class",
+    )
+
+    return bencher
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg(run_tag="example_tag1", print_meta=True)
+    example_custom_sweep(ex_run_cfg).report.show()

bencher/example/example_custom_sweep2.py

@@ -0,0 +1,42 @@
+import bencher as bch
+
+
+class Square(bch.ParametrizedSweep):
+    """An example of a datatype with an integer and float parameter"""
+
+    x = bch.FloatSweep(default=0, bounds=[0, 6])
+
+    result = bch.ResultVar("ul", doc="Square of x")
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.x * self.x
+        return self.get_results_values_as_dict()
+
+
+def example_custom_sweep2(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    bench = Square().to_bench(run_cfg=run_cfg, report=report)
+
+    # These are all equivalent
+    bench.plot_sweep(input_vars=[Square.param.x.with_sample_values([0, 1, 2])])
+    bench.plot_sweep(input_vars=[bch.p("x", [4, 5, 6])])
+
+    bench.plot_sweep(input_vars=[bch.p("x", samples=5)])
+    bench.plot_sweep(input_vars=[bch.p("x", samples=6)])
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_custom_sweep2().report.show()

bencher/example/example_docs.py

@@ -0,0 +1,34 @@
+import bencher as bch
+from bencher.example.example_video import example_video
+from bencher.example.example_image import example_image
+from bencher.example.meta.example_meta_levels import example_meta_levels
+from bencher.example.meta.example_meta_cat import example_meta_cat
+from bencher.example.meta.example_meta_float import example_meta_float
+
+
+def example_docs(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    # b_run = bch.BenchRunner("bench_runner_test", run_cfg=run_cfg)
+    # b_run.add_run(example_categorical)
+    # b_run.add_run(example_floats)
+    # b_run.add_run(example_image)
+    # b_run.add_run(example_video)
+    # b_run.add_run(example_meta_levels)
+    # b_run.add_run(run_levels)
+    # b_run.run(level=4, grouped=True, save=True)
+    # b_run.shutdown()
+    run_cfg.repeats = 1
+    run_cfg.level = 2
+    example_image(run_cfg, report)
+    example_video(run_cfg, report)
+    example_meta_cat(report=report)
+    example_meta_float(report=report)
+    example_meta_levels(report=report)
+    # example_meta(run_cfg,report)
+
+    return report
+
+
+if __name__ == "__main__":
+    example_docs().show()

bencher/example/example_filepath.py

@@ -0,0 +1,27 @@
+import bencher as bch
+
+
+class ExampleFile(bch.ParametrizedSweep):
+    content = bch.StringSweep(["entry1", "entry2", "entry3"])
+
+    file_result = bch.ResultPath()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        # this generates a unique filename and stores it in the cache directory
+        filename = bch.gen_path(self.content, suffix=".txt")
+        with open(filename, "w", encoding="utf-8") as text_file:
+            text_file.write(f"content:{self.content}")
+        self.file_result = filename
+        return super().__call__()
+
+
+def example_filepath(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None):
+    bench = ExampleFile().to_bench(run_cfg, report)
+    bench.plot_sweep()
+    return bench
+
+
+if __name__ == "__main__":
+    example_filepath().report.show()

bencher/example/example_float3D.py

@@ -0,0 +1,101 @@
+# 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=4
+    )
+    y = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="y coordinate of the sample volume", samples=5
+    )
+    z = bch.FloatSweep(
+        default=0, bounds=[-1.0, 1.0], doc="z coordinate of the sample volume", samples=6
+    )
+
+
+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")
+    occupancy = bch.ResultVar(
+        "occupied", doc="If the value is > 0.5 this point is considered occupied"
+    )
+    interesting = bch.ResultVar("ul", doc="A more interesting scalar field")
+    interesting_vec = bch.ResultVec(3, "vec", doc="A vector field with an interesting shape")
+    interesting_vec_and_occ = bch.ResultVec(
+        3, "vec", doc="The same vector field but only showing values in a sphere of radius 0.5"
+    )
+
+
+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
+    """
+    output = VolumeResult()
+    output.value = np.linalg.norm(np.array([point.x, point.y, point.z]))  # distance to origin
+    output.occupancy = float(output.value < 0.5)
+    # from https://plotly.com/python/3d-volume-plots/
+    output.interesting = np.sin(np.pi * point.x) * np.cos(np.pi * point.z) * np.sin(np.pi * point.y)
+    output.interesting_vec = [
+        np.sin(np.pi * point.x),
+        np.cos(np.pi * point.z),
+        np.sin(np.pi * point.y),
+    ]
+
+    if output.occupancy:
+        output.interesting_vec_and_occ = output.interesting_vec
+    else:
+        output.interesting_vec_and_occ = [0, 0, 0]
+
+    return output
+
+
+def example_floats3D(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> 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
+    """
+    bench = bch.Bench(
+        "Bencher_Example_Floats",
+        bench_fn,
+        VolumeSample,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    bench.plot_sweep(
+        title="Float 3D Example",
+        input_vars=[VolumeSample.param.x, VolumeSample.param.y, VolumeSample.param.z],
+        result_vars=[
+            VolumeResult.param.value,
+            VolumeResult.param.occupancy,
+            VolumeResult.param.interesting,
+        ],
+        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",
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.level = 3
+    example_floats3D(ex_run_cfg).report.show()

bencher/example/example_float_cat.py

@@ -0,0 +1,99 @@
+"""Example of how to perform a parameter sweep for categorical variables"""
+
+import bencher as bch
+
+
+# All the examples will be using the data structures and benchmark function defined in this file
+from bencher.example.benchmark_data import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
+
+
+def example_float_cat(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a parameter sweep for categorical variables
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+    bench = bch.Bench(
+        "Bencher_Example_Float_Cat",
+        bench_function,
+        ExampleBenchCfgIn,
+        run_cfg=run_cfg,
+        report=report,
+    )
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.theta,
+            ExampleBenchCfgIn.param.offset,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+        title="Float 2D Cat 1D Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We pass the boolean  'noisy' and keep the other parameters the same""",
+        post_description="Now the plot has two lines, one for each of the boolean values where noisy=true and noisy=false.",
+    )
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+        title="Float 1D Cat 1D  Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We pass the boolean  'noisy' and keep the other parameters the same""",
+        post_description="Now the plot has two lines, one for each of the boolean values where noisy=true and noisy=false.",
+        plot_callbacks=False,
+    )
+
+    # report.append(bench.get_result().to_curve())
+
+    # # this does not work yet because it tries to find min and max of categorical values
+    # bench.plot_sweep(
+    #     input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.postprocess_fn],
+    #     result_vars=[ExampleBenchCfgOut.param.out_sin],
+    #     const_vars=[ExampleBenchCfgIn.param.noisy.with_const(True)],
+    #     title="Float 1D Cat 1D  Example",
+    #     description="""Following from the previous example lets add another input parameter to see how that affects the output.  We pass the boolean  'noisy' and keep the other parameters the same""",
+    #     post_description="Now the plot has two lines, one for each of the boolean values where noisy=true and noisy=false.",
+    #     run_cfg=run_cfg,
+    # )
+
+    return bench
+
+
+def run_example_float_cat(ex_run_cfg=bch.BenchRunCfg()) -> None:
+    ex_run_cfg.repeats = 2
+    ex_run_cfg.over_time = True
+    ex_run_cfg.clear_cache = True
+    ex_run_cfg.clear_history = True
+    ex_run_cfg.level = 3
+    # ex_run_cfg.time_event = "run 1"
+    # ex_run_cfg.use_optuna = True
+
+    example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.repeats = 2
+    # ex_run_cfg.over_time = True
+    ex_run_cfg.clear_cache = False
+    ex_run_cfg.clear_history = False
+    # ex_run_cfg.time_event = "run 2"
+    # ex_run_cfg.use_optuna = True
+
+    # example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.clear_cache = False
+    # ex_run_cfg.clear_history = False
+    # ex_run_cfg.time_event = "run 2"
+
+    # example_float_cat(ex_run_cfg)
+
+    # ex_run_cfg.time_event = "run 3"
+    return example_float_cat(ex_run_cfg)
+
+
+if __name__ == "__main__":
+    run_example_float_cat().report.show()

bencher/example/example_floats.py

@@ -0,0 +1,89 @@
+# pylint: disable=duplicate-code
+
+
+import bencher as bch
+
+# All the examples will be using the data structures and benchmark function defined in this file
+from bencher.example.benchmark_data import ExampleBenchCfgIn, ExampleBenchCfgOut, ExampleBenchCfg
+
+
+def example_floats(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    """Example of how to perform a parameter sweep for floating point variables
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+    bench = bch.Bench("Bencher_Example_Floats", ExampleBenchCfg(), report=report, run_cfg=run_cfg)
+
+    with open("README.md", "r", encoding="utf-8") as file:
+        readme = file.read()
+
+    bench.report.append(readme, "Intro")
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta],
+        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
+
+    The following examples will show how to perform parameter sweeps to characterise the behavior of the function.  The idea is that the benchmarking can be used to gain understanding of an unknown function. 
+        """,
+        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",
+    )
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.noisy],
+        result_vars=[ExampleBenchCfgOut.param.out_sin],
+        title="Float 1D and Bool Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We pass the boolean  'noisy' and keep the other parameters the same""",
+        post_description="Now the plot has two lines, one for each of the boolean values where noisy=true and noisy=false.",
+    )
+
+    bench.plot_sweep(
+        input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.noisy],
+        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
+        title="Float 1D and Bool Example with multiple outputs",
+        description="""Following from the previous example here the second output is added to the result variables""",
+        post_description="Another column is added for the result variable that shows cos(theta)",
+    )
+
+    bench.plot_sweep(
+        input_vars=[
+            ExampleBenchCfgIn.param.theta,
+            ExampleBenchCfgIn.param.noisy,
+            ExampleBenchCfgIn.param.postprocess_fn,
+        ],
+        result_vars=[
+            ExampleBenchCfgOut.param.out_sin,
+            ExampleBenchCfgOut.param.out_cos,
+        ],
+        title="Float 1D, Bool and Categorical Example",
+        description="""Following from the previous example lets add another input parameter to see how that affects the output.  We add the 'postprocess_fn' categorical enum value which either takes the absolute value or negates the output of the function.""",
+        post_description="This generates two rows of results, one for each of the category options.",
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    bench_ex = example_floats(bch.BenchRunCfg(repeats=2))
+    bench_ex.report.save_index()
+    bench_ex.report.show()