functioneer 0.4.2__tar.gz → 0.5.0__tar.gz

{functioneer-0.4.2/src/functioneer.egg-info → functioneer-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functioneer
-Version: 0.4.2
+Version: 0.5.0
 Summary: Effortlessly explore function behavior with the ultimate batch runner.
 Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
 Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
@@ -71,7 +71,7 @@ analysis = fn.AnalysisModule() # Create new analysis
 analysis.add.define({'a': 1, 'b': 100}) # define a and b
 analysis.add.fork('x', (0, 1, 2)) # Fork analysis, create branches for x=0, x=1, x=2
 analysis.add.fork('y', (1, 10))
-analysis.add.execute(func=rosenbrock) #
+analysis.add.evaluate(func=rosenbrock) #
 results = analysis.run()
 print('Example 1 Output:')
 print(results['df'][['a', 'b', 'x', 'y', 'rosenbrock']])
@@ -132,7 +132,7 @@ At its core, functioneer organizes analyses as a tree where a *set of parameters
 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
+- Evaluate: 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>

{functioneer-0.4.2 → functioneer-0.5.0}/README.md

@@ -40,7 +40,7 @@ analysis = fn.AnalysisModule() # Create new analysis
 analysis.add.define({'a': 1, 'b': 100}) # define a and b
 analysis.add.fork('x', (0, 1, 2)) # Fork analysis, create branches for x=0, x=1, x=2
 analysis.add.fork('y', (1, 10))
-analysis.add.execute(func=rosenbrock) #
+analysis.add.evaluate(func=rosenbrock) #
 results = analysis.run()
 print('Example 1 Output:')
 print(results['df'][['a', 'b', 'x', 'y', 'rosenbrock']])
@@ -101,7 +101,7 @@ At its core, functioneer organizes analyses as a tree where a *set of parameters
 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
+- Evaluate: 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>

{functioneer-0.4.2 → functioneer-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "functioneer"
-version = "0.4.2"
+version = "0.5.0"
 authors = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
 maintainers = [{ name = "Quinn Marsh", email = "quinnmarsh@hotmail.com" }]
 description = "Effortlessly explore function behavior with the ultimate batch runner."

{functioneer-0.4.2 → functioneer-0.5.0}/src/functioneer/__init__.py

@@ -1,4 +1,4 @@
 # functioneer/__init__.py
-__version__ = "0.4.2"
-from functioneer.analysis import AnalysisModule, AnalysisStep, Define, Fork, Execute, Optimize
+__version__ = "0.5.0"
+from functioneer.analysis import AnalysisModule, AnalysisStep, Define, Fork, Evaluate, Optimize
 from functioneer.parameter import Parameter

{functioneer-0.4.2 → functioneer-0.5.0}/src/functioneer/analysis.py

@@ -20,13 +20,14 @@
 # THE SOFTWARE.
 
 
+import itertools
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import copy
 import pandas as pd
 from datetime import datetime
 import time
 
-from functioneer.steps import AnalysisStep, Define, Fork, Execute, Optimize
+from functioneer.steps import AnalysisStep, Define, Fork, Evaluate, Optimize
 from functioneer.parameter import ParameterSet, Parameter
 from functioneer.util import call_with_matched_kwargs
 
@@ -139,52 +140,75 @@ class AnalysisModule():
             else:
                 raise ValueError("Expected (param_id, value) or {param_id: value, ...}")
             
-        def fork(self, param_or_dict: Union[str, Dict[str, Tuple[Any, ...]]], value_set: Optional[Tuple[Any, ...]] = None, condition: Optional[Callable[..., bool]] = None) -> None:
-            """Fork analysis with a single parameter or dictionary of parameter value sets.
+        def fork(self, param_or_dict_or_configs: Union[str, Dict[str, Tuple[Any, ...]], List[Dict[str, Any]], Tuple[Dict[str, Any], ...]], 
+             value_list: Optional[Tuple[Any, ...]] = None, condition: Optional[Callable[..., bool]] = None) -> None:
+            """Fork analysis with a single parameter, dictionary of parameter value lists, or list of parameter configurations.
 
             Args:
-                param_or_dict: Parameter ID (str) or dictionary of parameter IDs to value sets.
-                value_set: Tuple of values for the parameter (if param_or_dict is a string).
+                param_or_dict_or_configs: Parameter ID (str), dictionary of parameter IDs to value lists, or list/tuple of parameter configurations.
+                value_list: Tuple of values for the parameter (if param_or_dict_or_configs is a string).
                 condition: Optional condition function to determine if the step should run.
 
             Examples:
                 >>> anal.add.fork('x', (0, 1, 2))  # Fork single parameter
-                >>> anal.add.fork({'x': (0, 1, 2), 'y': (0, 10, 20)})  # Fork multiple parameters
+                >>> anal.add.fork({'x': (0, 1), 'y': (10, 20)})  # Fork multiple parameters with value lists
+                >>> anal.add.fork([{'x': 0, 'y': 0}, {'x': 1, 'y': 10}])  # Fork with parameter configurations
 
             Raises:
-                ValueError: If inputs are invalid (e.g., wrong types, missing value_set, or value_set provided with dict).
+                ValueError: If inputs are invalid (e.g., wrong types, missing value_list, non-iterable value lists, or inconsistent configurations).
             """
-            if isinstance(param_or_dict, dict):
-                if value_set is not None:
-                    raise ValueError(
-                        "When forking multiple parameters with a dictionary, the 'value_set' argument is ignored. "
-                        "Use either fork(param_id: str, value_set: Tuple[Any, ...]) or fork(params: Dict[str, Tuple[Any, ...]])."
-                    )
-                self.parent.sequence.append(Fork(param_or_dict, condition))
-            elif isinstance(param_or_dict, str) and value_set is not None:
-                self.parent.sequence.append(Fork({param_or_dict: value_set}, condition))
+            if isinstance(param_or_dict_or_configs, str):
+                if value_list is None:
+                    raise ValueError("value_list must be provided for single parameter fork")
+                if not isinstance(value_list, (list, tuple)):
+                    raise ValueError("value_list must be a list or tuple of parameter values")
+                configurations = [{param_or_dict_or_configs: value} for value in value_list]
+            elif isinstance(param_or_dict_or_configs, dict):
+                param_ids = list(param_or_dict_or_configs.keys())
+                value_lists = list(param_or_dict_or_configs.values())
+                # Validate that value lists are iterable and same length
+                for vs in value_lists:
+                    if not isinstance(vs, (list, tuple)):
+                        raise ValueError("Value lists must be lists or tuples")
+                value_lengths = [len(values) for values in value_lists]
+                if not value_lengths:
+                    raise ValueError("param_value_lists dictionary cannot be empty")
+                if len(set(value_lengths)) > 1:
+                    raise ValueError("All value lists must have the same length")
+                
+                # Compute create configurations
+                value_configs = zip(*value_lists)
+                configurations = [dict(zip(param_ids, values)) for values in value_configs]
+
+            elif isinstance(param_or_dict_or_configs, (list, tuple)):
+                configurations = param_or_dict_or_configs
+                # Validate that configurations is a list of dictionaries
+                if not all(isinstance(config, dict) for config in configurations):
+                    raise ValueError("Configurations must be a list or tuple of dictionaries")
             else:
-                raise ValueError("Expected (param_id, value_set) or {param_id: value_set, ...}")
+                raise ValueError("Invalid input for fork: expected str, dict, or list/tuple of dicts")
+
+            self.parent.sequence.append(Fork(configurations, condition))
             
-        def execute(self, func: Callable[..., Any], assign_to: Optional[Union[str, List[str], Tuple[str, ...]]] = None, unpack_result: bool = False, condition: Optional[Callable[..., bool]] = None) -> None:
-            """Execute a function and store its result in the ParameterSet.
+        def evaluate(self, func: Callable[..., Any], assign_to: Optional[Union[str, List[str], Tuple[str, ...]]] = None, unpack_result: bool = False, condition: Optional[Callable[..., bool]] = None) -> None:
+            """Evaluate a function and store its result in the ParameterSet.
 
             Args:
-                func: Function to execute, taking parameter values as input.
+                func: Function to evaluate, taking parameter values as input.
                 assign_to: Custom Parameter ID(s) to store the result (str or list/tuple of strings).
                 unpack_result: If True, unpacks a dictionary result into multiple parameters.
                 condition: Optional condition function to determine if the step should run.
 
             Examples:
-                >>> anal.add.execute(my_function)  # Execute function, store result
-                >>> anal.add.execute(my_function, assign_to='new_param')  # Execute function, store result to param: 'new_param'
-                >>> anal.add.execute(my_function_returns_dict, unpack_result=True)  # Unpack dict result
-                >>> anal.add.execute(my_function_returns_dict, assign_to=['out_1', 'out_2'], unpack_result=True)  # Unpack only dict keys: out_1, out_2
+                >>> anal.add.evaluate(my_function)  # Evaluate function, store result
+                >>> anal.add.evaluate(my_function, assign_to='new_param')  # Evaluate function, store result to param: 'new_param'
+                >>> anal.add.evaluate(my_function_returns_dict, unpack_result=True)  # Unpack dict result
+                >>> anal.add.evaluate(my_function_returns_dict, assign_to=['out_1', 'out_2'], unpack_result=True)  # Unpack only dict keys: out_1, out_2
 
             Raises:
                 ValueError: If func is not callable or assign_to is invalid.
             """
-            self.parent.sequence.append(Execute(func, assign_to, unpack_result, condition))
+            self.parent.sequence.append(Evaluate(func, assign_to, unpack_result, condition))
                 
         def optimize(self, func: Callable[..., float], opt_param_ids: Tuple[str, ...], assign_to: Optional[str] = None, direction: str = 'min', optimizer: Union[str, Callable] = 'SLSQP', tol: Optional[float] = None, bounds: Optional[Dict[str, Tuple[float, float]]] = None, options: Optional[Dict[str, Any]] = None, condition: Optional[Callable[..., bool]] = None, **kwargs) -> None:
             """Optimize a function over specified parameters.
@@ -214,7 +238,7 @@ class AnalysisModule():
             # create_pandas = True,
             # verbose = True
         )  -> Dict[str, Any]:
-        """Execute the analysis sequence and return results including a DataFrame of leaf data.
+        """Evaluate the analysis sequence and return results including a DataFrame of leaf data.
 
         Returns:
             Dict[str, Any]: Dictionary containing the results DataFrame, runtime, and number of finished leaves.

{functioneer-0.4.2 → functioneer-0.5.0}/src/functioneer/steps.py

@@ -21,9 +21,7 @@
 
 
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-import logging
 import copy
-import warnings
 import numpy as np
 from scipy.optimize import minimize, dual_annealing, basinhopping, OptimizeResult
 
@@ -46,7 +44,7 @@ class AnalysisStep():
 
     def run(self, paramset: ParameterSet) -> Tuple[ParameterSet, ...]:
         """
-        Execute the analysis step, returning a tuple of modified ParameterSets.
+        Evaluate the analysis step, returning a tuple of modified ParameterSets.
 
         Parameters
         ----------
@@ -109,91 +107,79 @@ class Define(AnalysisStep):
     
 class Fork(AnalysisStep):
     """
-    Fork AnalysisStep: Splits analysis into parallel branches based on provided parameters and values.
-    Creates new parameters in ParameterSet if they do not already exist.
+    Fork AnalysisStep: Splits analysis into parallel branches based on provided parameter configurations.
+
+    Each configuration is a dictionary mapping parameter IDs to values. The analysis creates a new branch
+    for each configuration by updating the parameter set with the specified key-value pairs, adding new
+    parameters or overwriting existing ones as needed.
 
     Parameters
     ----------
-    param_id_or_ids : str or tuple/list of str
-        Parameter ID(s) to fork. Must be valid parameter IDs (non-empty strings, not reserved).
-    value_set_or_sets : tuple/list of values or tuple/list of tuples
-        Values to assign to the parameter(s) in each branch. For a single parameter, provide a
-        tuple/list of values. For multiple parameters, provide a tuple/list of tuples, where each
-        inner tuple contains values for the corresponding parameters. The number of value sets must
-        match the number of param_ids, and all inner value sets must have the same length.
+    configurations : list of dict
+        List of parameter configurations, where each dictionary contains parameter IDs (str) as keys
+        and their corresponding values. All configurations must share the same set of parameter IDs.
     condition : callable, optional
         Condition function to determine if the step should run.
 
     Raises
     ------
     ValueError
-        If param_id_or_ids are invalid, or if value_set_or_sets are not a non-empty tuple/list of
-        values/tuples with lengths matching param_ids and consistent across all value sets.
+        If configurations is not a list of dictionaries, is empty, contains inconsistent parameter IDs,
+        or includes invalid parameter IDs.
     TypeError
-        If condition is not callable or None.
+        If condition is provided but is not callable.
 
     Examples
     --------
-    >>> fork = Fork('x', (1, 2, 3))  # Single parameter fork
-    >>> fork = Fork(('x', 'y'), ((0, 1), (2, 3)))  # Multi-parameter fork
-    >>> fork = Fork(['x', 'y'], [(0, 1), (2, 3)])  # List input
+    >>> fork = Fork([{'x': 0}, {'x': 1}, {'x': 2}])  # Single parameter fork
+    >>> fork = Fork([{'x': 0, 'y': 10}, {'x': 1, 'y': 20}])  # Multi-parameter fork with configurations
     """
-    def __init__(self, param_value_sets: dict, condition: Callable[..., bool] | None = None):
+    def __init__(self, configurations: List[Dict[str, Any]], condition: Callable[..., bool] | None = None):
         super().__init__(condition)
-        if not isinstance(param_value_sets, dict):
-            raise ValueError("param_value_sets must be a dictionary with format {'param_id': (value1, value2, ...)}")
-        self.param_value_sets = param_value_sets
-
-        # Validate parameter IDs
-        for param_id in self.param_value_sets:
-            try:
-                Parameter.validate_id(param_id)
-            except ValueError as e:
-                raise ValueError(f"Invalid param_id '{param_id}': {str(e)}") from e
+        # Validate that configurations is a non-empty list of dictionaries
+        if not isinstance(configurations, (list, tuple)) or not all(isinstance(config, dict) for config in configurations):
+            raise ValueError("configurations must be a list or tuple of dictionaries")
+        if not configurations:
+            raise ValueError("configurations cannot be empty")
         
-        # Validate value sets
-        value_lengths = [len(values) for values in self.param_value_sets.values()]
-        if not value_lengths:
-            raise ValueError("param_value_sets dictionary cannot be empty")
-        if len(set(value_lengths)) > 1:
-            raise ValueError("All value sets in param_value_sets must have the same length")
-        self.value_cnt = value_lengths[0]
-
-        # TODO Validate value types
-        # this will be optional but left alone and values are tuples then it might be good to throw a warning in case user meant 
-        # raise ValueError(f"Warning: values of paramfork are of type 'tuple'. to silence this error set Parameter.value_type tot tuple")
-
-        # TODO: Provide one level higher of error handling at the analysis level that can provide context like step index.
+        self.configurations = list(configurations)  # Convert to list for consistency
+
+        # Validate parameter IDs and ensure consistency across configurations
+        # param_ids = set(self.configurations[0].keys())
+        for config in self.configurations:
+            # if set(config.keys()) != param_ids: # may turn on this optionally
+            #     raise ValueError("All configurations must have the same parameter IDs")
+            for param_id in config:
+                try:
+                    Parameter.validate_id(param_id)
+                except ValueError as e:
+                    raise ValueError(f"Invalid param_id '{param_id}': {str(e)}") from e
 
     def run(self, paramset: ParameterSet) -> Tuple[ParameterSet, ...]:
         super().run(paramset)
-        if self.value_cnt == 0:
-            return (paramset,)
-        
-        # Do forky stuff
         next_paramsets = []
-        for i in range(self.value_cnt):
+        for config in self.configurations:
             ps = copy.deepcopy(paramset)
-            for param_id, values in self.param_value_sets.items():
-                ps.update_param(param_id, values[i])
+            for param_id, value in config.items():
+                ps.update_param(param_id, value)  # Update or add parameter
             next_paramsets.append(ps)
         return tuple(next_paramsets)
-    
+
     def get_details(self) -> Dict[str, Any]:
         details = super().get_details()
         details.update({
-            'param_value_sets': self.param_value_sets
+            'configurations': self.configurations
         })
         return details
     
-class Execute(AnalysisStep):
+class Evaluate(AnalysisStep):
     """
-    Execute AnalysisStep: Executes a provided function and updates the ParameterSet with results.
+    Evaluate AnalysisStep: Evaluates a provided function and updates the ParameterSet with results.
 
     Parameters
     ----------
     func : callable
-        The function to execute. Output can be any type if unpack_result=False and assign_to is a string,
+        The function to evaluate. Output can be any type if unpack_result=False and assign_to is a string,
         or a dictionary if unpack_result=True.
     assign_to : str or iterable of str, optional
         Parameter ID(s) where the function output is stored. If a string and unpack_result=False, stores
@@ -212,14 +198,14 @@ class Execute(AnalysisStep):
     >>> anal = AnalysisModule({'x': 0, 'y': 0})
     >>> def add(x, y):
     ...     return x + y
-    >>> anal.add.execute(func=add, assign_to='sum')  # Stores scalar 0 in 'sum'
-    >>> anal.add.execute(func=add)  # Stores scalar 0 in 'add'
+    >>> anal.add.evaluate(func=add, assign_to='sum')  # Stores scalar 0 in 'sum'
+    >>> anal.add.evaluate(func=add)  # Stores scalar 0 in 'add'
     >>> def dict_func(x, y):
     ...     return {'sum': x + y, 'product': x * y}
-    >>> anal.add.execute(func=dict_func, assign_to='results')  # Stores {'sum': 0, 'product': 0} in 'results'
-    >>> anal.add.execute(func=dict_func, assign_to=['sum', 'product'], unpack_result=True)  # Stores sum=0, product=0
-    >>> anal.add.execute(func=dict_func, unpack_result=True)  # Unpacks sum=0, product=0
-    >>> anal.add.execute(func=lambda x, y: [x, y], assign_to='list_result')  # Stores [0, 0] in 'list_result'
+    >>> anal.add.evaluate(func=dict_func, assign_to='results')  # Stores {'sum': 0, 'product': 0} in 'results'
+    >>> anal.add.evaluate(func=dict_func, assign_to=['sum', 'product'], unpack_result=True)  # Stores sum=0, product=0
+    >>> anal.add.evaluate(func=dict_func, unpack_result=True)  # Unpacks sum=0, product=0
+    >>> anal.add.evaluate(func=lambda x, y: [x, y], assign_to='list_result')  # Stores [0, 0] in 'list_result'
     """
     def __init__(self,
             func: Callable,
@@ -231,7 +217,7 @@ class Execute(AnalysisStep):
 
         # Validate func
         if not isinstance(func, Callable):
-            raise ValueError("Invalid Execute: 'func' must be a callable")
+            raise ValueError("Invalid Evaluate: 'func' must be a callable")
         self.func = func
 
         # Handle assign_to
@@ -243,34 +229,34 @@ class Execute(AnalysisStep):
         # Handle unpack_result
         self.unpack_result = unpack_result if unpack_result is not None else False
         if not isinstance(self.unpack_result, bool):
-            raise ValueError(f"Invalid Execute: 'unpack_result' must be a boolean, got {type(self.unpack_result)}")
+            raise ValueError(f"Invalid Evaluate: 'unpack_result' must be a boolean, got {type(self.unpack_result)}")
 
         # Validate assign_to
         if isinstance(assign_to, str):
             try:
                 Parameter.validate_id(assign_to)
             except ValueError as e:
-                raise ValueError(f"Invalid Execute: 'assign_to' is not a valid param id, got {assign_to}: {str(e)}") from e
+                raise ValueError(f"Invalid Evaluate: 'assign_to' is not a valid param id, got {assign_to}: {str(e)}") from e
             self.assign_to = assign_to
         elif isinstance(assign_to, (list, tuple)) and assign_to:
             try:
                 Parameter.validate_id_iterable(assign_to)
             except ValueError as e:
-                raise ValueError(f"Invalid Execute: 'assign_to' must be a valid iterable of param ids, got {assign_to}: {str(e)}") from e
+                raise ValueError(f"Invalid Evaluate: 'assign_to' must be a valid iterable of param ids, got {assign_to}: {str(e)}") from e
             self.assign_to = tuple(assign_to)
         else:
-            raise ValueError(f"Invalid Execute: 'assign_to' must be a string or non-empty iterable of strings, got {assign_to}")
+            raise ValueError(f"Invalid Evaluate: 'assign_to' must be a string or non-empty iterable of strings, got {assign_to}")
         
         # Error if unpack_result is False and assign_to is tuple/list
         if not self.unpack_result and isinstance(self.assign_to, tuple):
             raise ValueError(
-                f"Invalid Execute: assign_to={self.assign_to} is a tuple/list, but unpack_result=False. "
+                f"Invalid Evaluate: assign_to={self.assign_to} is a tuple/list, but unpack_result=False. "
                 f"Try setting unpack_result=True to explicitly indicate a dictionary output (which a tuple/list 'assign_to' expects. "
             )
 
     def run(self, paramset: ParameterSet) -> Tuple[ParameterSet, ...]:
         """
-        Executes the function and updates the ParameterSet with the output.
+        Evaluates the function and updates the ParameterSet with the output.
 
         Parameters
         ----------
@@ -304,18 +290,18 @@ class Execute(AnalysisStep):
         if self.unpack_result:
             if not isinstance(output, dict):
                 raise ValueError(
-                    f"Execute: Expected dictionary output for unpack_result=True, "
+                    f"Evaluate: Expected dictionary output for unpack_result=True, "
                     f"got {type(output)} with value {output}"
                 )
             if not output:
-                raise ValueError("Execute: Output dictionary is empty for unpack_result=True")
+                raise ValueError("Evaluate: Output dictionary is empty for unpack_result=True")
             
             # Use specified keys if assign_to is a tuple/list
             if isinstance(self.assign_to, tuple):
                 for key in self.assign_to:
                     if key not in output:
                         raise ValueError(
-                            f"Execute: Output dictionary missing key '{key}' for assign_to={self.assign_to}"
+                            f"Evaluate: Output dictionary missing key '{key}' for assign_to={self.assign_to}"
                         )
                     next_paramset.update_param(key, output[key])    
 
@@ -325,7 +311,7 @@ class Execute(AnalysisStep):
                     try:
                         Parameter.validate_id(key)
                     except ValueError as e:
-                        raise ValueError(f"Execute: Output key '{key}' is not a valid param id: {str(e)}") from e
+                        raise ValueError(f"Evaluate: Output key '{key}' is not a valid param id: {str(e)}") from e
                     next_paramset.update_param(key, value)
 
         # Handle any output type (unpack_result=False, string assign_to)

{functioneer-0.4.2 → functioneer-0.5.0/src/functioneer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: functioneer
-Version: 0.4.2
+Version: 0.5.0
 Summary: Effortlessly explore function behavior with the ultimate batch runner.
 Author-email: Quinn Marsh <quinnmarsh@hotmail.com>
 Maintainer-email: Quinn Marsh <quinnmarsh@hotmail.com>
@@ -71,7 +71,7 @@ analysis = fn.AnalysisModule() # Create new analysis
 analysis.add.define({'a': 1, 'b': 100}) # define a and b
 analysis.add.fork('x', (0, 1, 2)) # Fork analysis, create branches for x=0, x=1, x=2
 analysis.add.fork('y', (1, 10))
-analysis.add.execute(func=rosenbrock) #
+analysis.add.evaluate(func=rosenbrock) #
 results = analysis.run()
 print('Example 1 Output:')
 print(results['df'][['a', 'b', 'x', 'y', 'rosenbrock']])
@@ -132,7 +132,7 @@ At its core, functioneer organizes analyses as a tree where a *set of parameters
 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
+- Evaluate: 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>