functioneer 0.2.1__tar.gz → 0.3.0__tar.gz

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

@@ -1,7 +1,7 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: functioneer
-Version: 0.2.1
-Summary: A library providing easy automated analysis for your functions.
+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>
 License: MIT
@@ -9,8 +9,8 @@ Project-URL: Homepage, https://github.com/qthedoc/functioneer
 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,automation,autorun,trade space,digital twin
-Classifier: Development Status :: 3 - Alpha
+Keywords: functioneer,analysis,batch run,automation,autorun,trade space,digital twin
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
 Classifier: License :: OSI Approved :: MIT License
@@ -27,13 +27,15 @@ 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
 
 **Author**: Quinn Marsh  
-**Date**: February 02, 2025
+**Date**: February 02, 2025\
+**PyPI**: https://pypi.org/project/functioneer/
 
-Functioneer is a Python package that automates the analysis of ANY function, enabling you to test and optimize with unlimited combinations of parameters. Whether you're performing parameter sweeps, sensitivity testing, or optimizing digital twins, Functioneer lets you queue up thousands or even millions of tests in seconds. Easily retrieve and analyze results in formats like pandas for seamless integration into your analysis workflows.
+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
 
@@ -43,9 +45,19 @@ Functioneer is a Python package that automates the analysis of ANY function, ena
 
 ## How Functioneer Works
 
-Functioneer is a powerful system for defining and executing complex analysis pipelines. At its core, the toolkit 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.
+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>
+<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.
@@ -69,6 +81,7 @@ Functioneer is a powerful system for defining and executing complex analysis pip
 * Leaf
     * Definition: The endpoint of a branch after all analysis steps have been executed.
     * Function: Represents the final state of parameters for that branch. Each leaf corresponds to a specific combination of parameter values and results. When results are tabulated, each row corresponds to a leaf.
+</details>
 
 ## Installation
 
@@ -81,17 +94,19 @@ pip install functioneer
 ## Getting Started
 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.
 
-### Choosing 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.
+### Choose a Function to Analyze
+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)
+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
@@ -105,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()
@@ -115,32 +130,33 @@ 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
-
-Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* fields
+As we expect, the `rosenbrock` parameter evaluates to 0 when a=1, b=100, x=1, y=1
 
-But let's say you want to test a range of values for some parameters...
+Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* for the given branch
 
 ### Example 2: Single Parameter Forks (Testing Variations of a Parameter)
+Let's say you want to test a range of values for some parameters...
 If you want to test a set of values for a parameter you can create a *fork* in the *analysis sequence*. This splits the analysis into multiple *branches*, each exploring different values for a the given parameter.
 
-Say we want to evaluate and plot the Rosenbrock surface over the x-y domain. Let's evaluate Rosenbrock a grid where x=(0, 1, 2) and y=(1, 10) which should result in 6 final *branches* / *leaves*...
+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()
@@ -148,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.
 
@@ -168,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()
@@ -186,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 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
@@ -198,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()
@@ -225,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
@@ -236,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  
-```
-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.1 → functioneer-0.3.0}/README.md

@@ -1,9 +1,10 @@
 # Functioneer
 
 **Author**: Quinn Marsh  
-**Date**: February 02, 2025
+**Date**: February 02, 2025\
+**PyPI**: https://pypi.org/project/functioneer/
 
-Functioneer is a Python package that automates the analysis of ANY function, enabling you to test and optimize with unlimited combinations of parameters. Whether you're performing parameter sweeps, sensitivity testing, or optimizing digital twins, Functioneer lets you queue up thousands or even millions of tests in seconds. Easily retrieve and analyze results in formats like pandas for seamless integration into your analysis workflows.
+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
 
@@ -13,9 +14,19 @@ Functioneer is a Python package that automates the analysis of ANY function, ena
 
 ## How Functioneer Works
 
-Functioneer is a powerful system for defining and executing complex analysis pipelines. At its core, the toolkit 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.
+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>
+<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.
@@ -39,6 +50,7 @@ Functioneer is a powerful system for defining and executing complex analysis pip
 * Leaf
     * Definition: The endpoint of a branch after all analysis steps have been executed.
     * Function: Represents the final state of parameters for that branch. Each leaf corresponds to a specific combination of parameter values and results. When results are tabulated, each row corresponds to a leaf.
+</details>
 
 ## Installation
 
@@ -51,17 +63,19 @@ pip install functioneer
 ## Getting Started
 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.
 
-### Choosing 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.
+### Choose a Function to Analyze
+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)
+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
@@ -75,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()
@@ -85,32 +99,33 @@ 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
-
-Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* fields
+As we expect, the `rosenbrock` parameter evaluates to 0 when a=1, b=100, x=1, y=1
 
-But let's say you want to test a range of values for some parameters...
+Note: the `results['df']` is a pandas DataFrame containing all parameters in addition to *runtime* and *datetime* for the given branch
 
 ### Example 2: Single Parameter Forks (Testing Variations of a Parameter)
+Let's say you want to test a range of values for some parameters...
 If you want to test a set of values for a parameter you can create a *fork* in the *analysis sequence*. This splits the analysis into multiple *branches*, each exploring different values for a the given parameter.
 
-Say we want to evaluate and plot the Rosenbrock surface over the x-y domain. Let's evaluate Rosenbrock a grid where x=(0, 1, 2) and y=(1, 10) which should result in 6 final *branches* / *leaves*...
+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()
@@ -118,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.
 
@@ -138,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()
@@ -156,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 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
@@ -168,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()
@@ -195,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
@@ -206,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.1 → functioneer-0.3.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "functioneer"
-version = "0.2.1"
+version = "0.3.0"
 authors = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
 maintainers = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
-description = "A library providing easy automated analysis for your functions."
+description = "Effortlessly explore function behavior with automated batch analysis."
 readme = "README.md"
 license = { text = "MIT" }
-keywords = ["functioneer", "analysis", "automation", "autorun", "trade space", "digital twin"]
+keywords = ["functioneer", "analysis", "batch run", "automation", "autorun", "trade space", "digital twin"]
 requires-python = ">=3.7"
 dependencies = [
   "numpy>=1.18.5",
@@ -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.1 → 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