functioneer 0.2.2__tar.gz → 0.3.0__tar.gz

{functioneer-0.2.2/src/functioneer.egg-info → functioneer-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: functioneer
-Version: 0.2.2
+Version: 0.3.0
 Summary: Effortlessly explore function behavior with automated batch analysis.
 Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
 Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
@@ -10,7 +10,7 @@ Project-URL: Issues, https://github.com/qthedoc/functioneer/issues
 Project-URL: Funding, https://donate.pypi.org
 Project-URL: Say Thanks!, http://quinnmarsh.com
 Keywords: functioneer,analysis,batch run,automation,autorun,trade space,digital twin
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
 Classifier: License :: OSI Approved :: MIT License
@@ -27,6 +27,7 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.18.5
 Requires-Dist: scipy>=1.5.2
 Requires-Dist: pandas>=1.0.5
+Dynamic: license-file
 
 # Functioneer
 
@@ -34,7 +35,7 @@ Requires-Dist: pandas>=1.0.5
 **Date**: February 02, 2025\
 **PyPI**: https://pypi.org/project/functioneer/
 
-Functioneer lets you effortlessly explore function behavior with automated batch analysis. With just a few lines of code, you can queue up thousands or even millions of function evaluations, testing and optimizing with unlimited parameter combinations. Retrieve structured results in formats like pandas for seamless integration into your workflows. Perfect for parameter sweeps, engineering simulations, and digital twin optimization.
+Functioneer lets you effortlessly explore function behavior with automated batch analysis. With just a few lines of code, you can queue up thousands or even millions of function evaluations, with various parameter combinations and/or optimizations. Retrieve structured results in formats like pandas for seamless integration into your workflows. Perfect for parameter sweeps, engineering simulations, and digital twin optimization.
 
 ## Use cases
 
@@ -44,15 +45,19 @@ Functioneer lets you effortlessly explore function behavior with automated batch
 
 ## How Functioneer Works
 
-At its core, functioneer organizes analyses as pipelines, where a set of *parameters* flows sequentially through a series of *analysis steps*. These steps modify the parameters in various ways, such as defining new parameters, updating existing parameter values, or performing operations like function evaluation and optimization. One of the key features of functioneer is the ability to introduce *forks*, which split the analysis into multiple *branches*, each exploring different values for a specific parameter. This structured approach enables highly flexible and dynamic analyses, suitable for a wide range of applications. Functioneer *Forks* are what let you queue up thousands or even millions of parameter combinations in only a few lines of code.
+At its core, functioneer organizes analyses as tree where a *set of parameters* starts at the trunk and moves out towards the leaves. Along the way, the *set of parameters* 'flows' through a series of *analysis steps* (each of which can be defined in a single line of code). Each *analysis step* can modify or use the parameters in various ways, such as defining new parameters, modifying parameters, or using the parameters to evaluate or even optimize any function of your choice. One key feature of functioneer is the ability to introduce *forks*: a type of analysis step that splits the analysis into multiple parallel *branches*, each exploring different values for a specific parameter. Using many *Forks* in series allows you to queue up thousands or even millions of parameter combinations with only a few lines of code. This structured approach enables highly flexible and dynamic analyses, suitable for a wide range of applications.
+
+Summary of most useful types of *analysis steps*:
+- Define: Adds a new parameter to the analysis
+- Fork: Splits the analysis into multiple parallel *branches*, each exploring different values for a specific parameter
+- Execute: Calls a provided function using the parameters
+- Optimize: Quickly set up an optimization by providing a function and defining which parameters are going to be optimized
 
 <details>
 <summary>
-Important Terms
+<span style="font-size:1.5em;">Important Terms</span>
 </summary>
 
-### Terms
-
 * AnalysisModule
     * Definition: The central container for an analysis pipeline.
     * Function: Holds a sequence of analysis steps and manages a set of parameters that flow through the pipeline.
@@ -90,17 +95,18 @@ pip install functioneer
 Below are a few quick examples of how to use Functioneer. Each example will build on the last, introducing one piece of functionality. By the end you will have witnessed the computational power of this fully armed and fully operational library.
 
 ### Choose a Function to Analyze
-Functioneer is designed to analyze ANY function(s) with ANY number of inputs and outputs. For the following examples, the [Rosenbrock Function](https://en.wikipedia.org/wiki/Rosenbrock_function) is used for its relative simplicity, 4 inputs (plenty to play with) and its historical significance as an optimization benchmark.
+Functioneer is designed to analyze ANY function(s) with ANY number of inputs and outputs. For the following examples, we use the [Rosenbrock Function](https://en.wikipedia.org/wiki/Rosenbrock_function) for (1) its relative simplicity, (2) 4 inputs (plenty to play with) and (3) its historical significance as an optimization benchmark.
 
 ```
+# Example Function
 # Rosenbrock function (known minimum of 0 at: x=1, y=1, a=1, b=100)
 def rosenbrock(x, y, a, b):
     return (a-x)**2 + b*(y-x**2)**2
 ```
 
 ### Example 1: The Basics (Defining Parameters and Executing a Function)
-Set up an *analysis sequence* by defining four parameters (the inputs needed for the Rosenbrock function), then executing the function (with parameter ids matched to kwargs)
-Note: Parameter IDs MUST match your function's args
+Set up an *analysis sequence* by defining four parameters to match our function, then executing the function 
+Note: Parameter IDs MUST match your function's args, function executions inside functioneer are fully keyword arg based.
 
 ```
 import functioneer as fn
@@ -114,7 +120,7 @@ anal.add.define('b', 100) # Define parameter 'b'
 anal.add.define('x', 1) # Define parameter 'x'
 anal.add.define('y', 1) # Define parameter 'y'
 
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function with parameter ids matched to kwargs
+anal.add.execute(func=rosenbrock) # Execute function with parameter ids matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -124,11 +130,11 @@ print(results['df'])
 
 ```
 Output:
-   runtime  a    b  x  y  rosen                   datetime
-0      0.0  1  100  1  1      0 2025-01-03 17:06:21.252981
+   runtime  a    b  x  y  rosenbrock                   datetime
+0      0.0  1  100  1  1           0 2025-06-24 03:26:48.842824
 ```
 
-As predicted, the `rosen` parameter evaluates to 0 when a=1, b=100, x=1, y=1
+As we expect, the `rosenbrock` parameter evaluates to 0 when a=1, b=100, x=1, y=1
 
 Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* for the given branch
 
@@ -138,17 +144,19 @@ If you want to test a set of values for a parameter you can create a *fork* in t
 
 Say we want to evaluate and plot the Rosenbrock surface over the x-y domain. Let's evaluate Rosenbrock on a grid where x=(0, 1, 2) and y=(1, 10) which should result in 6 final *branches* / *leaves*...
 
+Note: the parameter's name is by default set from the function name, but can be overridden using the 'assign_to' arg.
 Note: some boiler plate can be removed by defining initial parameters in the AnalysisModule() declaration
+Note: initial parameter values will be overwritten as needed by parameter steps
 ```
 # Create new analysis
-init_params = dict(a=1, b=100, x=1, y=1) # initial parameters will be overwritten by forks, optimizations, etc
+init_params = dict(a=1, b=100, x=1, y=1) # define initial parameters
 anal = fn.AnalysisModule(init_params)
 
 # Define analysis sequence
-anal.add.fork('x', value_sets=(0, 1, 2)) # Fork analysis, create a branch for each value of 'x': 0, 1, 2
-anal.add.fork('y', value_sets=(1, 10)) # Fork analysis, create a branch for each value of 'y': 1, 10
+anal.add.fork('x', value_set=(0, 1, 2)) # Fork analysis, create a branch for each value of 'x': 0, 1, 2
+anal.add.fork('y', value_set=(1, 10)) # Fork analysis, create a branch for each value of 'y': 1, 10
 
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function (for each branch) with parameters matched to kwargs
+anal.add.execute(func=rosenbrock, assign_to='brock_purdy') # Execute function (for each branch) with parameters matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -156,13 +164,13 @@ print(results['df'].drop(columns='datetime'))
 ```
 ```
 Output:
-    runtime  a    b  x   y  rosen
-0  0.000994  1  100  0   1    101
-1  0.000994  1  100  0  10  10001
-2  0.000994  1  100  1   1      0
-3  0.000994  1  100  1  10   8100
-4  0.000994  1  100  2   1    901
-5  0.000994  1  100  2  10   3601
+    runtime  a    b  x   y  brock_purdy
+0  0.001294  1  100  0   1          101
+1  0.000000  1  100  0  10        10001
+2  0.000000  1  100  1   1            0
+3  0.000000  1  100  1  10         8100
+4  0.000000  1  100  2   1          901
+5  0.000000  1  100  2  10         3601
 ```
 The parameters `x` and `y` were given 3 and 2 fork values respectively, this created 6 total *leaves* (end of each branch) in the analysis. `rosen` has been evaluated for each *leaf*. Essentially you have begun to map the Rosenbrock function over the x-y domain.
 
@@ -176,7 +184,7 @@ anal = fn.AnalysisModule(dict(x=0, y=0))
 anal.add.fork('a', value_set=(1, 2)) # Fork analysis, create a branch for each value of 'a': 0, 1, 2
 anal.add.fork('b', value_set=(0, 100, 200)) # Fork analysis, create a branch for each value of 'b': 0, 100, 200
 
-anal.add.optimize(func=rosenbrock, obj_param_id='rosen', opt_param_ids=('x', 'y'))
+anal.add.optimize(func=rosenbrock, opt_param_ids=('x', 'y'))
 
 # Run the analysis sequence
 results = anal.run()
@@ -194,8 +202,7 @@ Output:
 ```
 For each branch, the Rosenbrock Function has been minimized and the solution values for `x`, `y` and `rosen` are shown.
 
-Note: the initial values (`x0`) used in the optimization are just the existing parameter values (in this case x and y are 0).
-
+Note: the initial values (`x0`) used in the optimization are simply the existing parameter values (in this case x and y are 0) going into the optimization step.
 Note: due to optimization the runtimes for some of the analyses have gone up.
 
 ### Example 4: Multi-parameter Forks
@@ -206,8 +213,7 @@ anal = fn.AnalysisModule(dict(a=1, b=100))
 
 # Define analysis sequence
 anal.add.fork.multi(('x', 'y'), value_sets=((0, 1, 2), (0, 10, 20))) # Fork analysis, create a branch for each value of 'y': 1, 10
-
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function (for each branch) with parameters matched to kwargs
+anal.add.execute(func=rosenbrock) # Execute function (for each branch) with parameters matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -233,7 +239,7 @@ anal = fn.AnalysisModule(dict(x=0, y=0))
 # Define analysis sequence
 anal.add.fork('a', value_set=(1, 2))
 anal.add.fork('b', value_set=(0, 100, 200))
-anal.add.optimize(func=rosenbrock, obj_param_id='rosen', opt_param_ids=('x', 'y'))
+anal.add.optimize(func=rosenbrock, opt_param_ids=('x', 'y'))
 
 # Only evaluate 'expensive_func' if the optimized 'y' is above 0.5
 expensive_func = lambda x, y: x+y
@@ -244,15 +250,15 @@ print(results['df'].drop(columns='datetime'))
 ```
 ```
 Output:
-    runtime  a    b         x         y         rosen  expensive_param  
-0  0.004001  1    0  1.000000  0.000000  4.930381e-32              NaN  
-1  0.009702  1  100  0.999763  0.999523  5.772481e-08         1.999286  
-2  0.017009  1  200  0.999939  0.999873  8.146869e-09         1.999811  
-3  0.000995  2    0  2.000000  0.000000  0.000000e+00              NaN  
-4  0.016001  2  100  1.999731  3.998866  4.067518e-07         5.998596  
-5  0.020995  2  200  1.999554  3.998225  2.136755e-07         5.997779  
+    runtime         x         y  a    b    rosenbrock  expensive_param
+0  0.001997  1.000000  0.000000  1    0  4.930381e-32              NaN
+1  0.004206  0.999763  0.999523  1  100  5.772481e-08         1.999286
+2  0.012199  0.999939  0.999873  1  200  8.146869e-09         1.999811
+3  0.000965  2.000000  0.000000  2    0  0.000000e+00              NaN
+4  0.010121  1.999731  3.998866  2  100  4.067518e-07         5.998596
+5  0.012308  1.999554  3.998225  2  200  2.136755e-07         5.997779 
 ```
-Notice how the evaluation of `expensive_param` has been skipped where the optimized `y` did not meet the criteria `y>0.5`
+Notice how the evaluation of `expensive_param` has been skipped where the optimized `y` did not meet our criteria `y>0.5`
 
 ## License
 

{functioneer-0.2.2 → functioneer-0.3.0}/README.md

@@ -4,7 +4,7 @@
 **Date**: February 02, 2025\
 **PyPI**: https://pypi.org/project/functioneer/
 
-Functioneer lets you effortlessly explore function behavior with automated batch analysis. With just a few lines of code, you can queue up thousands or even millions of function evaluations, testing and optimizing with unlimited parameter combinations. Retrieve structured results in formats like pandas for seamless integration into your workflows. Perfect for parameter sweeps, engineering simulations, and digital twin optimization.
+Functioneer lets you effortlessly explore function behavior with automated batch analysis. With just a few lines of code, you can queue up thousands or even millions of function evaluations, with various parameter combinations and/or optimizations. Retrieve structured results in formats like pandas for seamless integration into your workflows. Perfect for parameter sweeps, engineering simulations, and digital twin optimization.
 
 ## Use cases
 
@@ -14,15 +14,19 @@ Functioneer lets you effortlessly explore function behavior with automated batch
 
 ## How Functioneer Works
 
-At its core, functioneer organizes analyses as pipelines, where a set of *parameters* flows sequentially through a series of *analysis steps*. These steps modify the parameters in various ways, such as defining new parameters, updating existing parameter values, or performing operations like function evaluation and optimization. One of the key features of functioneer is the ability to introduce *forks*, which split the analysis into multiple *branches*, each exploring different values for a specific parameter. This structured approach enables highly flexible and dynamic analyses, suitable for a wide range of applications. Functioneer *Forks* are what let you queue up thousands or even millions of parameter combinations in only a few lines of code.
+At its core, functioneer organizes analyses as tree where a *set of parameters* starts at the trunk and moves out towards the leaves. Along the way, the *set of parameters* 'flows' through a series of *analysis steps* (each of which can be defined in a single line of code). Each *analysis step* can modify or use the parameters in various ways, such as defining new parameters, modifying parameters, or using the parameters to evaluate or even optimize any function of your choice. One key feature of functioneer is the ability to introduce *forks*: a type of analysis step that splits the analysis into multiple parallel *branches*, each exploring different values for a specific parameter. Using many *Forks* in series allows you to queue up thousands or even millions of parameter combinations with only a few lines of code. This structured approach enables highly flexible and dynamic analyses, suitable for a wide range of applications.
+
+Summary of most useful types of *analysis steps*:
+- Define: Adds a new parameter to the analysis
+- Fork: Splits the analysis into multiple parallel *branches*, each exploring different values for a specific parameter
+- Execute: Calls a provided function using the parameters
+- Optimize: Quickly set up an optimization by providing a function and defining which parameters are going to be optimized
 
 <details>
 <summary>
-Important Terms
+<span style="font-size:1.5em;">Important Terms</span>
 </summary>
 
-### Terms
-
 * AnalysisModule
     * Definition: The central container for an analysis pipeline.
     * Function: Holds a sequence of analysis steps and manages a set of parameters that flow through the pipeline.
@@ -60,17 +64,18 @@ pip install functioneer
 Below are a few quick examples of how to use Functioneer. Each example will build on the last, introducing one piece of functionality. By the end you will have witnessed the computational power of this fully armed and fully operational library.
 
 ### Choose a Function to Analyze
-Functioneer is designed to analyze ANY function(s) with ANY number of inputs and outputs. For the following examples, the [Rosenbrock Function](https://en.wikipedia.org/wiki/Rosenbrock_function) is used for its relative simplicity, 4 inputs (plenty to play with) and its historical significance as an optimization benchmark.
+Functioneer is designed to analyze ANY function(s) with ANY number of inputs and outputs. For the following examples, we use the [Rosenbrock Function](https://en.wikipedia.org/wiki/Rosenbrock_function) for (1) its relative simplicity, (2) 4 inputs (plenty to play with) and (3) its historical significance as an optimization benchmark.
 
 ```
+# Example Function
 # Rosenbrock function (known minimum of 0 at: x=1, y=1, a=1, b=100)
 def rosenbrock(x, y, a, b):
     return (a-x)**2 + b*(y-x**2)**2
 ```
 
 ### Example 1: The Basics (Defining Parameters and Executing a Function)
-Set up an *analysis sequence* by defining four parameters (the inputs needed for the Rosenbrock function), then executing the function (with parameter ids matched to kwargs)
-Note: Parameter IDs MUST match your function's args
+Set up an *analysis sequence* by defining four parameters to match our function, then executing the function 
+Note: Parameter IDs MUST match your function's args, function executions inside functioneer are fully keyword arg based.
 
 ```
 import functioneer as fn
@@ -84,7 +89,7 @@ anal.add.define('b', 100) # Define parameter 'b'
 anal.add.define('x', 1) # Define parameter 'x'
 anal.add.define('y', 1) # Define parameter 'y'
 
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function with parameter ids matched to kwargs
+anal.add.execute(func=rosenbrock) # Execute function with parameter ids matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -94,11 +99,11 @@ print(results['df'])
 
 ```
 Output:
-   runtime  a    b  x  y  rosen                   datetime
-0      0.0  1  100  1  1      0 2025-01-03 17:06:21.252981
+   runtime  a    b  x  y  rosenbrock                   datetime
+0      0.0  1  100  1  1           0 2025-06-24 03:26:48.842824
 ```
 
-As predicted, the `rosen` parameter evaluates to 0 when a=1, b=100, x=1, y=1
+As we expect, the `rosenbrock` parameter evaluates to 0 when a=1, b=100, x=1, y=1
 
 Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* for the given branch
 
@@ -108,17 +113,19 @@ If you want to test a set of values for a parameter you can create a *fork* in t
 
 Say we want to evaluate and plot the Rosenbrock surface over the x-y domain. Let's evaluate Rosenbrock on a grid where x=(0, 1, 2) and y=(1, 10) which should result in 6 final *branches* / *leaves*...
 
+Note: the parameter's name is by default set from the function name, but can be overridden using the 'assign_to' arg.
 Note: some boiler plate can be removed by defining initial parameters in the AnalysisModule() declaration
+Note: initial parameter values will be overwritten as needed by parameter steps
 ```
 # Create new analysis
-init_params = dict(a=1, b=100, x=1, y=1) # initial parameters will be overwritten by forks, optimizations, etc
+init_params = dict(a=1, b=100, x=1, y=1) # define initial parameters
 anal = fn.AnalysisModule(init_params)
 
 # Define analysis sequence
-anal.add.fork('x', value_sets=(0, 1, 2)) # Fork analysis, create a branch for each value of 'x': 0, 1, 2
-anal.add.fork('y', value_sets=(1, 10)) # Fork analysis, create a branch for each value of 'y': 1, 10
+anal.add.fork('x', value_set=(0, 1, 2)) # Fork analysis, create a branch for each value of 'x': 0, 1, 2
+anal.add.fork('y', value_set=(1, 10)) # Fork analysis, create a branch for each value of 'y': 1, 10
 
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function (for each branch) with parameters matched to kwargs
+anal.add.execute(func=rosenbrock, assign_to='brock_purdy') # Execute function (for each branch) with parameters matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -126,13 +133,13 @@ print(results['df'].drop(columns='datetime'))
 ```
 ```
 Output:
-    runtime  a    b  x   y  rosen
-0  0.000994  1  100  0   1    101
-1  0.000994  1  100  0  10  10001
-2  0.000994  1  100  1   1      0
-3  0.000994  1  100  1  10   8100
-4  0.000994  1  100  2   1    901
-5  0.000994  1  100  2  10   3601
+    runtime  a    b  x   y  brock_purdy
+0  0.001294  1  100  0   1          101
+1  0.000000  1  100  0  10        10001
+2  0.000000  1  100  1   1            0
+3  0.000000  1  100  1  10         8100
+4  0.000000  1  100  2   1          901
+5  0.000000  1  100  2  10         3601
 ```
 The parameters `x` and `y` were given 3 and 2 fork values respectively, this created 6 total *leaves* (end of each branch) in the analysis. `rosen` has been evaluated for each *leaf*. Essentially you have begun to map the Rosenbrock function over the x-y domain.
 
@@ -146,7 +153,7 @@ anal = fn.AnalysisModule(dict(x=0, y=0))
 anal.add.fork('a', value_set=(1, 2)) # Fork analysis, create a branch for each value of 'a': 0, 1, 2
 anal.add.fork('b', value_set=(0, 100, 200)) # Fork analysis, create a branch for each value of 'b': 0, 100, 200
 
-anal.add.optimize(func=rosenbrock, obj_param_id='rosen', opt_param_ids=('x', 'y'))
+anal.add.optimize(func=rosenbrock, opt_param_ids=('x', 'y'))
 
 # Run the analysis sequence
 results = anal.run()
@@ -164,8 +171,7 @@ Output:
 ```
 For each branch, the Rosenbrock Function has been minimized and the solution values for `x`, `y` and `rosen` are shown.
 
-Note: the initial values (`x0`) used in the optimization are just the existing parameter values (in this case x and y are 0).
-
+Note: the initial values (`x0`) used in the optimization are simply the existing parameter values (in this case x and y are 0) going into the optimization step.
 Note: due to optimization the runtimes for some of the analyses have gone up.
 
 ### Example 4: Multi-parameter Forks
@@ -176,8 +182,7 @@ anal = fn.AnalysisModule(dict(a=1, b=100))
 
 # Define analysis sequence
 anal.add.fork.multi(('x', 'y'), value_sets=((0, 1, 2), (0, 10, 20))) # Fork analysis, create a branch for each value of 'y': 1, 10
-
-anal.add.execute(func=rosenbrock, output_param_ids='rosen') # Execute function (for each branch) with parameters matched to kwargs
+anal.add.execute(func=rosenbrock) # Execute function (for each branch) with parameters matched to kwargs
 
 # Run the analysis sequence
 results = anal.run()
@@ -203,7 +208,7 @@ anal = fn.AnalysisModule(dict(x=0, y=0))
 # Define analysis sequence
 anal.add.fork('a', value_set=(1, 2))
 anal.add.fork('b', value_set=(0, 100, 200))
-anal.add.optimize(func=rosenbrock, obj_param_id='rosen', opt_param_ids=('x', 'y'))
+anal.add.optimize(func=rosenbrock, opt_param_ids=('x', 'y'))
 
 # Only evaluate 'expensive_func' if the optimized 'y' is above 0.5
 expensive_func = lambda x, y: x+y
@@ -214,15 +219,15 @@ print(results['df'].drop(columns='datetime'))
 ```
 ```
 Output:
-    runtime  a    b         x         y         rosen  expensive_param  
-0  0.004001  1    0  1.000000  0.000000  4.930381e-32              NaN  
-1  0.009702  1  100  0.999763  0.999523  5.772481e-08         1.999286  
-2  0.017009  1  200  0.999939  0.999873  8.146869e-09         1.999811  
-3  0.000995  2    0  2.000000  0.000000  0.000000e+00              NaN  
-4  0.016001  2  100  1.999731  3.998866  4.067518e-07         5.998596  
-5  0.020995  2  200  1.999554  3.998225  2.136755e-07         5.997779  
-```
-Notice how the evaluation of `expensive_param` has been skipped where the optimized `y` did not meet the criteria `y>0.5`
+    runtime         x         y  a    b    rosenbrock  expensive_param
+0  0.001997  1.000000  0.000000  1    0  4.930381e-32              NaN
+1  0.004206  0.999763  0.999523  1  100  5.772481e-08         1.999286
+2  0.012199  0.999939  0.999873  1  200  8.146869e-09         1.999811
+3  0.000965  2.000000  0.000000  2    0  0.000000e+00              NaN
+4  0.010121  1.999731  3.998866  2  100  4.067518e-07         5.998596
+5  0.012308  1.999554  3.998225  2  200  2.136755e-07         5.997779 
+```
+Notice how the evaluation of `expensive_param` has been skipped where the optimized `y` did not meet our criteria `y>0.5`
 
 ## License
 

{functioneer-0.2.2 → functioneer-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "functioneer"
-version = "0.2.2"
+version = "0.3.0"
 authors = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
 maintainers = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
 description = "Effortlessly explore function behavior with automated batch analysis."
@@ -19,7 +19,7 @@ dependencies = [
 ]
 
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Intended Audience :: Science/Research",
   "Topic :: Scientific/Engineering",
   "License :: OSI Approved :: MIT License",

{functioneer-0.2.2 → functioneer-0.3.0}/src/functioneer/__init__.py

@@ -1,6 +1,4 @@
 # functioneer/__init__.py
-
-# Import specific functions and classes from your modules
-
+__version__ = "0.3.0"
 from functioneer.analysis import AnalysisModule, AnalysisStep, Define, Fork, Execute, Optimize
 from functioneer.parameter import Parameter