Merge pull request #76 from BlockScience/staging

Update README.md

.gitignore

@@ -1,7 +1,9 @@
 .idea
+jupyter notebook
 .ipynb_checkpoints
 .DS_Store
 .idea
+.pytest_cache/
 notebooks
 *.egg-info
 __pycache__
@@ -10,11 +12,19 @@ Pipfile.lock
 results
 .mypy_cache
 *.csv
-*.txt
 simulations/.ipynb_checkpoints
 simulations/validation/config3.py
-dist/*.gz
 cadCAD.egg-info
 
 build
-SimCAD.egg-info
+cadCAD.egg-info
+
+testing/example.py
+testing/example2.py
+testing/multi_config_test.py
+testing/udo.py
+testing/udo_test.py
+
+Simulation.md
+
+monkeytype.sqlite3

AUTHORS.txt

@@ -0,0 +1,29 @@
+Authors
+=======
+
+cadCAD was originally implemented by Joshua E. Jodesty and designed by Michael Zargham, Markus B. Koch, and
+Matthew V. Barlin from 2018 to 2019.
+
+
+Project Maintainers:
+- Joshua E. Jodesty <joshua@block.science, joshua.jodesty@gmail.com>
+- Markus B. Koch <markus@block.science>
+
+
+Contributors:
+- Joshua E. Jodesty
+- Markus B. Koch
+- Matthew V. Barlin
+- Michael Zargham
+- Zixuan Zhang
+- Charles Rice
+
+
+We’d also like to thank:
+- Andrew Clark
+- Nikhil Jamdade
+- Nick Hirannet
+- Jonathan Gabler
+- Chris Frazier
+- Harry Goodnight
+- Charlie Hoppes

CONTRIBUTING.md

@@ -0,0 +1,21 @@
+# Contributing to cadCAD (Draft)
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+The following is a set of guidelines for contributing to cadCAD. These are mostly guidelines, not rules. 
+Use your best judgment, and feel free to propose changes to this document in a pull request.
+
+### Pull Requests:
+
+Pull Request (PR) presented as "->".
+
+General Template:
+fork/branch -> BlockScience/staging
+
+Contributing a new feature:
+fork/feature -> BlockScience/staging
+
+Contributing to an existing feature:
+fork/feature -> BlockScience/feature
+
+Thanks! :heart:

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2019 BlockScience
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,82 +1,50 @@
-# SimCad
-**Warning**:
-**Do not** publish this package / software to **any** software repository **except** one permitted by BlockScience.  
+```
+                    __________   ____
+  ________ __ _____/ ____/   |  / __ \
+ / ___/ __` / __  / /   / /| | / / / /
+/ /__/ /_/ / /_/ / /___/ ___ |/ /_/ /
+\___/\__,_/\__,_/\____/_/  |_/_____/
+by BlockScience
+======================================
+       Complex Adaptive Dynamics       
+       o       i        e
+       m       d        s
+       p       e        i
+       u       d        g
+       t                n
+       e
+       r
+```
+***cadCAD*** is a Python package that assists in the processes of designing, testing and validating complex systems through simulation, with support for Monte Carlo methods, A/B testing and parameter sweeping. 
 
-**Description:**
+# Getting Started
+## 1. Installation: 
+Requires [Python 3](https://www.python.org/downloads/) 
 
-SimCAD is a differential games based simulation software package for research, validation, and Computer \
-Aided Design of economic systems. An economic system is treated as a state based model and defined through a \
-set of endogenous and exogenous state variables which are updated through mechanisms and environmental \
-processes, respectively. Behavioral models, which may be deterministic or stochastic, provide the evolution of \
-the system within the action space of the mechanisms. Mathematical formulations of these economic games \
-treat agent utility as derived from state rather than direct from action, creating a rich dynamic modeling framework. 
-
-Simulations may be run with a range of initial conditions and parameters for states, behaviors, mechanisms, \
-and environmental processes to understand and visualize network behavior under various conditions. Support for \
-A/B testing policies, monte carlo analysis and other common numerical methods is provided.
-
-SimCAD is written in Python 3.
-
-**1. Install Dependencies:**
+**Option A: Install Using [pip](https://pypi.org/project/cadCAD/)** 
 ```bash
+pip3 install cadCAD
+```
+
+**Option B:** Build From Source
+```
 pip3 install -r requirements.txt
 python3 setup.py sdist bdist_wheel
-pip3 install dist/cadCAD-0.1-py3-none-any.whl
+pip3 install dist/*.whl
 ```
 
-**2. Configure Simulation:**
+ 
+## 2. Learn the basics
+**Tutorials:** available both as [Jupyter Notebooks](tutorials) 
+and [videos](https://www.youtube.com/watch?v=uJEiYHRWA9g&list=PLmWm8ksQq4YKtdRV-SoinhV6LbQMgX1we) 
 
-Intructions:
-`/Simulation.md`
+Familiarize yourself with some system modelling concepts and cadCAD terminology.
 
-Examples:
-`/simulations/validation/*`
+## 3. Documentation:
+* [System Model Configuration](documentation)
+* [System Simulation Execution](documentation/Simulation_Execution.md)
+* [Policy Aggregation](documentation/Policy_Aggregation.md)
+* [System Model Parameter Sweep](documentation/System_Model_Parameter_Sweep.md)
 
-**3. Import SimCAD & Run Simulation:**
-
-Examples: `/simulations/example_run.py` or `/simulations/example_run.ipynb`
-
-`/simulations/example_run.py`:
-```python
-import pandas as pd
-from tabulate import tabulate
-
-# The following imports NEED to be in the exact order
-from SimCAD.engine import ExecutionMode, ExecutionContext, Executor
-from validation import config1, config2
-from SimCAD import configs
-
-exec_mode = ExecutionMode()
-
-print("Simulation Execution 1")
-print()
-first_config = [configs[0]] # from config1
-single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
-run1 = Executor(exec_context=single_proc_ctx, configs=first_config)
-run1_raw_result, tensor_field = run1.main()
-result = pd.DataFrame(run1_raw_result)
-print()
-print("Tensor Field:")
-print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
-print("Output:")
-print(tabulate(result, headers='keys', tablefmt='psql'))
-print()
-
-print("Simulation Execution 2: Pairwise Execution")
-print()
-multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
-run2 = Executor(exec_context=multi_proc_ctx, configs=configs)
-for raw_result, tensor_field in run2.main():
-    result = pd.DataFrame(raw_result)
-    print()
-    print("Tensor Field:")
-    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
-    print("Output:")
-    print(tabulate(result, headers='keys', tablefmt='psql'))
-    print()
-```
-
-The above can be run in Jupyter. 
-```bash
-jupyter notebook
-```
+## 4. Connect
+Find other cadCAD users at our [Discourse](https://community.cadcad.org/). We are a small but rapidly growing community.

Simulation.md

@@ -1,151 +0,0 @@
-# SimCAD Documentation
-
-## Introduction
-
-A blockchain is a distributed ledger with economic agents transacting in a network. The state of the network evolves with every new transaction, which can be a result of user behaviors, protocol-defined system mechanisms, or external processes.
-
-It is not uncommon today for blockchain projects to announce a set of rules for their network and make claims about their system level behavior. However, the validity of those claims is hardly validated. Furthermore, it is difficult to know the potential system-level impact when the network is considering an upgrade to their system rules and parameters.
-
-To rigorously and reliably analyze, design, and improve cryptoeconomic networks, we are introducing this Computer Aided Design Engine where we define a cryptoeconomic network with its state and exogneous variables, model transactions as a result of agent behaviors, state mechanisms, and environmental processes. We can then run simulations with different initial states, mechanisms, environmental processes to understand and visualize network behavior under different conditions.
-
-## State Variables and Transitions
-
-We now define variables and different transition mechanisms that will be inputs to the simulation engine.
-
-- ***State variables*** are defined to capture the shape and property of the network, such as a vector or a dictionary that captures all user balances.
-- ***Exogenous variables*** are variables that represent external input and signal. They are only affected by environmental processes and are not affected by system mechanisms. Nonetheless, exgoneous variables can be used as an input to a mechanism that impacts state variables. They can be considered as read-only variables to the system.
-- ***Behaviors per transition*** model agent behaviors in reaction to state variables and exogenous variables. The resulted user action will become an input to state mechanisms. Note that user behaviors should not directly update value of state variables. 
-- ***State mechanisms per transition*** are system defined mechanisms that take user actions and other states as inputs and produce updates to the value of state variables.
-- ***Exogenous state updates*** specify how exogenous variables evolve with time which can indirectly impact state variables through behavior and state mechanisms.
-- ***Environmental processes*** model external changes that directly impact state or exogenous variables at specific timestamps or conditions. 
-
-A state evolves to another state via state transition. Each transition is composed of behavior and state mechanisms as functions of state and exogenous variables. A flow of the state transition is as follows.
-
-Given some state and exogenous variables of the system at the onset of a state transition, agent behavior takes in these variables as input and return a set of agent actions. This models after agent behavior and reaction to a set of variables. Given these agent actions, state mechanism, as defined by the protocol, takes these actions, state, and exogenous variables as inputs and return a new set of state variables.
-
-## System Configuration File
-
-Simulation engine takes in system configuration files, e.g. `config.py`, where all the above variables and mechanisms are defined. The following import statements should be added at the beginning of the configuration files.
-```python
-from decimal import Decimal
-import numpy as np
-from datetime import timedelta
-
-from SimCAD import configs
-from SimCAD.configuration import Configuration
-from SimCAD.configuration.utils import exo_update_per_ts, proc_trigger, bound_norm_random, \
-    ep_time_step
-```
-
-State variables and their initial values can be defined as follows. Note that `timestamp` is a required field for this iteration of SimCAD for `env_proc` to work. Future iterations will strive to make this more generic and timestamp optional.
-```python
-genesis_dict = {
-    's1': Decimal(0.0),
-    's2': Decimal(0.0),
-    's3': Decimal(1.0),
-    'timestamp': '2018-10-01 15:16:24'
-}
-```
-
-Each potential transition and its state and behavior mechanisms can be defined in the following dictionary object.
-```python
-transitions = {
-    "m1": {
-        "behaviors": {
-            "b1": b1m1,
-            "b2": b2m1
-        },
-        "states": {
-            "s1": s1m1,
-            "s2": s2m1
-        }
-    },
-    "m2": {...}
-}
-```
-Every behavior per transition should return a dictionary as actions taken by the agents. They will then be aggregated through addition in this version of SimCAD. Some examples of behaviors per transition are as follows. More flexible and user-defined aggregation functions will be introduced in future iterations but no example is provided at this point. 
-```python
-def b1m1(step, sL, s):
-    return {'param1': 1}
-
-def b1m2(step, sL, s):
-    return {'param1': 'a', 'param2': 2}
-
-def b1m3(step, sL, s):
-    return {'param1': ['c'], 'param2': np.array([10, 100])}
-```
-State mechanism per transition on the other hand takes in the output of behavior mechanisms (`_input`) and returns a tuple of the name of the variable and the new value for the variable. Some examples of a state mechanism per transition are as follows. Note that each state mechanism is supposed to change one state variable at a time. Changes to multiple state variables should be done in separate mechanisms.
-```python
-def s1m1(step, sL, s, _input):
-    y = 's1'
-    x = _input['param1'] + 1
-    return (y, x)
-
-def s1m2(step, sL, s, _input):
-    y = 's1'
-    x = _input['param1']
-    return (y, x)
-```
-Exogenous state update functions, for example `es3p1`, `es4p2` and `es5p2` below, update exogenous variables at every timestamp. Note that every timestamp is consist of all behaviors and state mechanisms in the order defined in `transitions` dictionary. If `exo_update_per_ts` is not used, exogenous state updates will be applied at every mechanism step (`m1`, `m2`, etc). Otherwise, exogenous state updates will only be applied once for every timestamp after all the mechanism steps are executed.
-```python
-exogenous_states = exo_update_per_ts(
-    {
-    "s3": es3p1,
-    "s4": es4p2,
-    "timestamp": es5p2
-    }
-)
-```
-To model randomness, we should also define pseudorandom seeds in the configuration as follows.
-```python
-seed = {
-    'z': np.random.RandomState(1),
-    'a': np.random.RandomState(2),
-    'b': np.random.RandomState(3),
-    'c': np.random.RandomState(3)
-}
-```
-SimCAD currently supports generating random number from a normal distribution through `bound_norm_random` with `min` and `max` values specified. Examples of environmental processes with randomness are as follows. We also define timestamp format with `ts_format` and timestamp changes with `t_delta`. Users can define other distributions to update exogenous variables.
-```python
-proc_one_coef_A = 0.7
-proc_one_coef_B = 1.3
-
-def es3p1(step, sL, s, _input):
-    y = 's3'
-    x = s['s3'] * bound_norm_random(seed['a'], proc_one_coef_A, proc_one_coef_B)
-    return (y, x)
-
-def es4p2(step, sL, s, _input):
-    y = 's4'
-    x = s['s4'] * bound_norm_random(seed['b'], proc_one_coef_A, proc_one_coef_B)
-    return (y, x)
-
-ts_format = '%Y-%m-%d %H:%M:%S'
-t_delta = timedelta(days=0, minutes=0, seconds=1)
-def es5p2(step, sL, s, _input):
-    y = 'timestamp'
-    x = ep_time_step(s, s['timestamp'], fromat_str=ts_format, _timedelta=t_delta)
-    return (y, x)
-```
-User can also define specific external events such as market shocks at specific timestamps through `env_processes` with `proc_trigger`. An environmental process with no `proc_trigger` will be called at every timestamp. In the example below, it will return the value of `s3` at every timestamp. Logical event triggers, such as a big draw down in exogenous variables, will be supported in a later version of SimCAD. 
-```python
-def env_a(x):
-    return x
-def env_b(x):
-    return 10
-
-env_processes = {
-    "s3": env_a,
-    "s4": proc_trigger('2018-10-01 15:16:25', env_b)
-}
-```
-
-Lastly, we set the overall simulation configuration and initialize the `Configuration` class with the following. `T` denotes the time range and `N` refers to the number of simulation runs. Each run will start from the same initial states and run for `T` time range. Every transition is consist of behaviors, state mechanisms, exogenous updates, and potentially environmental processes. All of these happen within one time step in the simulation.
-```python
-sim_config = {
-    "N": 2,
-    "T": range(5)
-}
-
-configs.append(Configuration(sim_config, state_dict, seed, exogenous_states, env_processes, mechanisms))
-```

ascii_art.txt

@@ -0,0 +1,15 @@
+Complex Adaptive Dynamics
+o       i        e
+m       d        s
+p       e        i
+u       d        g
+t                n
+e
+r
+
+                    __________   ____
+  ________ __ _____/ ____/   |  / __ \
+ / ___/ __` / __  / /   / /| | / / / /
+/ /__/ /_/ / /_/ / /___/ ___ |/ /_/ /
+\___/\__,_/\__,_/\____/_/  |_/_____/
+by BlockScience

cadCAD/configuration/__init__.py

@@ -1,16 +1,20 @@
+from typing import Dict, Callable, List, Tuple
 from functools import reduce
-from fn.op import foldr
 import pandas as pd
+from pandas.core.frame import DataFrame
 
 from cadCAD import configs
 from cadCAD.utils import key_filter
-from cadCAD.configuration.utils.policyAggregation import dict_elemwise_sum
 from cadCAD.configuration.utils import exo_update_per_ts
+from cadCAD.configuration.utils.policyAggregation import dict_elemwise_sum
+from cadCAD.configuration.utils.depreciationHandler import sanitize_partial_state_updates, sanitize_config
 
 
 class Configuration(object):
     def __init__(self, sim_config={}, initial_state={}, seeds={}, env_processes={},
-                 exogenous_states={}, partial_state_update_blocks={}, policy_ops=[foldr(dict_elemwise_sum())], **kwargs):
+                 exogenous_states={}, partial_state_update_blocks={}, policy_ops=[lambda a, b: a + b],
+                 **kwargs) -> None:
+        # print(exogenous_states)
         self.sim_config = sim_config
         self.initial_state = initial_state
         self.seeds = seeds
@@ -18,56 +22,53 @@ class Configuration(object):
         self.exogenous_states = exogenous_states
         self.partial_state_updates = partial_state_update_blocks
         self.policy_ops = policy_ops
+        self.kwargs = kwargs
+
+        sanitize_config(self)
 
 
-def append_configs(sim_configs, initial_state, seeds, raw_exogenous_states, env_processes, partial_state_update_blocks, _exo_update_per_ts=True):
+def append_configs(sim_configs={}, initial_state={}, seeds={}, raw_exogenous_states={}, env_processes={},
+                   partial_state_update_blocks={}, policy_ops=[lambda a, b: a + b], _exo_update_per_ts: bool = True) -> None:
     if _exo_update_per_ts is True:
         exogenous_states = exo_update_per_ts(raw_exogenous_states)
     else:
         exogenous_states = raw_exogenous_states
 
-    if isinstance(sim_configs, list):
-        for sim_config in sim_configs:
-            configs.append(
-                Configuration(
-                    sim_config=sim_config,
-                    initial_state=initial_state,
-                    seeds=seeds,
-                    exogenous_states=exogenous_states,
-                    env_processes=env_processes,
-                    partial_state_update_blocks=partial_state_update_blocks
-                )
-            )
-    elif isinstance(sim_configs, dict):
-        configs.append(
-            Configuration(
-                sim_config=sim_configs,
-                initial_state=initial_state,
-                seeds=seeds,
-                exogenous_states=exogenous_states,
-                env_processes=env_processes,
-                partial_state_update_blocks=partial_state_update_blocks
-            )
+    if isinstance(sim_configs, dict):
+        sim_configs = [sim_configs]
+
+    for sim_config in sim_configs:
+        config = Configuration(
+            sim_config=sim_config,
+            initial_state=initial_state,
+            seeds=seeds,
+            exogenous_states=exogenous_states,
+            env_processes=env_processes,
+            partial_state_update_blocks=partial_state_update_blocks,
+            policy_ops=policy_ops
         )
+        print(sim_configs)
+        #for each sim config create new config
+        configs.append(config)
 
 
 class Identity:
-    def __init__(self, policy_id={'identity': 0}):
+    def __init__(self, policy_id: Dict[str, int] = {'identity': 0}) -> None:
         self.beh_id_return_val = policy_id
 
     def p_identity(self, var_dict, sub_step, sL, s):
         return self.beh_id_return_val
 
-    def policy_identity(self, k):
+    def policy_identity(self, k: str) -> Callable:
         return self.p_identity
 
     def no_state_identity(self, var_dict, sub_step, sL, s, _input):
         return None
 
-    def state_identity(self, k):
+    def state_identity(self, k: str) -> Callable:
         return lambda var_dict, sub_step, sL, s, _input: (k, s[k])
 
-    def apply_identity_funcs(self, identity, df, cols):
+    def apply_identity_funcs(self, identity: Callable, df: DataFrame, cols: List[str]) -> List[DataFrame]:
         def fillna_with_id_func(identity, df, col):
             return df[[col]].fillna(value=identity(col))
 
@@ -75,7 +76,7 @@ class Identity:
 
 
 class Processor:
-    def __init__(self, id=Identity()):
+    def __init__(self, id: Identity = Identity()) -> None:
         self.id = id
         self.p_identity = id.p_identity
         self.policy_identity = id.policy_identity
@@ -83,11 +84,12 @@ class Processor:
         self.state_identity = id.state_identity
         self.apply_identity_funcs = id.apply_identity_funcs
 
-    def create_matrix_field(self, partial_state_updates, key):
+    def create_matrix_field(self, partial_state_updates, key: str) -> DataFrame:
         if key == 'variables':
             identity = self.state_identity
         elif key == 'policies':
             identity = self.policy_identity
+
         df = pd.DataFrame(key_filter(partial_state_updates, key))
         col_list = self.apply_identity_funcs(identity, df, list(df.columns))
         if len(col_list) != 0:
@@ -95,7 +97,8 @@ class Processor:
         else:
             return pd.DataFrame({'empty': []})
 
-    def generate_config(self, initial_state, partial_state_updates, exo_proc):
+    def generate_config(self, initial_state, partial_state_updates, exo_proc
+                       ) -> List[Tuple[List[Callable], List[Callable]]]:
 
         def no_update_handler(bdf, sdf):
             if (bdf.empty == False) and (sdf.empty == True):
@@ -120,6 +123,9 @@ class Processor:
             return sdf_values, bdf_values
 
         if len(partial_state_updates) != 0:
+            # backwards compatibility # ToDo: Move this
+            partial_state_updates = sanitize_partial_state_updates(partial_state_updates)
+
             bdf = self.create_matrix_field(partial_state_updates, 'policies')
             sdf = self.create_matrix_field(partial_state_updates, 'variables')
             sdf_values, bdf_values = no_update_handler(bdf, sdf)

cadCAD/configuration/utils/__init__.py

@@ -1,17 +1,23 @@
 from datetime import datetime, timedelta
-from decimal import Decimal
 from copy import deepcopy
+from functools import reduce
 from fn.func import curried
+from funcy import curry
 import pandas as pd
 
-from cadCAD.utils import dict_filter, contains_type
+from cadCAD.configuration.utils.depreciationHandler import sanitize_partial_state_updates
+from cadCAD.utils import dict_filter, contains_type, flatten_tabulated_dict, tabulate_dict
 
 
 class TensorFieldReport:
     def __init__(self, config_proc):
         self.config_proc = config_proc
 
-    def create_tensor_field(self, partial_state_updates, exo_proc, keys=['policies', 'variables']):
+    # ToDo: backwards compatibility
+    def create_tensor_field(self, partial_state_updates, exo_proc, keys = ['policies', 'variables']):
+
+        partial_state_updates = sanitize_partial_state_updates(partial_state_updates) # Temporary
+
         dfs = [self.config_proc.create_matrix_field(partial_state_updates, k) for k in keys]
         df = pd.concat(dfs, axis=1)
         for es, i in zip(exo_proc, range(len(exo_proc))):
@@ -20,44 +26,43 @@ class TensorFieldReport:
         return df
 
 
-# def s_update(y, x):
-#     return lambda step, sL, s, _input: (y, x)
-#
-#
 def state_update(y, x):
-    return lambda sub_step, sL, s, _input: (y, x)
+    return lambda var_dict, sub_step, sL, s, _input: (y, x)
 
 
 def bound_norm_random(rng, low, high):
     res = rng.normal((high+low)/2, (high-low)/6)
     if res < low or res > high:
         res = bound_norm_random(rng, low, high)
-    return Decimal(res)
+    # return Decimal(res)
+    return float(res)
 
 
 @curried
-def proc_trigger(trigger_time, update_f, time):
-    if time == trigger_time:
-        return update_f
+def env_proc_trigger(timestep, f, time):
+    if time == timestep:
+        return f
     else:
         return lambda x: x
 
 
 tstep_delta = timedelta(days=0, minutes=0, seconds=30)
 def time_step(dt_str, dt_format='%Y-%m-%d %H:%M:%S', _timedelta = tstep_delta):
+    # print(dt_str)
     dt = datetime.strptime(dt_str, dt_format)
     t = dt + _timedelta
     return t.strftime(dt_format)
 
 
 ep_t_delta = timedelta(days=0, minutes=0, seconds=1)
-def ep_time_step(s, dt_str, fromat_str='%Y-%m-%d %H:%M:%S', _timedelta = ep_t_delta):
-    if s['substep'] == 0:
+def ep_time_step(s_condition, dt_str, fromat_str='%Y-%m-%d %H:%M:%S', _timedelta = ep_t_delta):
+    # print(dt_str)
+    if s_condition:
         return time_step(dt_str, fromat_str, _timedelta)
     else:
         return dt_str
 
-# mech_sweep_filter
+
 def partial_state_sweep_filter(state_field, partial_state_updates):
     partial_state_dict = dict([(k, v[state_field]) for k, v in partial_state_updates.items()])
     return dict([
@@ -69,7 +74,7 @@ def partial_state_sweep_filter(state_field, partial_state_updates):
 def state_sweep_filter(raw_exogenous_states):
     return dict([(k, v) for k, v in raw_exogenous_states.items() if isinstance(v, list)])
 
-# sweep_mech_states
+
 @curried
 def sweep_partial_states(_type, in_config):
     configs = []
@@ -120,3 +125,99 @@ def exo_update_per_ts(ep):
             return y, s[y]
 
     return {es: ep_decorator(f, es) for es, f in ep.items()}
+
+
+def trigger_condition(s, pre_conditions, cond_opp):
+    condition_bools = [s[field] in precondition_values for field, precondition_values in pre_conditions.items()]
+    return reduce(cond_opp, condition_bools)
+
+
+def apply_state_condition(pre_conditions, cond_opp, y, f, _g, step, sL, s, _input):
+    if trigger_condition(s, pre_conditions, cond_opp):
+        return f(_g, step, sL, s, _input)
+    else:
+        return y, s[y]
+
+
+def var_trigger(y, f, pre_conditions, cond_op):
+    return lambda _g, step, sL, s, _input: apply_state_condition(pre_conditions, cond_op, y, f, _g, step, sL, s, _input)
+
+
+def var_substep_trigger(substeps):
+    def trigger(end_substep, y, f):
+        pre_conditions = {'substep': substeps}
+        cond_opp = lambda a, b: a and b
+        return var_trigger(y, f, pre_conditions, cond_opp)
+
+    return lambda y, f: curry(trigger)(substeps)(y)(f)
+
+
+def env_trigger(end_substep):
+    def trigger(end_substep, trigger_field, trigger_vals, funct_list):
+        def env_update(state_dict, sweep_dict, target_value):
+            state_dict_copy = deepcopy(state_dict)
+            # Use supstep to simulate current sysMetrics
+            if state_dict_copy['substep'] == end_substep:
+                state_dict_copy['timestep'] = state_dict_copy['timestep'] + 1
+
+            if state_dict_copy[trigger_field] in trigger_vals:
+                for g in funct_list:
+                    target_value = g(sweep_dict, target_value)
+
+            del state_dict_copy
+            return target_value
+
+        return env_update
+
+    return lambda trigger_field, trigger_vals, funct_list: \
+        curry(trigger)(end_substep)(trigger_field)(trigger_vals)(funct_list)
+
+
+def config_sim(d):
+    def process_variables(d):
+        return flatten_tabulated_dict(tabulate_dict(d))
+
+    if "M" in d:
+        return [{"N": d["N"], "T": d["T"], "M": M} for M in process_variables(d["M"])]
+    else:
+        d["M"] = [{}]
+        return d
+
+
+def psub_list(psu_block, psu_steps):
+    return [psu_block[psu] for psu in psu_steps]
+
+
+def psub(policies, state_updates):
+    return {
+        'policies': policies,
+        'states': state_updates
+    }
+
+
+def genereate_psubs(policy_grid, states_grid, policies, state_updates):
+    PSUBS = []
+    for policy_ids, state_list in zip(policy_grid, states_grid):
+        filtered_policies = {k: v for (k, v) in policies.items() if k in policy_ids}
+        filtered_state_updates = {k: v for (k, v) in state_updates.items() if k in state_list}
+        PSUBS.append(psub(filtered_policies, filtered_state_updates))
+
+    return PSUBS
+
+
+def access_block(state_history, target_field, psu_block_offset, exculsion_list=[]):
+    exculsion_list += [target_field]
+    def filter_history(key_list, sH):
+        filter = lambda key_list: \
+            lambda d: {k: v for k, v in d.items() if k not in key_list}
+        return list(map(filter(key_list), sH))
+
+    if psu_block_offset < -1:
+        if len(state_history) >= abs(psu_block_offset):
+            return filter_history(exculsion_list, state_history[psu_block_offset])
+        else:
+            return []
+    elif psu_block_offset == -1:
+        return filter_history(exculsion_list, state_history[psu_block_offset])
+    else:
+        return []

cadCAD/configuration/utils/depreciationHandler.py

@@ -0,0 +1,35 @@
+from copy import deepcopy
+
+
+def sanitize_config(config):
+    for key, value in config.kwargs.items():
+        if key == 'state_dict':
+            config.initial_state = value
+        elif key == 'seed':
+            config.seeds = value
+        elif key == 'mechanisms':
+            config.partial_state_updates = value
+
+    if config.initial_state == {}:
+        raise Exception('The initial conditions of the system have not been set')
+
+
+def sanitize_partial_state_updates(partial_state_updates):
+    new_partial_state_updates = deepcopy(partial_state_updates)
+    def rename_keys(d):
+        if 'behaviors' in d:
+            d['policies'] = d.pop('behaviors')
+
+        if 'states' in d:
+            d['variables'] = d.pop('states')
+
+
+    if isinstance(new_partial_state_updates, list):
+        for v in new_partial_state_updates:
+            rename_keys(v)
+    elif isinstance(new_partial_state_updates, dict):
+        for k, v in new_partial_state_updates.items():
+            rename_keys(v)
+
+    del partial_state_updates
+    return new_partial_state_updates

cadCAD/configuration/utils/parameterSweep.py

@@ -1,20 +0,0 @@
-from cadCAD.utils import flatten_tabulated_dict, tabulate_dict
-
-
-def process_variables(d):
-    return flatten_tabulated_dict(tabulate_dict(d))
-
-
-def config_sim(d):
-    if "M" in d:
-        return [
-            {
-                "N": d["N"],
-                "T": d["T"],
-                "M": M
-            }
-            for M in process_variables(d["M"])
-        ]
-    else:
-        d["M"] = [{}]
-        return d

cadCAD/configuration/utils/policyAggregation.py

@@ -14,7 +14,7 @@ def get_base_value(x):
 
 
 def policy_to_dict(v):
-    return dict(list(zip(map(lambda n: 'b' + str(n + 1), list(range(len(v)))), v)))
+    return dict(list(zip(map(lambda n: 'p' + str(n + 1), list(range(len(v)))), v)))
 
 
 add = lambda a, b: a + b
@@ -41,6 +41,5 @@ def dict_op(f, d1, d2):
 
     return {k: f(set_base_value(d1, d2, k), set_base_value(d2, d1, k)) for k in key_set}
 
-
 def dict_elemwise_sum():
     return dict_op(add)

cadCAD/configuration/utils/userDefinedObject.py

@@ -0,0 +1,59 @@
+from collections import namedtuple
+from inspect import getmembers, ismethod
+from pandas.core.frame import DataFrame
+
+from cadCAD.utils import SilentDF
+
+
+def val_switch(v):
+    if isinstance(v, DataFrame) is True:
+        return SilentDF(v)
+    else:
+        return v
+
+
+class udcView(object):
+    def __init__(self, d, masked_members):
+        self.__dict__ = d
+        self.masked_members = masked_members
+
+    def __repr__(self):
+        members = {}
+        variables = {
+            k: val_switch(v) for k, v in self.__dict__.items()
+            if str(type(v)) != "<class 'method'>" and k not in self.masked_members # and isinstance(v, DataFrame) is not True
+        }
+        members['methods'] = [k for k, v in self.__dict__.items() if str(type(v)) == "<class 'method'>"]
+
+        members.update(variables)
+        return f"{members}"
+
+
+class udcBroker(object):
+    def __init__(self, obj, function_filter=['__init__']):
+        d = {}
+        funcs = dict(getmembers(obj, ismethod))
+        filtered_functions = {k: v for k, v in funcs.items() if k not in function_filter}
+        d['obj'] = obj
+        # d.update(deepcopy(vars(obj)))  # somehow is enough
+        d.update(vars(obj))  # somehow is enough
+        d.update(filtered_functions)
+
+        self.members_dict = d
+
+    def get_members(self):
+        return self.members_dict
+
+    def get_view(self, masked_members):
+        return udcView(self.members_dict, masked_members)
+
+    def get_namedtuple(self):
+        return namedtuple("Hydra", self.members_dict.keys())(*self.members_dict.values())
+
+
+def UDO(udo, masked_members=['obj']):
+    return udcBroker(udo).get_view(masked_members)
+
+
+def udoPipe(obj_view):
+    return UDO(obj_view.obj, obj_view.masked_members)

cadCAD/engine/__init__.py

@@ -1,33 +1,58 @@
-from pathos.multiprocessing import ProcessingPool as Pool
+from typing import Callable, Dict, List, Any, Tuple
+from pathos.multiprocessing import ProcessingPool as PPool
+from pandas.core.frame import DataFrame
 
 from cadCAD.utils import flatten
-from cadCAD.configuration import Processor
+from cadCAD.configuration import Configuration, Processor
 from cadCAD.configuration.utils import TensorFieldReport
 from cadCAD.engine.simulation import Executor as SimExecutor
 
+VarDictType = Dict[str, List[Any]]
+StatesListsType = List[Dict[str, Any]]
+ConfigsType = List[Tuple[List[Callable], List[Callable]]]
+EnvProcessesType = Dict[str, Callable]
+
 
 class ExecutionMode:
     single_proc = 'single_proc'
     multi_proc = 'multi_proc'
 
 
+def single_proc_exec(
+        simulation_execs: List[Callable],
+        var_dict_list: List[VarDictType],
+        states_lists: List[StatesListsType],
+        configs_structs: List[ConfigsType],
+        env_processes_list: List[EnvProcessesType],
+        Ts: List[range],
+        Ns: List[int]
+    ):
+    l = [simulation_execs, states_lists, configs_structs, env_processes_list, Ts, Ns]
+    simulation_exec, states_list, config, env_processes, T, N = list(map(lambda x: x.pop(), l))
+    result = simulation_exec(var_dict_list, states_list, config, env_processes, T, N)
+    return flatten(result)
+
+
+def parallelize_simulations(
+        simulation_execs: List[Callable],
+        var_dict_list: List[VarDictType],
+        states_lists: List[StatesListsType],
+        configs_structs: List[ConfigsType],
+        env_processes_list: List[EnvProcessesType],
+        Ts: List[range],
+        Ns: List[int]
+    ):
+    l = list(zip(simulation_execs, var_dict_list, states_lists, configs_structs, env_processes_list, Ts, Ns))
+    with PPool(len(configs_structs)) as p:
+        results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5], t[6]), l)
+    return results
+
+
 class ExecutionContext:
-    def __init__(self, context=ExecutionMode.multi_proc):
+    def __init__(self, context: str = ExecutionMode.multi_proc) -> None:
         self.name = context
         self.method = None
 
-        def single_proc_exec(simulation_execs, var_dict, states_lists, configs_structs, env_processes_list, Ts, Ns):
-            l = [simulation_execs, states_lists, configs_structs, env_processes_list, Ts, Ns]
-            simulation, states_list, config, env_processes, T, N = list(map(lambda x: x.pop(), l))
-            result = simulation(var_dict, states_list, config, env_processes, T, N)
-            return flatten(result)
-
-        def parallelize_simulations(fs, var_dict_list, states_list, configs, env_processes, Ts, Ns):
-            l = list(zip(fs, var_dict_list, states_list, configs, env_processes, Ts, Ns))
-            with Pool(len(configs)) as p:
-                results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5], t[6]), l)
-            return results
-
         if context == 'single_proc':
             self.method = single_proc_exec
         elif context == 'multi_proc':
@@ -35,21 +60,32 @@ class ExecutionContext:
 
 
 class Executor:
-    def __init__(self, exec_context, configs):
+    def __init__(self, exec_context: ExecutionContext, configs: List[Configuration]) -> None:
         self.SimExecutor = SimExecutor
         self.exec_method = exec_context.method
         self.exec_context = exec_context.name
         self.configs = configs
-        self.main = self.execute
 
-    def execute(self):
+    def execute(self) -> Tuple[List[Dict[str, Any]], DataFrame]:
         config_proc = Processor()
         create_tensor_field = TensorFieldReport(config_proc).create_tensor_field
 
-        print(self.exec_context+": "+str(self.configs))
+
+        print(r'''
+                            __________   ____ 
+          ________ __ _____/ ____/   |  / __ \
+         / ___/ __` / __  / /   / /| | / / / /
+        / /__/ /_/ / /_/ / /___/ ___ |/ /_/ / 
+        \___/\__,_/\__,_/\____/_/  |_/_____/  
+        by BlockScience
+        ''')
+        print(f'Execution Mode: {self.exec_context + ": " + str(self.configs)}')
+        print(f'Configurations: {self.configs}')
+
         var_dict_list, states_lists, Ts, Ns, eps, configs_structs, env_processes_list, partial_state_updates, simulation_execs = \
             [], [], [], [], [], [], [], [], []
         config_idx = 0
+
         for x in self.configs:
 
             Ts.append(x.sim_config['T'])
@@ -58,21 +94,26 @@ class Executor:
             states_lists.append([x.initial_state])
             eps.append(list(x.exogenous_states.values()))
             configs_structs.append(config_proc.generate_config(x.initial_state, x.partial_state_updates, eps[config_idx]))
+            # print(env_processes_list)
             env_processes_list.append(x.env_processes)
             partial_state_updates.append(x.partial_state_updates)
             simulation_execs.append(SimExecutor(x.policy_ops).simulation)
 
             config_idx += 1
 
+        final_result = None
+
         if self.exec_context == ExecutionMode.single_proc:
             tensor_field = create_tensor_field(partial_state_updates.pop(), eps.pop())
             result = self.exec_method(simulation_execs, var_dict_list, states_lists, configs_structs, env_processes_list, Ts, Ns)
-            return result, tensor_field
+            final_result = result, tensor_field
         elif self.exec_context == ExecutionMode.multi_proc:
-            if len(self.configs) > 1:
-                simulations = self.exec_method(simulation_execs, var_dict_list, states_lists, configs_structs, env_processes_list, Ts, Ns)
-                results = []
-                for result, partial_state_updates, ep in list(zip(simulations, partial_state_updates, eps)):
-                    results.append((flatten(result), create_tensor_field(partial_state_updates, ep)))
+            # if len(self.configs) > 1:
+            simulations = self.exec_method(simulation_execs, var_dict_list, states_lists, configs_structs, env_processes_list, Ts, Ns)
+            results = []
+            for result, partial_state_updates, ep in list(zip(simulations, partial_state_updates, eps)):
+                results.append((flatten(result), create_tensor_field(partial_state_updates, ep)))
 
-                return results
+            final_result = results
+
+        return final_result

cadCAD/engine/simulation.py

@@ -1,101 +1,234 @@
+from typing import Any, Callable, Dict, List, Tuple
+from pathos.pools import ThreadPool as TPool
 from copy import deepcopy
-from fn.op import foldr, call
+from functools import reduce
 
 from cadCAD.engine.utils import engine_exception
+from cadCAD.utils import flatten
 
-id_exception = engine_exception(KeyError, KeyError, None)
+id_exception: Callable = engine_exception(KeyError, KeyError, None)
 
 
 class Executor:
-    def __init__(self, policy_ops, policy_update_exception=id_exception, state_update_exception=id_exception):
-        self.policy_ops = policy_ops # behavior_ops
+    def __init__(
+        self,
+        policy_ops: List[Callable],
+        policy_update_exception: Callable = id_exception,
+        state_update_exception: Callable = id_exception
+    ) -> None:
+
+        self.policy_ops = policy_ops
         self.state_update_exception = state_update_exception
-        self.policy_update_exception = policy_update_exception # behavior_update_exception
+        self.policy_update_exception = policy_update_exception
 
-    # get_behavior_input
-    def get_policy_input(self, var_dict, sub_step, sL, s, funcs):
-        ops = self.policy_ops[::-1]
+    def get_policy_input(
+                self,
+                sweep_dict: Dict[str, List[Any]],
+                sub_step: int,
+                sL: List[Dict[str, Any]],
+                s: Dict[str, Any],
+                funcs: List[Callable]
+            ) -> Dict[str, Any]:
 
-        def get_col_results(var_dict, sub_step, sL, s, funcs):
-            return list(map(lambda f: f(var_dict, sub_step, sL, s), funcs))
+        ops = self.policy_ops
 
-        return foldr(call, get_col_results(var_dict, sub_step, sL, s, funcs))(ops)
+        def get_col_results(sweep_dict, sub_step, sL, s, funcs):
+            return list(map(lambda f: f(sweep_dict, sub_step, sL, s), funcs))
 
-    def apply_env_proc(self, env_processes, state_dict, sub_step):
-        for state in state_dict.keys():
-            if state in list(env_processes.keys()):
-                env_state = env_processes[state]
-                if (env_state.__name__ == '_curried') or (env_state.__name__ == 'proc_trigger'):
-                    state_dict[state] = env_state(sub_step)(state_dict[state])
+        def compose(init_reduction_funct, funct_list, val_list):
+            result, i = None, 0
+            composition = lambda x: [reduce(init_reduction_funct, x)] + funct_list
+            for g in composition(val_list):
+                if i == 0:
+                    result = g
+                    i = 1
                 else:
-                    state_dict[state] = env_state(state_dict[state])
+                    result = g(result)
+            return result
+
+        col_results = get_col_results(sweep_dict, sub_step, sL, s, funcs)
+        key_set = list(set(list(reduce(lambda a, b: a + b, list(map(lambda x: list(x.keys()), col_results))))))
+        new_dict = {k: [] for k in key_set}
+        for d in col_results:
+            for k in d.keys():
+                new_dict[k].append(d[k])
+
+        ops_head, *ops_tail = ops
+        return {
+            k: compose(
+                init_reduction_funct=ops_head, # func executed on value list
+                funct_list=ops_tail,
+                val_list=val_list
+            ) for k, val_list in new_dict.items()
+        }
+
+
+    def apply_env_proc(
+                self,
+                sweep_dict,
+                env_processes: Dict[str, Callable],
+                state_dict: Dict[str, Any],
+            ) -> Dict[str, Any]:
+
+        def env_composition(target_field, state_dict, target_value):
+            function_type = type(lambda x: x)
+            env_update = env_processes[target_field]
+            if isinstance(env_update, list):
+                for f in env_update:
+                    target_value = f(sweep_dict, target_value)
+            elif isinstance(env_update, function_type):
+                target_value = env_update(state_dict, sweep_dict, target_value)
+            else:
+                target_value = env_update
+
+            return target_value
+
+        filtered_state_dict = {k: v for k, v in state_dict.items() if k in env_processes.keys()}
+        env_proc_dict = {
+            target_field: env_composition(target_field, state_dict, target_value)
+            for target_field, target_value in filtered_state_dict.items()
+        }
+
+        for k, v in env_proc_dict.items():
+            state_dict[k] = v
+
+        return state_dict
 
     # mech_step
-    def partial_state_update(self, var_dict, sub_step, sL, state_funcs, policy_funcs, env_processes, time_step, run):
-        last_in_obj = sL[-1]
+    def partial_state_update(
+                self,
+                sweep_dict: Dict[str, List[Any]],
+                sub_step: int,
+                sL: Any,
+                sH: Any,
+                state_funcs: List[Callable],
+                policy_funcs: List[Callable],
+                env_processes: Dict[str, Callable],
+                time_step: int,
+                run: int
+            ) -> List[Dict[str, Any]]:
 
-        _input = self.policy_update_exception(self.get_policy_input(var_dict, sub_step, sL, last_in_obj, policy_funcs))
-
-        # ToDo: add env_proc generator to `last_in_copy` iterator as wrapper function
-        last_in_copy = dict(
-            [
-                self.state_update_exception(f(var_dict, sub_step, sL, last_in_obj, _input)) for f in state_funcs
-            ]
+        last_in_obj: Dict[str, Any] = deepcopy(sL[-1])
+        _input: Dict[str, Any] = self.policy_update_exception(
+            self.get_policy_input(sweep_dict, sub_step, sH, last_in_obj, policy_funcs)
         )
 
-        for k in last_in_obj:
-            if k not in last_in_copy:
-                last_in_copy[k] = last_in_obj[k]
 
-        del last_in_obj
+        def generate_record(state_funcs):
+            for f in state_funcs:
+                yield self.state_update_exception(f(sweep_dict, sub_step, sH, last_in_obj, _input))
 
-        self.apply_env_proc(env_processes, last_in_copy, last_in_copy['timestep']) # not time_step
+        def transfer_missing_fields(source, destination):
+            for k in source:
+                if k not in destination:
+                    destination[k] = source[k]
+            del source # last_in_obj
+            return destination
 
+        last_in_copy: Dict[str, Any] = transfer_missing_fields(last_in_obj, dict(generate_record(state_funcs)))
+        last_in_copy: Dict[str, Any] = self.apply_env_proc(sweep_dict, env_processes, last_in_copy)
         last_in_copy['substep'], last_in_copy['timestep'], last_in_copy['run'] = sub_step, time_step, run
+
         sL.append(last_in_copy)
         del last_in_copy
 
         return sL
 
-    # mech_pipeline
-    def state_update_pipeline(self, var_dict, states_list, configs, env_processes, time_step, run):
+    # mech_pipeline - state_update_block
+    def state_update_pipeline(
+                self,
+                sweep_dict: Dict[str, List[Any]],
+                simulation_list, #states_list: List[Dict[str, Any]],
+                configs: List[Tuple[List[Callable], List[Callable]]],
+                env_processes: Dict[str, Callable],
+                time_step: int,
+                run: int
+            ) -> List[Dict[str, Any]]:
+
         sub_step = 0
-        states_list_copy = deepcopy(states_list)
-        genesis_states = states_list_copy[-1]
-        genesis_states['substep'], genesis_states['timestep'] = sub_step, time_step
-        states_list = [genesis_states]
+        states_list_copy: List[Dict[str, Any]] = deepcopy(simulation_list[-1])
+        genesis_states: Dict[str, Any] = states_list_copy[-1]
+
+        if len(states_list_copy) == 1:
+            genesis_states['substep'] = sub_step
+        #     genesis_states['timestep'] = 0
+        # else:
+        #     genesis_states['timestep'] = time_step
+
+        del states_list_copy
+        states_list: List[Dict[str, Any]] = [genesis_states]
 
         sub_step += 1
-        for config in configs:
-            s_conf, p_conf = config[0], config[1]
-            states_list = self.partial_state_update(var_dict, sub_step, states_list, s_conf, p_conf, env_processes, time_step, run)
+
+        for [s_conf, p_conf] in configs: # tensor field
+
+            states_list: List[Dict[str, Any]] = self.partial_state_update(
+                sweep_dict, sub_step, states_list, simulation_list, s_conf, p_conf, env_processes, time_step, run
+            )
             sub_step += 1
 
         time_step += 1
 
         return states_list
 
-    def run_pipeline(self, var_dict, states_list, configs, env_processes, time_seq, run):
-        time_seq = [x + 1 for x in time_seq]
-        simulation_list = [states_list]
+    # state_update_pipeline
+    def run_pipeline(
+                self,
+                sweep_dict: Dict[str, List[Any]],
+                states_list: List[Dict[str, Any]],
+                configs: List[Tuple[List[Callable], List[Callable]]],
+                env_processes: Dict[str, Callable],
+                time_seq: range,
+                run: int
+            ) -> List[List[Dict[str, Any]]]:
+
+        time_seq: List[int] = [x + 1 for x in time_seq]
+        simulation_list: List[List[Dict[str, Any]]] = [states_list]
+
         for time_step in time_seq:
-            pipe_run = self.state_update_pipeline(var_dict, simulation_list[-1], configs, env_processes, time_step, run)
+            pipe_run: List[Dict[str, Any]] = self.state_update_pipeline(
+                sweep_dict, simulation_list, configs, env_processes, time_step, run
+            )
+
             _, *pipe_run = pipe_run
             simulation_list.append(pipe_run)
 
         return simulation_list
 
-    # ToDo: Muiltithreaded Runs
-    def simulation(self, var_dict, states_list, configs, env_processes, time_seq, runs):
-        pipe_run = []
-        for run in range(runs):
+    def simulation(
+            self,
+            sweep_dict: Dict[str, List[Any]],
+            states_list: List[Dict[str, Any]],
+            configs: List[Tuple[List[Callable], List[Callable]]],
+            env_processes: Dict[str, Callable],
+            time_seq: range,
+            runs: int
+        ) -> List[List[Dict[str, Any]]]:
+
+        def execute_run(sweep_dict, states_list, configs, env_processes, time_seq, run) -> List[Dict[str, Any]]:
             run += 1
-            states_list_copy = deepcopy(states_list)
-            head, *tail = self.run_pipeline(var_dict, states_list_copy, configs, env_processes, time_seq, run)
-            genesis = head.pop()
-            genesis['substep'], genesis['timestep'], genesis['run'] = 0, 0, run
-            first_timestep_per_run = [genesis] + tail.pop(0)
-            pipe_run += [first_timestep_per_run] + tail
+
+            def generate_init_sys_metrics(genesis_states_list):
+                for d in genesis_states_list:
+                    d['run'], d['substep'], d['timestep'] = run, 0, 0
+                    yield d
+
+            states_list_copy: List[Dict[str, Any]] = list(generate_init_sys_metrics(deepcopy(states_list)))
+
+            first_timestep_per_run: List[Dict[str, Any]] = self.run_pipeline(
+                sweep_dict, states_list_copy, configs, env_processes, time_seq, run
+            )
             del states_list_copy
 
+            return first_timestep_per_run
+
+        tp = TPool(runs)
+        pipe_run: List[List[Dict[str, Any]]] = flatten(
+            tp.map(
+                lambda run: execute_run(sweep_dict, states_list, configs, env_processes, time_seq, run),
+                list(range(runs))
+            )
+        )
+
+        tp.clear()
         return pipe_run

cadCAD/engine/utils.py

@@ -24,8 +24,6 @@ def retrieve_state(l, offset):
     return l[last_index(l) + offset + 1]
 
 
-# exception_function = f(sub_step, sL, sL[-2], _input)
-# try_function = f(sub_step, sL, last_mut_obj, _input)
 @curried
 def engine_exception(ErrorType, error_message, exception_function, try_function):
     try:
@@ -38,5 +36,3 @@ def engine_exception(ErrorType, error_message, exception_function, try_function)
 @curried
 def fit_param(param, x):
     return x + param
-
-# fit_param = lambda param: lambda x: x + param

cadCAD/utils/__init__.py

@@ -1,7 +1,34 @@
-from collections import defaultdict
+from functools import reduce
+from typing import Dict, List
+from collections import defaultdict, Counter
 from itertools import product
 import warnings
 
+from pandas import DataFrame
+
+
+class SilentDF(DataFrame):
+    def __repr__(self):
+        return str(hex(id(DataFrame))) #"pandas.core.frame.DataFrame"
+
+
+def append_dict(dict, new_dict):
+    dict.update(new_dict)
+    return dict
+
+
+class IndexCounter:
+    def __init__(self):
+        self.i = 0
+
+    def __call__(self):
+        self.i += 1
+        return self.i
+
+
+def compose(*functions):
+    return reduce(lambda f, g: lambda x: f(g(x)), functions, lambda x: x)
+
 def pipe(x):
     return x
 
@@ -41,11 +68,11 @@ def dict_filter(dictionary, condition):
     return dict([(k, v) for k, v in dictionary.items() if condition(v)])
 
 
-def get_max_dict_val_len(g):
+def get_max_dict_val_len(g: Dict[str, List[int]]) -> int:
     return len(max(g.values(), key=len))
 
 
-def tabulate_dict(d):
+def tabulate_dict(d: Dict[str, List[int]]) -> Dict[str, List[int]]:
     max_len = get_max_dict_val_len(d)
     _d = {}
     for k, vl in d.items():
@@ -57,7 +84,7 @@ def tabulate_dict(d):
     return _d
 
 
-def flatten_tabulated_dict(d):
+def flatten_tabulated_dict(d: Dict[str, List[int]]) -> List[Dict[str, int]]:
     max_len = get_max_dict_val_len(d)
     dl = [{} for i in range(max_len)]
 
@@ -113,23 +140,3 @@ def curry_pot(f, *argv):
         return f(argv[0], argv[1], argv[2])
     else:
         raise TypeError('curry_pot() needs 3 or 4 positional arguments')
-
-# def curry_pot(f, *argv):
-#     sweep_ind = f.__name__[0:5] == 'sweep'
-#     arg_len = len(argv)
-#     if sweep_ind is True and arg_len == 4:
-#         return f(argv[0])(argv[1])(argv[2])(argv[3])
-#     elif sweep_ind is False and arg_len == 4:
-#         return f(argv[0])(argv[1])(argv[2])(argv[3])
-#     elif sweep_ind is True and arg_len == 3:
-#         return f(argv[0])(argv[1])(argv[2])
-#     elif sweep_ind is False and arg_len == 3:
-#         return f(argv[0])(argv[1])(argv[2])
-#     else:
-#         raise TypeError('curry_pot() needs 3 or 4 positional arguments')
-
-# def rename(newname):
-#     def decorator(f):
-#         f.__name__ = newname
-#         return f
-#     return decorator

cadCAD/utils/sys_config.py

@@ -0,0 +1,51 @@
+from funcy import curry
+from cadCAD.configuration.utils import ep_time_step, time_step
+
+
+def increment(y, incr_by):
+    return lambda _g, step, sL, s, _input: (y, s[y] + incr_by)
+
+
+def track(y):
+    return lambda _g, step, sL, s, _input: (y, s[y].x)
+
+
+def simple_state_update(y, x):
+    return lambda _g, step, sH, s, _input: (y, x)
+
+
+def simple_policy_update(y):
+    return lambda _g, step, sH, s: y
+
+
+def update_timestamp(y, timedelta, format):
+    return lambda _g, step, sL, s, _input: (
+        y,
+        ep_time_step(s, dt_str=s[y], fromat_str=format, _timedelta=timedelta)
+    )
+
+
+def apply(f, y: str, incr_by: int):
+    return lambda _g, step, sL, s, _input: (y, curry(f)(s[y])(incr_by))
+
+
+def add(y: str, incr_by):
+    return apply(lambda a, b: a + b, y, incr_by)
+
+
+def increment_state_by_int(y: str, incr_by: int):
+    return lambda _g, step, sL, s, _input: (y, s[y] + incr_by)
+
+
+def s(y, x):
+    return lambda _g, step, sH, s, _input: (y, x)
+
+
+def time_model(y, substeps, time_delta, ts_format='%Y-%m-%d %H:%M:%S'):
+    def apply_incriment_condition(s):
+        if s['substep'] == 0 or s['substep'] == substeps:
+            return y, time_step(dt_str=s[y], dt_format=ts_format, _timedelta=time_delta)
+        else:
+            return y, s[y]
+    return lambda _g, step, sL, s, _input: apply_incriment_condition(s)
+

documentation/Historically_State_Access.md

@@ -0,0 +1,91 @@
+Historical State Access
+==
+#### Motivation
+The current state (values of state variables) is accessed through the `s` list. When the user requires previous state variable values, they may be accessed through the state history list, `sH`. Accessing the state history should be implemented without creating unintended feedback loops on the current state.
+
+The 3rd parameter of state and policy update functions (labeled as `sH` of type `List[List[dict]]`) provides access to past Partial State Update Block (PSUB) given a negative offset number. `access_block` is used to access past PSUBs (`List[dict]`) from `sH`. For example, an offset of `-2` denotes the second to last PSUB.
+
+#### Exclusion List
+Create a list of states to exclude from the reported PSU.
+```python
+exclusion_list = [
+    'nonexistent', 'last_x', '2nd_to_last_x', '3rd_to_last_x', '4th_to_last_x'
+]
+```
+##### Example Policy Updates
+###### Last partial state update
+```python
+def last_update(_params, substep, sH, s):
+    return {"last_x": access_block(
+            state_history=sH,
+            target_field="last_x", # Add a field to the exclusion list
+            psu_block_offset=-1,
+            exculsion_list=exclusion_list
+        )
+    }
+```
+* Note: Although `target_field` adding a field to the exclusion may seem redundant, it is useful in the case of the exclusion list being empty while the `target_field` is assigned to a state or a policy key.
+##### Define State Updates
+###### 2nd to last partial state update
+```python
+def second2last_update(_params, substep, sH, s):
+    return {"2nd_to_last_x": access_block(sH, "2nd_to_last_x", -2, exclusion_list)}
+```
+
+
+###### 3rd to last partial state update
+```python
+def third_to_last_x(_params, substep, sH, s, _input):
+    return '3rd_to_last_x', access_block(sH, "3rd_to_last_x", -3, exclusion_list)
+```
+###### 4rd to last partial state update
+```python
+def fourth_to_last_x(_params, substep, sH, s, _input):
+    return '4th_to_last_x', access_block(sH, "4th_to_last_x", -4, exclusion_list)
+```
+###### Non-exsistent partial state update
+* `psu_block_offset >= 0` doesn't exist
+```python
+def nonexistent(_params, substep, sH, s, _input):
+    return 'nonexistent', access_block(sH, "nonexistent", 0, exclusion_list)
+```
+
+#### [Example Simulation:](examples/historical_state_access.py)
+
+
+#### Example Output:
+###### State History
+```
++----+-------+-----------+------------+-----+
+|    |   run |   substep |   timestep |   x |
+|----+-------+-----------+------------+-----|
+|  0 |     1 |         0 |          0 |   0 |
+|  1 |     1 |         1 |          1 |   1 |
+|  2 |     1 |         2 |          1 |   2 |
+|  3 |     1 |         3 |          1 |   3 |
+|  4 |     1 |         1 |          2 |   4 |
+|  5 |     1 |         2 |          2 |   5 |
+|  6 |     1 |         3 |          2 |   6 |
+|  7 |     1 |         1 |          3 |   7 |
+|  8 |     1 |         2 |          3 |   8 |
+|  9 |     1 |         3 |          3 |   9 |
++----+-------+-----------+------------+-----+
+```
+###### Accessed State History: 
+Example: `last_x`
+```
++----+-----------------------------------------------------------------------------------------------------------------------------------------------------+
+|    | last_x                                                                                                                                              |
+|----+-----------------------------------------------------------------------------------------------------------------------------------------------------|
+|  0 | []                                                                                                                                                  |
+|  1 | [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}]                                                                                                   |
+|  2 | [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}]                                                                                                   |
+|  3 | [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}]                                                                                                   |
+|  4 | [{'x': 1, 'run': 1, 'substep': 1, 'timestep': 1}, {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1}, {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}] |
+|  5 | [{'x': 1, 'run': 1, 'substep': 1, 'timestep': 1}, {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1}, {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}] |
+|  6 | [{'x': 1, 'run': 1, 'substep': 1, 'timestep': 1}, {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1}, {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}] |
+|  7 | [{'x': 4, 'run': 1, 'substep': 1, 'timestep': 2}, {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2}, {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}] |
+|  8 | [{'x': 4, 'run': 1, 'substep': 1, 'timestep': 2}, {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2}, {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}] |
+|  9 | [{'x': 4, 'run': 1, 'substep': 1, 'timestep': 2}, {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2}, {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}] |
++----+-----------------------------------------------------------------------------------------------------------------------------------------------------+
+```

documentation/Policy_Aggregation.md

@@ -0,0 +1,77 @@
+Policy Aggregation
+==
+
+For each Partial State Update, multiple policy dictionaries are aggregated into a single dictionary to be imputted into 
+all state functions using an initial reduction function and optional subsequent map functions. 
+
+#### Aggregate Function Composition:
+```python
+# Reduce Function
+add = lambda a, b: a + b # Used to add policy values of the same key
+# Map Function
+mult_by_2 = lambda y: y * 2 # Used to multiply all policy values by 2
+policy_ops=[add, mult_by_2]
+```
+
+##### Example Policy Updates per Partial State Update (PSU)
+```python
+def p1_psu1(_params, step, sH, s):
+    return {'policy1': 1}
+def p2_psu1(_params, step, sH, s):
+    return {'policy2': 2}
+```
+* `add` not applicable due to lack of redundant policies
+* `mult_by_2` applied to all policies
+* Result: `{'policy1': 2, 'policy2': 4}`
+
+```python
+def p1_psu2(_params, step, sH, s):
+    return {'policy1': 2, 'policy2': 2}
+def p2_psu2(_params, step, sH, s):
+    return {'policy1': 2, 'policy2': 2}
+```
+* `add` applicable due to redundant policies
+* `mult_by_2` applied to all policies
+* Result: `{'policy1': 8, 'policy2': 8}`
+
+```python
+def p1_psu3(_params, step, sH, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+def p2_psu3(_params, step, sH, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+```
+* `add` applicable due to redundant policies
+* `mult_by_2` applied to all policies
+* Result: `{'policy1': 4, 'policy2': 8, 'policy3': 12}`
+
+#### Aggregate Policies using functions
+```python
+from cadCAD.configuration import append_configs
+
+append_configs(
+    sim_configs=???,
+    initial_state=???,
+    partial_state_update_blocks=???,
+    policy_ops=[add, mult_by_2] # Default: [lambda a, b: a + b]
+)
+```
+
+#### Example
+##### * [System Model Configuration](examples/policy_aggregation.py)
+##### * Simulation Results:
+```
++----+---------------------------------------------+-------+------+-----------+------------+
+|    | policies                                    |   run |   s1 |   substep |   timestep |
+|----+---------------------------------------------+-------+------+-----------+------------|
+|  0 | {}                                          |     1 |    0 |         0 |          0 |
+|  1 | {'policy1': 2, 'policy2': 4}                |     1 |    1 |         1 |          1 |
+|  2 | {'policy1': 8, 'policy2': 8}                |     1 |    2 |         2 |          1 |
+|  3 | {'policy3': 12, 'policy1': 4, 'policy2': 8} |     1 |    3 |         3 |          1 |
+|  4 | {'policy1': 2, 'policy2': 4}                |     1 |    4 |         1 |          2 |
+|  5 | {'policy1': 8, 'policy2': 8}                |     1 |    5 |         2 |          2 |
+|  6 | {'policy3': 12, 'policy1': 4, 'policy2': 8} |     1 |    6 |         3 |          2 |
+|  7 | {'policy1': 2, 'policy2': 4}                |     1 |    7 |         1 |          3 |
+|  8 | {'policy1': 8, 'policy2': 8}                |     1 |    8 |         2 |          3 |
+|  9 | {'policy3': 12, 'policy1': 4, 'policy2': 8} |     1 |    9 |         3 |          3 |
++----+---------------------------------------------+-------+------+-----------+------------+
+```

documentation/README.md

@@ -0,0 +1,241 @@
+Simulation Configuration
+==
+
+## Introduction
+
+Given a **Simulation Configuration**, cadCAD produces datasets that represent the evolution of the state of a system 
+over [discrete time](https://en.wikipedia.org/wiki/Discrete_time_and_continuous_time#Discrete_time). The state of the 
+system is described by a set of [State Variables](#State-Variables). The dynamic of the system is described by 
+[Policy Functions](#Policy-Functions) and [State Update Functions](#State-Update-Functions), which are evaluated by 
+cadCAD according to the definitions set by the user in [Partial State Update Blocks](#Partial-State-Update-Blocks).
+
+A Simulation Configuration is comprised of a [System Model](#System-Model) and a set of 
+[Simulation Properties](#Simulation-Properties)
+
+`append_configs`, stores a **Simulation Configuration** to be [Executed](/JS4Q9oayQASihxHBJzz4Ug) by cadCAD
+
+```python
+from cadCAD.configuration import append_configs
+
+append_configs(
+    initial_state = ..., # System Model
+    partial_state_update_blocks = .., # System Model
+    policy_ops = ..., # System Model
+    sim_configs = ... # Simulation Properties
+)
+```
+Parameters:
+* **initial_state** : _dict_ - [State Variables](#State-Variables) and their initial values
+* **partial_state_update_blocks** : List[dict[dict]] - List of [Partial State Update Blocks](#Partial-State-Update-Blocks)
+* **policy_ops** : List[functions] - See [Policy Aggregation](/63k2ncjITuqOPCUHzK7Viw) 
+* **sim_configs** - See [System Model Parameter Sweep](/4oJ_GT6zRWW8AO3yMhFKrg)
+
+## Simulation Properties
+
+Simulation properties are passed to `append_configs` in the `sim_configs` parameter. To construct this parameter, we 
+use the `config_sim` function in `cadCAD.configuration.utils`
+
+```python
+from cadCAD.configuration.utils import config_sim
+
+c = config_sim({
+    "N": ...,
+    "T": range(...),
+    "M": ...
+})
+
+append_configs(
+    ...
+    sim_configs = c # Simulation Properties
+)
+```
+
+### T - Simulation Length
+Computer simulations run in discrete time:
+
+>Discrete time views values of variables as occurring at distinct, separate "points in time", or equivalently as being 
+unchanged throughout each non-zero region of time ("time period")—that is, time is viewed as a discrete variable. (...) 
+This view of time corresponds to a digital clock that gives a fixed reading of 10:37 for a while, and then jumps to a 
+new fixed reading of 10:38, etc. 
+([source: Wikipedia](https://en.wikipedia.org/wiki/Discrete_time_and_continuous_time#Discrete_time))
+
+As is common in many simulation tools, in cadCAD too we refer to each discrete unit of time as a **timestep**. cadCAD 
+increments a "time counter", and at each step it updates the state variables according to the equations that describe 
+the system.
+
+The main simulation property that the user must set when creating a Simulation Configuration is the number of timesteps 
+in the simulation. In other words, for how long do they want to simulate the system that has been modeled.
+
+### N - Number of Runs
+
+cadCAD facilitates running multiple simulations of the same system sequentially, reporting the results of all those 
+runs in a single dataset. This is especially helpful for running 
+[Monte Carlo Simulations](../tutorials/robot-marbles-part-4/robot-marbles-part-4.ipynb).
+
+### M - Parameters of the System
+
+Parameters of the system, passed to the state update functions and the policy functions in the `params` parameter are 
+defined here. See [System Model Parameter Sweep](/4oJ_GT6zRWW8AO3yMhFKrg) for more information.
+
+## System Model
+The System Model describes the system that will be simulated in cadCAD. It is comprised of a set of 
+[State Variables](###Sate-Variables) and the [State Update Functions](#State-Update-Functions) that determine the 
+evolution of the state of the system over time. [Policy Functions](#Policy-Functions) (representations of user policies 
+or internal system control policies) may also be part of a System Model.
+
+### State Variables
+>A state variable is one of the set of variables that are used to describe the mathematical "state" of a dynamical 
+system. Intuitively, the state of a system describes enough about the system to determine its future behaviour in the 
+absence of any external forces affecting the system. ([source: Wikipedia](https://en.wikipedia.org/wiki/State_variable))
+
+cadCAD can handle state variables of any Python data type, including custom classes. It is up to the user of cadCAD to 
+determine the state variables needed to **sufficiently and accurately** describe the system they are interested in.
+
+State Variables are passed to `append_configs` along with its initial values, as a Python `dict` where the `dict_keys` 
+are the names of the variables and the `dict_values` are their initial values.
+
+```python
+from cadCAD.configuration import append_configs
+
+genesis_states = {
+    'state_variable_1': 0,
+    'state_variable_2': 0,
+    'state_variable_3': 1.5,
+    'timestamp': '2019-01-01 00:00:00'
+}
+
+append_configs(
+    initial_state = genesis_states,
+    ...
+)
+```
+### State Update Functions
+State Update Functions represent equations according to which the state variables change over time. Each state update 
+function must return a tuple containing a string with the name of the state variable being updated and its new value. 
+Each state update function can only modify a single state variable. The general structure of a state update function is:
+```python
+def state_update_function_A(_params, substep, sH, s, _input):
+    ...
+    return 'state_variable_name', new_value
+```
+Parameters:
+* **_params** : _dict_ - [System parameters](/4oJ_GT6zRWW8AO3yMhFKrg)
+* **substep** : _int_ - Current [substep](#Substep)
+* **sH** : _list[list[dict_]] - Historical values of all state variables for the simulation. See 
+[Historical State Access](/smiyQTnATtC9xPwvF8KbBQ) for details
+* **s** : _dict_ - Current state of the system, where the `dict_keys` are the names of the state variables and the 
+`dict_values` are their current values.
+* **_input** : _dict_ - Aggregation of the signals of all policy functions in the current 
+[Partial State Update Block](#Partial-State-Update-Block)
+
+Return:
+* _tuple_ containing a string with the name of the state variable being updated and its new value.
+    
+State update functions should not modify any of the parameters passed to it, as those are mutable Python objects that 
+cadCAD relies on in order to run the simulation according to the specifications.
+
+### Policy Functions
+A Policy Function computes one or more signals to be passed to [State Update Functions](#State-Update-Functions) 
+(via the _\_input_ parameter). Read 
+[this article](../tutorials/robot-marbles-part-2/robot-marbles-part-2.ipynb) 
+for details on why and when to use policy functions.
+
+<!-- We would then expand the tutorials with these kind of concepts
+#### Policies
+Policies consist of the potential action made available through mechanisms. The action taken is expected to be the 
+result of a conditional determination of the past state.  
+
+While executed the same, the modeller can approach policies dependent on the availability of a mechanism to a population.
+
+- ***Control Policy***
+When the controlling or deploying entity has the ability to act in order to affect some aspect of the system, this is a 
+control policy.
+- ***User Policy*** model agent behaviors in reaction to state variables and exogenous variables. The resulted user 
+action will become an input to PSUs. Note that user behaviors should not directly update value of state variables. 
+The action taken, as well as the potential to act, through a mechanism is a behavior.  -->
+
+The general structure of a policy function is:
+```python
+def policy_function_1(_params, substep, sH, s):
+    ...
+    return {'signal_1': value_1, ..., 'signal_N': value_N}
+```
+Parameters:
+* **_params** : _dict_ - [System parameters](/4oJ_GT6zRWW8AO3yMhFKrg)
+* **substep** : _int_ - Current [substep](#Substep)
+* **sH** : _list[list[dict_]] - Historical values of all state variables for the simulation. See 
+[Historical State Access](/smiyQTnATtC9xPwvF8KbBQ) for details
+* **s** : _dict_ - Current state of the system, where the `dict_keys` are the names of the state variables and the 
+`dict_values` are their current values.
+    
+Return:
+* _dict_ of signals to be passed to the state update functions in the same 
+[Partial State Update Block](#Partial-State-Update-Blocks)
+
+Policy functions should not modify any of the parameters passed to it, as those are mutable Python objects that cadCAD 
+relies on in order to run the simulation according to the specifications.
+
+At each [Partial State Update Block](#Partial-State-Update-Blocks) (PSUB), the `dicts` returned by all policy functions 
+within that PSUB dictionaries are aggregated into a single `dict` using an initial reduction function 
+(a key-wise operation, default: `dic1['keyA'] + dic2['keyA']`) and optional subsequent map functions. The resulting 
+aggregated `dict` is then passed as the `_input` parameter to the state update functions in that PSUB. For more 
+information on how to modify the aggregation method, see [Policy Aggregation](/63k2ncjITuqOPCUHzK7Viw).
+
+### Partial State Update Blocks
+
+A **Partial State Update Block** (PSUB) is a set of State Update Functions and Policy Functions such that State Update 
+Functions in the set are independent from each other and Policies in the set are independent from each other and from 
+the State Update Functions in the set. In other words, if a state variable is updated in a PSUB, its new value cannot 
+impact the State Update Functions and Policy Functions in that PSUB - only those in the next PSUB.
+
+![](https://i.imgur.com/9rlX9TG.png)
+
+Partial State Update Blocks are passed to `append_configs` as a List of Python `dicts` where the `dict_keys` are named 
+`"policies"` and `"variables"` and the values are also Python `dicts` where the keys are the names of the policy and 
+state update functions and the values are the functions.
+
+```python
+PSUBs = [
+    {
+        "policies": {
+            "b_1": policy_function_1,
+            ...
+            "b_J": policy_function_J
+        },
+        "variables": {
+            "s_1": state_update_function_1,
+            ...
+            "s_K": state_update_function_K
+        }
+    }, #PSUB_1,
+    {...}, #PSUB_2,
+    ...
+    {...} #PSUB_M
+]
+
+append_configs(
+    ...
+    partial_state_update_blocks = PSUBs,
+    ...
+)
+
+```
+
+#### Substep
+At each timestep, cadCAD iterates over the `partial_state_update_blocks` list. For each Partial State Update Block, 
+cadCAD returns a record containing the state of the system at the end of that PSUB. We refer to that subdivision of a 
+timestep as a `substep`.
+
+## Result Dataset
+
+cadCAD returns a dataset containing the evolution of the state variables defined by the user over time, with three `int` 
+indexes:
+* `run` - id of the [run](#N-Number-of-Runs)
+* `timestep` - discrete unit of time (the total number of timesteps is defined by the user in the 
+[T Simulation Parameter](#T-Simulation-Length))
+* `substep` - subdivision of timestep (the number of [substeps](#Substeps) is the same as the number of Partial State 
+Update Blocks)
+
+Therefore, the total number of records in the resulting dataset is `N` x `T` x `len(partial_state_update_blocks)`
+
+#### [System Simulation Execution](Simulation_Execution.md)

documentation/Simulation_Execution.md

@@ -0,0 +1,160 @@
+Simulation Execution
+==
+System Simulations are executed with the execution engine executor (`cadCAD.engine.Executor`) given System Model 
+Configurations. There are multiple simulation Execution Modes and Execution Contexts.
+
+### Steps:
+1. #### *Choose Execution Mode*:
+    * ##### Simulation Execution Modes:
+        `cadCAD` executes a process per System Model Configuration and a thread per System Simulation.
+    ##### Class: `cadCAD.engine.ExecutionMode`
+    ##### Attributes:
+    * **Single Process:** A single process Execution Mode for a single System Model Configuration (Example: 
+    `cadCAD.engine.ExecutionMode().single_proc`).
+    * **Multi-Process:** Multiple process Execution Mode for System Model Simulations which executes on a thread per 
+    given System Model Configuration (Example: `cadCAD.engine.ExecutionMode().multi_proc`).
+2. #### *Create Execution Context using Execution Mode:*
+```python
+from cadCAD.engine import ExecutionMode, ExecutionContext
+exec_mode = ExecutionMode()
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+```
+3. #### *Create Simulation Executor*
+```python
+from cadCAD.engine import Executor
+from cadCAD import configs
+simulation = Executor(exec_context=single_proc_ctx, configs=configs)
+```
+4. #### *Execute Simulation: Produce System Event Dataset*
+A Simulation execution produces a System Event Dataset and the Tensor Field applied to initial states used to create it. 
+```python
+import pandas as pd
+raw_system_events, tensor_field = simulation.execute()
+
+# Simulation Result Types:
+# raw_system_events: List[dict] 
+# tensor_field: pd.DataFrame
+
+# Result System Events DataFrame
+simulation_result = pd.DataFrame(raw_system_events)
+```
+
+##### Example Tensor Field
+```
++----+-----+--------------------------------+--------------------------------+
+|    |   m | b1                             | s1                             |
+|----+-----+--------------------------------+--------------------------------|
+|  0 |   1 | <function p1m1 at 0x10c458ea0> | <function s1m1 at 0x10c464510> |
+|  1 |   2 | <function p1m2 at 0x10c464048> | <function s1m2 at 0x10c464620> |
+|  2 |   3 | <function p1m3 at 0x10c464400> | <function s1m3 at 0x10c464730> |
++----+-----+--------------------------------+--------------------------------+
+```
+
+##### Example Result: System Events DataFrame
+```
++----+-------+------------+-----------+------+-----------+
+|    |   run |   timestep |   substep |   s1 | s2        |
+|----+-------+------------+-----------+------+-----------|
+|  0 |     1 |          0 |         0 |    0 | 0.0       |
+|  1 |     1 |          1 |         1 |    1 | 4         |
+|  2 |     1 |          1 |         2 |    2 | 6         |
+|  3 |     1 |          1 |         3 |    3 | [ 30 300] |
+|  4 |     2 |          0 |         0 |    0 | 0.0       |
+|  5 |     2 |          1 |         1 |    1 | 4         |
+|  6 |     2 |          1 |         2 |    2 | 6         |
+|  7 |     2 |          1 |         3 |    3 | [ 30 300] |
++----+-------+------------+-----------+------+-----------+
+```
+
+### Execution Examples:
+##### Single Simulation Execution (Single Process Execution)
+Example System Model Configurations: 
+* [System Model A](examples/sys_model_A.py): `/documentation/examples/sys_model_A.py`
+* [System Model B](examples/sys_model_B.py): `/documentation/examples/sys_model_B.py`
+Example Simulation Executions:
+* [System Model A](examples/sys_model_A_exec.py): `/documentation/examples/sys_model_A_exec.py`
+* [System Model B](examples/sys_model_B_exec.py): `/documentation/examples/sys_model_B_exec.py`
+```python
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_A
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+# Single Process Execution using a Single System Model Configuration:
+# sys_model_A
+sys_model_A = [configs[0]] # sys_model_A
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+sys_model_A_simulation = Executor(exec_context=single_proc_ctx, configs=sys_model_A)
+
+sys_model_A_raw_result, sys_model_A_tensor_field = sys_model_A_simulation.execute()
+sys_model_A_result = pd.DataFrame(sys_model_A_raw_result)
+print()
+print("Tensor Field: sys_model_A")
+print(tabulate(sys_model_A_tensor_field, headers='keys', tablefmt='psql'))
+print("Result: System Events DataFrame")
+print(tabulate(sys_model_A_result, headers='keys', tablefmt='psql'))
+print()
+```
+
+##### Multiple Simulation Execution
+
+* ##### *Multi Process Execution*
+Documentation: Simulation Execution 
+[Example Simulation Executions::](examples/sys_model_AB_exec.py) `/documentation/examples/sys_model_AB_exec.py`
+Example System Model Configurations: 
+* [System Model A](examples/sys_model_A.py): `/documentation/examples/sys_model_A.py`
+* [System Model B](examples/sys_model_B.py): `/documentation/examples/sys_model_B.py`
+```python
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_A, sys_model_B
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+# # Multiple Processes Execution using Multiple System Model Configurations:
+# # sys_model_A & sys_model_B
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+sys_model_AB_simulation = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+i = 0
+config_names = ['sys_model_A', 'sys_model_B']
+for sys_model_AB_raw_result, sys_model_AB_tensor_field in sys_model_AB_simulation.execute():
+    sys_model_AB_result = pd.DataFrame(sys_model_AB_raw_result)
+    print()
+    print(f"Tensor Field: {config_names[i]}")
+    print(tabulate(sys_model_AB_tensor_field, headers='keys', tablefmt='psql'))
+    print("Result: System Events DataFrame:")
+    print(tabulate(sys_model_AB_result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1
+```
+
+* ##### [*System Model Parameter Sweep*](System_Model_Parameter_Sweep.md) 
+
+[Example:](examples/param_sweep.py) `/documentation/examples/param_sweep.py`
+```python
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import param_sweep
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print("Tensor Field:")
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print("Output:")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()
+```

documentation/System_Model_Parameter_Sweep.md

@@ -0,0 +1,72 @@
+System Model Parameter Sweep
+==
+Parametrization of a System Model configuration that produces multiple configurations.
+
+##### Set Parameters
+```python
+params = {
+    'alpha': [1],
+    'beta': [2, 5],
+    'gamma': [3, 4],
+    'omega': [7]
+}
+```
+The parameters above produce 2 simulations.
+* Simulation 1: 
+    * `alpha = 1`
+    * `beta = 2`
+    * `gamma = 3`
+    * `omega = 7`
+* Simulation 2:
+    * `alpha = 1`
+    * `beta = 5`
+    * `gamma = 4`
+    * `omega = 7`
+
+All parameters can also be set to include a single parameter each, which will result in a single simulation.
+
+##### Example State Updates
+
+Previous State:
+`y = 0`
+
+```python
+def state_update(_params, step, sH, s, _input):
+    y = 'state'
+    x = s['state'] + _params['alpha'] + _params['gamma']
+    return y, x
+```
+* Updated State:
+    * Simulation 1: `y = 4 = 0 + 1 + 3` 
+    * Simulation 2: `y = 5 = 0 + 1 + 4`
+
+##### Example Policy Updates
+```python
+# Internal States per Mechanism
+def policies(_params, step, sH, s):
+    return {'beta': _params['beta'], 'gamma': _params['gamma']}
+```
+* Simulation 1: `{'beta': 2, 'gamma': 3]}` 
+* Simulation 2: `{'beta': 5, 'gamma': 4}`
+
+##### Configure Simulation
+```python
+from cadCAD.configuration.utils import config_sim
+
+g = {
+    'alpha': [1],
+    'beta': [2, 5],
+    'gamma': [3, 4],
+    'omega': [7]
+}
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+        "M": g,
+    }
+)
+```
+#### Example
+##### * [System Model Configuration](examples/param_sweep.py)

documentation/examples/example_1.py

@@ -0,0 +1,45 @@
+from pprint import pprint
+
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_A, sys_model_B
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+# Single Process Execution using a Single System Model Configuration:
+# sys_model_A
+sys_model_A = [configs[0]]
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+sys_model_A_simulation = Executor(exec_context=single_proc_ctx, configs=sys_model_A)
+
+sys_model_A_raw_result, sys_model_A_tensor_field = sys_model_A_simulation.execute()
+sys_model_A_result = pd.DataFrame(sys_model_A_raw_result)
+print()
+print("Tensor Field: sys_model_A")
+print(tabulate(sys_model_A_tensor_field, headers='keys', tablefmt='psql'))
+print("Result: System Events DataFrame")
+print(tabulate(sys_model_A_result, headers='keys', tablefmt='psql'))
+print()
+
+# # Multiple Processes Execution using Multiple System Model Configurations:
+# # sys_model_A & sys_model_B
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+sys_model_AB_simulation = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+
+
+i = 0
+config_names = ['sys_model_A', 'sys_model_B']
+for sys_model_AB_raw_result, sys_model_AB_tensor_field in sys_model_AB_simulation.execute():
+    print()
+    pprint(sys_model_AB_raw_result)
+    # sys_model_AB_result = pd.DataFrame(sys_model_AB_raw_result)
+    print()
+    print(f"Tensor Field: {config_names[i]}")
+    print(tabulate(sys_model_AB_tensor_field, headers='keys', tablefmt='psql'))
+    # print("Result: System Events DataFrame:")
+    # print(tabulate(sys_model_AB_result, headers='keys', tablefmt='psql'))
+    # print()
+    i += 1

documentation/examples/historical_state_access.py

@@ -0,0 +1,110 @@
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim, access_block
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+
+
+policies, variables = {}, {}
+exclusion_list = ['nonexsistant', 'last_x', '2nd_to_last_x', '3rd_to_last_x', '4th_to_last_x']
+
+# Policies per Mechanism
+
+# state_history, target_field, psu_block_offset, exculsion_list
+def last_update(_g, substep, sH, s):
+    return {"last_x": access_block(
+            state_history=sH,
+            target_field="last_x",
+            psu_block_offset=-1,
+            exculsion_list=exclusion_list
+        )
+    }
+policies["last_x"] = last_update
+
+def second2last_update(_g, substep, sH, s):
+    return {"2nd_to_last_x": access_block(sH, "2nd_to_last_x", -2, exclusion_list)}
+policies["2nd_to_last_x"] = second2last_update
+
+
+# Internal States per Mechanism
+
+# WARNING: DO NOT delete elements from sH
+def add(y, x):
+    return lambda _g, substep, sH, s, _input: (y, s[y] + x)
+variables['x'] = add('x', 1)
+
+# last_partial_state_update_block
+def nonexsistant(_g, substep, sH, s, _input):
+    return 'nonexsistant', access_block(sH, "nonexsistant", 0, exclusion_list)
+variables['nonexsistant'] = nonexsistant
+
+# last_partial_state_update_block
+def last_x(_g, substep, sH, s, _input):
+    return 'last_x', _input["last_x"]
+variables['last_x'] = last_x
+
+# 2nd to last partial state update block
+def second_to_last_x(_g, substep, sH, s, _input):
+    return '2nd_to_last_x', _input["2nd_to_last_x"]
+variables['2nd_to_last_x'] = second_to_last_x
+
+# 3rd to last partial state update block
+def third_to_last_x(_g, substep, sH, s, _input):
+    return '3rd_to_last_x', access_block(sH, "3rd_to_last_x", -3, exclusion_list)
+variables['3rd_to_last_x'] = third_to_last_x
+
+# 4th to last partial state update block
+def fourth_to_last_x(_g, substep, sH, s, _input):
+    return '4th_to_last_x', access_block(sH, "4th_to_last_x", -4, exclusion_list)
+variables['4th_to_last_x'] = fourth_to_last_x
+
+
+genesis_states = {
+    'x': 0,
+    'nonexsistant': [],
+    'last_x': [],
+    '2nd_to_last_x': [],
+    '3rd_to_last_x': [],
+    '4th_to_last_x': []
+}
+
+PSUB = {
+    "policies": policies,
+    "variables": variables
+}
+
+psubs = {
+    "PSUB1": PSUB,
+    "PSUB2": PSUB,
+    "PSUB3": PSUB
+}
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=psubs
+)
+
+exec_mode = ExecutionMode()
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=configs)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+cols = ['run','substep','timestep','x','nonexsistant','last_x','2nd_to_last_x','3rd_to_last_x','4th_to_last_x']
+result = result[cols]
+
+print()
+print("Tensor Field:")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

documentation/examples/param_sweep.py

@@ -0,0 +1,116 @@
+import pprint
+from typing import Dict, List
+
+import pandas as pd
+from tabulate import tabulate
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import env_trigger, var_substep_trigger, config_sim, psub_list
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+
+pp = pprint.PrettyPrinter(indent=4)
+
+
+def some_function(x):
+    return x
+
+
+g: Dict[str, List[int]] = {
+    'alpha': [1],
+    'beta': [2, 5],
+    'gamma': [3, 4],
+    'omega': [some_function]
+}
+
+psu_steps = ['1', '2', '3']
+system_substeps = len(psu_steps)
+var_timestep_trigger = var_substep_trigger([0, system_substeps])
+env_timestep_trigger = env_trigger(system_substeps)
+env_process = {}
+
+
+# Policies
+def gamma(_params, step, sH, s):
+    return {'gamma': _params['gamma']}
+
+
+def omega(_params, step, sH, s):
+    return {'omega': _params['omega'](7)}
+
+
+# Internal States
+def alpha(_params, step, sH, s, _input):
+    return 'alpha', _params['alpha']
+
+def alpha_plus_gamma(_params, step, sH, s, _input):
+    return 'alpha_plus_gamma', _params['alpha'] + _params['gamma']
+
+
+def beta(_params, step, sH, s, _input):
+    return 'beta', _params['beta']
+
+
+def policies(_params, step, sH, s, _input):
+    return 'policies', _input
+
+
+def sweeped(_params, step, sH, s, _input):
+    return 'sweeped', {'beta': _params['beta'], 'gamma': _params['gamma']}
+
+
+
+
+
+genesis_states = {
+    'alpha_plus_gamma': 0,
+    'alpha': 0,
+    'beta': 0,
+    'policies': {},
+    'sweeped': {}
+}
+
+env_process['sweeped'] = env_timestep_trigger(trigger_field='timestep', trigger_vals=[5], funct_list=[lambda _g, x: _g['beta']])
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+        "M": g,
+    }
+)
+
+psu_block = {k: {"policies": {}, "variables": {}} for k in psu_steps}
+for m in psu_steps:
+    psu_block[m]['policies']['gamma'] = gamma
+    psu_block[m]['policies']['omega'] = omega
+    psu_block[m]["variables"]['alpha'] = alpha_plus_gamma
+    psu_block[m]["variables"]['alpha_plus_gamma'] = alpha
+    psu_block[m]["variables"]['beta'] = beta
+    psu_block[m]['variables']['policies'] = policies
+    psu_block[m]["variables"]['sweeped'] = var_timestep_trigger(y='sweeped', f=sweeped)
+
+psubs = psub_list(psu_block, psu_steps)
+print()
+pp.pprint(psu_block)
+print()
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    env_processes=env_process,
+    partial_state_update_blocks=psubs
+)
+
+exec_mode = ExecutionMode()
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print("Tensor Field:")
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print("Output:")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()

documentation/examples/policy_aggregation.py

@@ -0,0 +1,98 @@
+import pandas as pd
+from tabulate import tabulate
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+
+# Policies per Mechanism
+def p1m1(_g, step, sH, s):
+    return {'policy1': 1}
+def p2m1(_g, step, sH, s):
+    return {'policy2': 2}
+
+def p1m2(_g, step, sH, s):
+    return {'policy1': 2, 'policy2': 2}
+def p2m2(_g, step, sH, s):
+    return {'policy1': 2, 'policy2': 2}
+
+def p1m3(_g, step, sH, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+def p2m3(_g, step, sH, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+
+
+# Internal States per Mechanism
+def add(y, x):
+    return lambda _g, step, sH, s, _input: (y, s[y] + x)
+
+def policies(_g, step, sH, s, _input):
+    y = 'policies'
+    x = _input
+    return (y, x)
+
+
+# Genesis States
+genesis_states = {
+    'policies': {},
+    's1': 0
+}
+
+variables = {
+    's1': add('s1', 1),
+    "policies": policies
+}
+
+psubs = {
+    "m1": {
+        "policies": {
+            "p1": p1m1,
+            "p2": p2m1
+        },
+        "variables": variables
+    },
+    "m2": {
+        "policies": {
+            "p1": p1m2,
+            "p2": p2m2
+        },
+        "variables": variables
+    },
+    "m3": {
+        "policies": {
+            "p1": p1m3,
+            "p2": p2m3
+        },
+        "variables": variables
+    }
+}
+
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=psubs,
+    policy_ops=[lambda a, b: a + b, lambda y: y * 2] # Default: lambda a, b: a + b
+)
+
+exec_mode = ExecutionMode()
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=configs)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+
+print()
+print("Tensor Field:")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

documentation/examples/sys_model_A.py

@@ -0,0 +1,159 @@
+import numpy as np
+from datetime import timedelta
+
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import bound_norm_random, config_sim, time_step, env_trigger
+
+seeds = {
+    'z': np.random.RandomState(1),
+    'a': np.random.RandomState(2),
+    'b': np.random.RandomState(3),
+    'c': np.random.RandomState(4)
+}
+
+
+# Policies per Mechanism
+def p1m1(_g, step, sH, s):
+    return {'param1': 1}
+def p2m1(_g, step, sH, s):
+    return {'param1': 1, 'param2': 4}
+
+def p1m2(_g, step, sH, s):
+    return {'param1': 'a', 'param2': 2}
+def p2m2(_g, step, sH, s):
+    return {'param1': 'b', 'param2': 4}
+
+def p1m3(_g, step, sH, s):
+    return {'param1': ['c'], 'param2': np.array([10, 100])}
+def p2m3(_g, step, sH, s):
+    return {'param1': ['d'], 'param2': np.array([20, 200])}
+
+
+# Internal States per Mechanism
+def s1m1(_g, step, sH, s, _input):
+    y = 's1'
+    x = s['s1'] + 1
+    return (y, x)
+def s2m1(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+def s1m2(_g, step, sH, s, _input):
+    y = 's1'
+    x = s['s1'] + 1
+    return (y, x)
+def s2m2(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+def s1m3(_g, step, sH, s, _input):
+    y = 's1'
+    x = s['s1'] + 1
+    return (y, x)
+def s2m3(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+def policies(_g, step, sH, s, _input):
+    y = 'policies'
+    x = _input
+    return (y, x)
+
+
+# Exogenous States
+proc_one_coef_A = 0.7
+proc_one_coef_B = 1.3
+
+def es3(_g, step, sH, s, _input):
+    y = 's3'
+    x = s['s3'] * bound_norm_random(seeds['a'], proc_one_coef_A, proc_one_coef_B)
+    return (y, x)
+
+def es4(_g, step, sH, s, _input):
+    y = 's4'
+    x = s['s4'] * bound_norm_random(seeds['b'], proc_one_coef_A, proc_one_coef_B)
+    return (y, x)
+
+def update_timestamp(_g, step, sH, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
+
+
+# Genesis States
+genesis_states = {
+    's1': 0.0,
+    's2': 0.0,
+    's3': 1.0,
+    's4': 1.0,
+    'timestamp': '2018-10-01 15:16:24'
+}
+
+
+# Environment Process
+# ToDo: Depreciation Waring for env_proc_trigger convention
+trigger_timestamps = ['2018-10-01 15:16:25', '2018-10-01 15:16:27', '2018-10-01 15:16:29']
+env_processes = {
+    "s3": [lambda _g, x: 5],
+    "s4": env_trigger(3)(trigger_field='timestamp', trigger_vals=trigger_timestamps, funct_list=[lambda _g, x: 10])
+}
+
+
+psubs = [
+    {
+        "policies": {
+            "b1": p1m1,
+            "b2": p2m1
+        },
+        "variables": {
+            "s1": s1m1,
+            "s2": s2m1,
+            "s3": es3,
+            "s4": es4,
+            "timestamp": update_timestamp
+        }
+    },
+    {
+        "policies": {
+            "b1": p1m2,
+            "b2": p2m2
+        },
+        "variables": {
+            "s1": s1m2,
+            "s2": s2m2,
+            # "s3": es3p1,
+            # "s4": es4p2,
+        }
+    },
+    {
+        "policies": {
+            "b1": p1m3,
+            "b2": p2m3
+        },
+        "variables": {
+            "s1": s1m3,
+            "s2": s2m3,
+            # "s3": es3p1,
+            # "s4": es4p2,
+        }
+    }
+]
+
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(1),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    env_processes=env_processes,
+    partial_state_update_blocks=psubs,
+    policy_ops=[lambda a, b: a + b]
+)

documentation/examples/sys_model_AB_exec.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_A, sys_model_B
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+# # Multiple Processes Execution using Multiple System Model Configurations:
+# # sys_model_A & sys_model_B
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+sys_model_AB_simulation = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+i = 0
+config_names = ['sys_model_A', 'sys_model_B']
+for sys_model_AB_raw_result, sys_model_AB_tensor_field in sys_model_AB_simulation.execute():
+    sys_model_AB_result = pd.DataFrame(sys_model_AB_raw_result)
+    print()
+    print(f"Tensor Field: {config_names[i]}")
+    print(tabulate(sys_model_AB_tensor_field, headers='keys', tablefmt='psql'))
+    print("Result: System Events DataFrame:")
+    print(tabulate(sys_model_AB_result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1

documentation/examples/sys_model_A_exec.py

@@ -0,0 +1,22 @@
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_A
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+# Single Process Execution using a Single System Model Configuration:
+# sys_model_A
+sys_model_A = [configs[0]] # sys_model_A
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+sys_model_A_simulation = Executor(exec_context=single_proc_ctx, configs=sys_model_A)
+
+sys_model_A_raw_result, sys_model_A_tensor_field = sys_model_A_simulation.execute()
+sys_model_A_result = pd.DataFrame(sys_model_A_raw_result)
+print()
+print("Tensor Field: sys_model_A")
+print(tabulate(sys_model_A_tensor_field, headers='keys', tablefmt='psql'))
+print("Result: System Events DataFrame")
+print(tabulate(sys_model_A_result, headers='keys', tablefmt='psql'))
+print()

documentation/examples/sys_model_B.py

@@ -0,0 +1,147 @@
+import numpy as np
+from datetime import timedelta
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import bound_norm_random, config_sim, env_trigger, time_step
+
+seeds = {
+    'z': np.random.RandomState(1),
+    'a': np.random.RandomState(2),
+    'b': np.random.RandomState(3),
+    'c': np.random.RandomState(3)
+}
+
+
+# Policies per Mechanism
+def p1m1(_g, step, sH, s):
+    return {'param1': 1}
+def p2m1(_g, step, sH, s):
+    return {'param2': 4}
+
+def p1m2(_g, step, sH, s):
+    return {'param1': 'a', 'param2': 2}
+def p2m2(_g, step, sH, s):
+    return {'param1': 'b', 'param2': 4}
+
+def p1m3(_g, step, sH, s):
+    return {'param1': ['c'], 'param2': np.array([10, 100])}
+def p2m3(_g, step, sH, s):
+    return {'param1': ['d'], 'param2': np.array([20, 200])}
+
+
+# Internal States per Mechanism
+def s1m1(_g, step, sH, s, _input):
+    y = 's1'
+    x = _input['param1']
+    return (y, x)
+def s2m1(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+def s1m2(_g, step, sH, s, _input):
+    y = 's1'
+    x = _input['param1']
+    return (y, x)
+def s2m2(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+def s1m3(_g, step, sH, s, _input):
+    y = 's1'
+    x = _input['param1']
+    return (y, x)
+def s2m3(_g, step, sH, s, _input):
+    y = 's2'
+    x = _input['param2']
+    return (y, x)
+
+
+# Exogenous States
+proc_one_coef_A = 0.7
+proc_one_coef_B = 1.3
+
+def es3(_g, step, sH, s, _input):
+    y = 's3'
+    x = s['s3'] * bound_norm_random(seeds['a'], proc_one_coef_A, proc_one_coef_B)
+    return (y, x)
+
+def es4(_g, step, sH, s, _input):
+    y = 's4'
+    x = s['s4'] * bound_norm_random(seeds['b'], proc_one_coef_A, proc_one_coef_B)
+    return (y, x)
+
+def update_timestamp(_g, step, sH, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
+
+
+# Genesis States
+genesis_states = {
+    's1': 0,
+    's2': 0,
+    's3': 1,
+    's4': 1,
+    'timestamp': '2018-10-01 15:16:24'
+}
+
+
+# Environment Process
+# ToDo: Depreciation Waring for env_proc_trigger convention
+trigger_timestamps = ['2018-10-01 15:16:25', '2018-10-01 15:16:27', '2018-10-01 15:16:29']
+env_processes = {
+    "s3": [lambda _g, x: 5],
+    "s4": env_trigger(3)(trigger_field='timestamp', trigger_vals=trigger_timestamps, funct_list=[lambda _g, x: 10])
+}
+
+psubs = [
+    {
+        "policies": {
+            "b1": p1m1,
+            # "b2": p2m1
+        },
+        "states": {
+            "s1": s1m1,
+            # "s2": s2m1
+            "s3": es3,
+            "s4": es4,
+            "timestep": update_timestamp
+        }
+    },
+    {
+        "policies": {
+            "b1": p1m2,
+            # "b2": p2m2
+        },
+        "states": {
+            "s1": s1m2,
+            # "s2": s2m2
+        }
+    },
+    {
+        "policies": {
+            "b1": p1m3,
+            "b2": p2m3
+        },
+        "states": {
+            "s1": s1m3,
+            "s2": s2m3
+        }
+    }
+]
+
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    env_processes=env_processes,
+    partial_state_update_blocks=psubs
+)

documentation/examples/sys_model_B_exec.py

@@ -0,0 +1,23 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from documentation.examples import sys_model_B
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains sys_model_B
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+print()
+print("Tensor Field: sys_model_B")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

licenses/AGREEMENT.txt

@@ -1,150 +0,0 @@
-SOFTWARE LICENSE AGREEMENT
-
-This Software License Agreement (the “Agreement”) is entered into as of December __ 2018, (the “Effective Date”) between
-Dapper Labs, Inc., a Canadian corporation having its principal place of business at 980-350 Howe Street,
-Vancouver, BC V6Z 1N9 (“DLI”) and BlockScience, Inc., a California corporation with an address at 471 McAuley Street,
-Oakland, CA 94609 (“BlockScience”). This Agreement includes the attached Exhibit A.
-
-WHEREAS, DLI and BlockScience are parties to that certain Professional Services Agreement dated March 23, 2018 (the
-“PSA”), pursuant to which BlockScience performed and is currently performing professional services and other development
-work for DLI;
-
-WHEREAS, as part of BlockScience’s performance under the PSA, BlockScience developed certain “behaviour archetypes” and
-“configuration of the Null Model”, which the parties agree are “Work Product” under the PSA;
-
-WHEREAS, the parties agree that BlockScience’s proprietary SimCAD software tool is considered “Contractor Technology”
-under the PSA; and
-
-WHEREAS, the parties wish to enter into this Agreement to clarify DLI’s rights to use the SimCAD software tool on a
-going-forward basis.
-
-NOW, THEREFORE, for good and valuable consideration, the receipt and sufficiency of which is hereby acknowledged, DLI
-and BlockScience agree as follows:
-
-1. DEFINITIONS
-
-(a) “Affiliate” means any entity that, directly or indirectly through one or more intermediaries, controls, is
-controlled by, or is under common control with, DLI.
-
-(b) “Documentation” means any manuals, documentation and other supporting materials related to the Software.
-Documentation is considered part of the related Software.
-
-(c) “Intellectual Property Rights” means patent rights (including patent applications and disclosures), copyrights,
-trade marks, trade secrets, know-how and any other intellectual property rights recognized in any country or
-jurisdiction in the world.
-
-(d) “Software” means the object and source code versions of BlockScience’s proprietary SimCAD software product more
-fully described in Exhibit A. Software includes the applicable Documentation, as well as any Updates.
-
-(e) “Update” means any bug fix, error correction, patch, modification, enhancement, update, upgrade, replacement,
-successor product, new version, new release, or derivative work of or to the Software.
-
-(f) “Zeus” means the decentralized synchronous computational network developed by DLI, as such name or reference may be
-changed from time to time at DLI’s sole discretion.
-
-2. SOFTWARE LICENSE
-
-(a) License Grant. BlockScience hereby grants to DLI and its Affiliates a worldwide, non-exclusive, royalty-free,
-irrevocable, perpetual license to (i) download, install, use, execute, access, copy, perform, and modify, the Software
-in connection with the Zeus project; (ii) distribute and display the Software internally amongst DLI and its Affiliates,
-its and their employees, contractors, and agents, subject to the use of reasonable efforts to maintain the confidential
-status of the non-public aspects of the Software display; and (iii) create derivative works of the Software in
-connection with the Zeus project, provided that any such derivative works may only be used in connection with the Zeus
-project. For the sake of clarity, nothing in this Agreement (including, without limitation, this Section 2) will create
-any liability to DLI for or restrict DLI’s ability to externally distribute python scripts containing the “input”
-configuration files specific to the Zeus project, as well as the notebooks with the resulting “output” data from the
-Software, all of which may be distributed, displayed, and shared publicly at DLI’s discretion.
-
-(b) Ownership; Limited Rights. As between the parties, BlockScience owns and retains all right, title and interest in
-and to the Software, and all Intellectual Property Rights therein. DLI’s rights in the Software are limited to those
-expressly granted in Section 2(a) and in the PSA. BlockScience reserves all rights and licenses in the Software not
-expressly granted to DLI herein and in the PSA.
-
-(c) Delivery. BlockScience will deliver a copy of the Software and Documentation to DLI on the Effective Date. The
-delivery may be made in electronic form, or via hardcopy medium (e.g., a CD).
-
-(d) Updates. BlockScience will deliver Updates to DLI as and when such Updates become available. The obligation to
-deliver Updates will continue for as long as the PSA remains in force; upon termination or expiration of the PSA,
-BlockScience’s obligation to provide Updates will automatically terminate.
-
-(e) Support. BlockScience will provide reasonable technical support for the Software, to help DLI manage any support
-issues that arise. The obligation to provide support will continue for as long as the PSA remains in force; upon
-termination or expiration of the PSA, BlockScience’s obligation to provide support will automatically terminate.
-
-3. NO FEES.
-
-There are no fees owed by DLI for the license granted or the Updates or support provided by BlockScience
-pursuant to this Agreement. Each party will bear its own costs and expenses arising out of or relating to its
-obligations, efforts and performance under this Agreement.
-
-4. LIMITED WARRANTY; DISCLAIMER
-
-(a) Limited Warranty. BlockScience represents and warrants as follows: (i) that it has the right to enter into this
-Agreement, and to perform its obligations hereunder, without violating the terms of any other agreement; (ii) that the
-Software, and any Updates, do not and will not infringe, violate, or misappropriate the Intellectual Property Rights of
-any third party; (iii) that the Software and any Updates do not and will not contain any virus, malware, spyware, trojan
-horse, or other malicious code; and (iv) that the Software and each Update will substantially conform to its
-Documentation.
-
-(b) Disclaimer. EXCEPT AS OTHERWISE SET FORTH IN THIS AGREEMENT, BLOCKSCIENCE DISCLAIMS ALL OTHER WARRANTIES, EXPRESS OR
-IMPLIED, RELATED TO THE SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
-PURPOSE.
-
-5. TERM & TERMINATION
-
-(a) Term. This Agreement begins on the Effective Date, and will continue in effect until one of us terminates it in
-accordance with Section 5(b).
-
-(b) Termination for Breach. Either party may terminate this Agreement if the other party breaches any material term or
-condition of this Agreement, and the breaching party fails to cure the breach within thirty (30) days of receiving
-written notice of it.
-
-(c) Survival. Sections 2 through 7 will survive termination or expiration of this Agreement.
-
-6. INDEMNIFICATION.
-
-BlockScience will defend, indemnify, and hold DLI harmless from and against any claim, damage, loss,
-liability, expense and cost (including, without limitation, reasonable attorneys’ fees) incurred by or brought against
-DLI arising out of or related to: (i) any claim that the Software infringes or misappropriates the Intellectual Property
-Rights of that third party; or (ii) BlockScience’s breach of its limited warranties in Section 4(a).
-
-7. GENERAL TERMS
-
-(a) Entire Agreement; Waiver. This Agreement is the entire understanding of the parties, and supersedes any and all
-prior agreements or understandings between the parties as to its subject matter. It may be amended or modified, or
-provisions waived, only in a writing signed by both parties. The waiver of a breach of any provision of this Agreement
-will not operate or be interpreted as a waiver of any other or subsequent breach.
-
-(b) Acknowledgement. BlockScience acknowledges and agrees that the “behaviour archetypes” and “configuration of the Null
-Model” referenced in the PSA are considered “Work Product” under the PSA.
-
-(c) Governing Law. This Agreement will be construed, interpreted and applies in accordance with the internal laws of
-British Columbia, Canada (excluding its body of law controlling conflicts of law). Any legal action or proceeding
-arising under or related to this Agreement will be brought exclusively in the federal or provincial courts located in
-Vancouver, British Columbia, and the parties irrevocably consent to personal jurisdiction and venue there.
-
-(d) Severability. If any provision of this Agreement is held to be invalid or unenforceable for any reason, that
-provision will be enforced to the maximum extent permitted by law, and the remaining provisions will continue in full
-force and effect.
-
-(e) Miscellaneous. This Agreement may be executed in one or more counterparts, with the same effect as if the parties
-had signed the same document. Each counterpart so executed will be deemed to be an original, and all such counterparts
-will be construed together and will constitute one Agreement. The prevailing party in any action or legal proceeding
-arising out of this Agreement will be entitled to recover from the other party all reasonable costs and expenses
-incurred in connection with such action or proceeding, including reasonable attorneys’ fees and court costs. In the
-event of a direct conflict between the terms of this Agreement and the PSA with respect to the DLI’s rights in and to
-the Software, the terms of this Agreement will control.
-
-EXHIBIT A
-
-SOFTWARE
-
-Software Name: SimCAD tool
-
-Software Description: SimCAD is a Monte-Carlo based simulation software package for research, validation, and
-Computer Aided Design of economic systems. An economic system is treated as a state based model and defined
-through a set of endogenous and exogenous state variables which are updated through mechanisms and
-environmental processes, respectively. Behavioral models, which may be deterministic or stochastic, provide the
-evolution of the system within the action space of the mechanisms. Simulations can be run with a range of initial
-conditions and parameters for states, behaviors, mechanisms, and environmental processes to understand and
-visualize network behavior under various conditions.

licenses/LICENSE

@@ -1,119 +0,0 @@
-TRIAL LICENSE AGREEMENT
-
-BACKGROUND
-
-Company has developed and intends to market and license a certain software product and service called ”SimCAD” which,
-among other things, is a scientific engineering simulation tool (“Software”). Company wishes to provide access, on a
-trial basis, to users of a “beta” version of the Software to test and provide feedback to Company. Licensee wishes to
-participate in Company’s beta trial of the Software and to provide feedback to Company with respect to Licensee’s use
-thereof.
-
-Accordingly, the parties hereby agree as follows:
-
-1. BETA PRODUCT.
-
-This Agreement applies to any pre­release version of the Software and any updates and changes thereto during the Term
-(collectively, “Beta Product”). As an essential condition of this Agreement, Licensee understands and acknowledges that:
-(a) Licensee is participating in a beta test of the Beta Product; (b) the Beta Product has not been field tested or
-trialed; and (c) the Beta Product may not operate properly or be error free and may not perform all functions for
-which it is intended or represented.
-
-2. FEEDBACK.
-
-As a condition of this Agreement, during the Term of this Agreement, Licensee agrees to provide Company with comments,
-feedback, criticisms, and suggestions for changes to the Beta Product (“Feedback”), and to help Company identify errors
-or malfunctions, and performance issues, in the operation of the Beta Product, as Company may reasonably request. All
-rights to any Feedback or other intellectual property derived from Licensee’s use of or relating to the Beta Product,
-as well any data collected from the use of the Beta Product, belong solely to Company and Licensee hereby irrevocably
-assigns all such rights to Company. Company reserves the right to use all Feedback and data collected as a result of the
-use of the Beta Product to advertise and promote the Company and the Software.
-
-3. LICENSE AND RESERVATION OF RIGHTS.
-
-3.1 Subject to the terms and conditions set forth in this Agreement, Company hereby grants Licensee, and Licensee
-accepts, during the Term, a non­exclusive, royalty­free, revocable, non­transferable, limited license to access and use
-the Beta Product for its internal, non­commercial use for evaluation purposes only, and to give permission to employees
-of Licensee and employees of Licensee’s subsidiaries (“Permitted Users”) to use the Beta Product in accordance with the
-foregoing.
-
-3.2 The Beta Product and the Software comprise the intellectual property of Company. All right, title and interest in
-and to the Beta Product (and, more generally, in and to the Software), and to all Feedback and data arising from its
-use, in whole or in part, and all patent, copyright, trade­marks, trade secret and all other intellectual and industrial
-property rights therein and the structure, sequence and organization of same, and the media on which such material is
-contained belong exclusively to Company. Licensee and its Permitted Users will not, directly or indirectly: reverse
-engineer, decompile, disassemble or otherwise attempt to discover the source code, object code or underlying structure,
-ideas, know­how or algorithms relevant to the Beta Product; modify, adapt, alter, edit, correct, translate, publish,
-sell, transfer, assign, convey, rent, lease, loan, pledge, sublicense, distribute, export, enhance or create derivative
-works based on the Beta Product; or remove, alter, cover or otherwise obscure any proprietary notices or labels
-displayed on or within the Beta Product any documentation relating thereto.
-
-4. DISCLAIMER.
-
-4.1 COMPANY MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, WITH RESPECT TO THE BETA PRODUCT,
-INCLUDING, BUT NOT LIMITED TO, THE AVAILABILITY, QUALITY OR PERFORMANCE OF THE BETA PRODUCT. COMPANY SPECIFICALLY
-DISCLAIMS ALL EXPRESS, STATUTORY AND IMPLIED WARRANTIES AND CONDITIONS, INCLUDING, WITHOUT LIMITATION (A) THE IMPLIED
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON­INFRINGEMENT, (B) ANY WARRANTIES AGAINST HIDDEN
-OR LATENT DEFECTS, (C) AND ANY WARRANTIES AND CONDITIONS ARISING OUT OF COURSE OF DEALING OR USAGE OF TRADE AND (D) ANY
-WARRANTY OR REPRESENTATION THAT THE BETA PRODUCT IS ERROR­FREE, VIRUS­FREE, SECURE, UNINTERRUPTED, OR FREE FROM
-UNAUTHORIZED ACCESS (INCLUDING, BUT NOT LIMITED TO, THIRD PARTY HACKERS OR DENIAL OF SERVICE ATTACKS). THE BETA PRODUCT
-IS SUPPLIED ON AN “AS IS”, “AS AVAILABLE” BASIS WITHOUT WARRANTY.
-
-4.2 NEITHER PARTY SHALL BE LIABLE FOR SPECIAL, INCIDENTAL, PUNITIVE, CONSEQUENTIAL OR INDIRECT DAMAGES OR LOSS
-(INCLUDING DEATH AND PERSONAL INJURY), IRRESPECTIVE OF THEIR CAUSE, NOTWITHSTANDING THAT A PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH LOSS OR DAMAGE, NOR FOR ANY CLAIMS FOR SUCH LOSS OR DAMAGE INSTITUTED AGAINST A PARTY OR ITS
-CUSTOMERS BY ANY THIRD PARTY.
-
-5. CONFIDENTIALITY
-
-5.1 All Confidential Information disclosed by either party shall be kept by the receiving party in strict confidence and
-shall not be disclosed to any third party without the disclosing party’s express written consent. For purposes of this
-Agreement, “Confidential Information” means all information regarding either party’s business which has been marked or
-is otherwise communicated as being “proprietary” or “confidential” or which reasonably should be known by the receiving
-party to be proprietary or confidential information. Without limiting the generality of the foregoing, Confidential
-Information of Company includes non­public information regarding features, functionality and performance of the Beta
-Product, including all Feedback and related data. Notwithstanding the foregoing, each party’s confidentiality
-obligations hereunder shall not apply to information that: (a) is already known to the receiving party without a
-pre­existing restriction as to disclosure; (b) is or becomes publicly available without fault of the receiving party;
-(c) is rightfully obtained by the receiving party from a third party without restriction as to disclosure, or is
-approved for release by written authorization of the disclosing party; (d) is developed independently by the receiving
-party without use of the disclosing party’s Confidential Information; or (e) is required to be disclosed by law or
-regulation, including, but not limited to, supplying such information or making such statements or disclosures relating
-to this Agreement before any competent court, governmental agency or authority in response to a lawful requirement or
-request from a court of governmental agency or authority, provided that the disclosing party shall give the other party
-prompt notice of such request, to the extent practicable, so that the other party may seek (at its sole cost and
-expense) an appropriate protective order or similar relief.
-
-5.2 In the event of a breach of Sections 2, 3 or this Section 5, the non­breaching party shall be entitled to seek
-equitable relief to protect its interests, including, but not limited to, injunctive relief. In the event of expiration
-or earlier termination of this Agreement, each party shall immediately return to the other party such other party’s
-Confidential Information, or at such other party’s option, destroy any remaining Confidential Information and certify
-that such destruction has taken place.
-
-6. FEES; EXPENSES.
-
-Neither party shall be entitled to any compensation in connection with this Agreement or its use or provision of the
-Beta Product. Each party shall bear its own costs and expenses arising from this Agreement and its use or provision of
-the Beta Product, as the case may be.
-
-7. TERM OF AGREEMENT.
-
-This Agreement shall begin on the Effective Date and shall continue until it has been terminated (such period, the
-“Term”). Either party shall have the right to terminate this Agreement at any time on one (1) month written notice to
-the other party, or in the case of a breach of this Agreement by Licensee or its Permitted Users, Company may terminate
-this Agreement immediately on written notice to Licensee. Upon termination of this Agreement, all rights granted to
-Licensee (and any Permitted User) under this Agreement will immediately terminate and Licensee (and all Permitted Users)
-must immediately cease all use of the Beta Product at such time. Notwithstanding any termination of this Agreement,
-Sections 2, 3.2, 4, 5, 6, this Section 7 and Section 8 shall survive and remain binding on the parties.
-
-8. MISCELLANEOUS.
-
-This Agreement shall be governed by and construed in accordance with the laws of the State of New York. All disputes
-relating to this Agreement shall be resolved in the federal and state courts of New York County, New York and the
-parties submit to the jurisdiction of such courts. This Agreement does not create any agency, partnership, or joint
-venture relationship between Licensee and Company. This Agreement is the entire understanding of the parties with
-respect to the subject matter hereof and supersedes any previous or contemporaneous communications, representations,
-warranties, discussions, arrangements or commitments, whether oral or written with respect to such subject matter. This
-Agreement cannot be amended except by a written amendment that expressly refers to this Agreement and is signed by an
-authorized representative of each party. This Agreement may be executed in one or more counterparts, including via
-facsimile or email (or any other electronic means such as “.pdf” or “.tiff” files), each of which shall be deemed an
-original, and all of which shall constitute one and the same Agreement.

notebooks/jjodesty/multithreading.ipynb

@@ -1,576 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "import _thread\n",
-    "import time\n",
-    "from fn.func import curried"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define a function for the thread\n",
-    "def f(threadName, delay):\n",
-    "   count = 0\n",
-    "   print(count)\n",
-    "   # while count < 5:\n",
-    "   #    time.sleep(delay)\n",
-    "   #    count += 1\n",
-    "   #    print(count)\n",
-    "      \n",
-    "def pipe(x):\n",
-    "    print(x)\n",
-    "    return x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "00\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Create two threads as follows\n",
-    "try:\n",
-    "   _thread.start_new_thread( f, (\"Thread-1\", 2, ) )\n",
-    "   _thread.start_new_thread( f, (\"Thread-2\", 4, ) )\n",
-    "except:\n",
-    "   print (\"Error: unable to start thread\")\n",
-    "\n",
-    "while 1:\n",
-    "   pass\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1, 2]\n",
-      "('s2', <function fit_param.<locals>.<lambda> at 0x1099efae8>)\n",
-      "('s2', <function fit_param.<locals>.<lambda> at 0x1099ef9d8>)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from SimCAD.engine.utils import sweep\n",
-    "from SimCAD.utils import rename\n",
-    "from SimCAD.configuration.utils import s_update\n",
-    "\n",
-    "# @curried\n",
-    "def fit_param(param):\n",
-    "    return lambda x: x + param\n",
-    "\n",
-    "# xf = lambda param: lambda x: x + param\n",
-    "\n",
-    "def sweep(params, y, xf):\n",
-    "    op = [rename('sweep', s_update(y, xf(param))) for param in params]\n",
-    "    print(params)\n",
-    "    # print()\n",
-    "    return op\n",
-    "\n",
-    "for f in sweep([1,2], 's2', fit_param):\n",
-    "    print(f(1,2,3,4))\n",
-    "# sweep([1,2], 's2', xf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1, 64, 2187, 65536]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# instantiate and configure the worker pool\n",
-    "from pathos.threading import ThreadPool\n",
-    "pool = ThreadPool(nodes=4)\n",
-    "\n",
-    "# do a blocking map on the chosen function\n",
-    "print(pool.map(pow, [1,2,3,4], [5,6,7,8]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "SyntaxError",
-     "evalue": "invalid syntax (<ipython-input-2-6e999d313015>, line 3)",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-6e999d313015>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    [for f in fs]\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
-     ],
-     "output_type": "error"
-    }
-   ],
-   "source": [
-    "with Pool(len(configs)) as p:\n",
-    "    results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5]), l)\n",
-    "    \n",
-    "\n",
-    "def state_multithreading(self, fs, m_step, sL, last_in_obj, _input):\n",
-    "    if type(fs) == 'list':\n",
-    "        pool.map(f(m_step, sL, last_in_obj, _input), fs)\n",
-    "    else:\n",
-    "        f(m_step, sL, last_in_obj, _input)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[('s2', [11, 23])]"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from itertools import groupby\n",
-    "l = [('s2', 11), ('s2', 23)]\n",
-    "l.sort(key = lambda i : i[0])\n",
-    "[(key, [i[1] for i in values]) for key, values in groupby(l, lambda i: i[0])]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def groupByKV(l):\n",
-    "    l.sort(key = lambda i : i[0])\n",
-    "    return [(key, [i[1] for i in values]) for key, values in groupby(l, lambda i: i[0])]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[('s2', [11, 23])]"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "groupByKV(l)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "SyntaxError",
-     "evalue": "invalid syntax (<ipython-input-20-fada0ccd8d2a>, line 2)",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-20-fada0ccd8d2a>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    collect = lambda tuplist: reduce(lambda acc, (k,v): acc[k].append(v) or acc,tuplist, defaultdict(list))\u001b[0m\n\u001b[0m                                                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
-     ],
-     "output_type": "error"
-    }
-   ],
-   "source": [
-    "from collections import defaultdict                                                                                       \n",
-    "collect = lambda tuplist: reduce(lambda acc, (k,v): acc[k].append(v) or acc,tuplist, defaultdict(list))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from collections import defaultdict\n",
-    "d = defaultdict(list)\n",
-    "for key, value in [('s2', 11), ('s2', 23)]:\n",
-    "    d[key].append(value)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on defaultdict object:\n",
-      "\n",
-      "class defaultdict(builtins.dict)\n",
-      " |  defaultdict(default_factory[, ...]) --> dict with default factory\n",
-      " |  \n",
-      " |  The default factory is called without arguments to produce\n",
-      " |  a new value when a key is not present, in __getitem__ only.\n",
-      " |  A defaultdict compares equal to a dict with the same items.\n",
-      " |  All remaining arguments are treated the same as if they were\n",
-      " |  passed to the dict constructor, including keyword arguments.\n",
-      " |  \n",
-      " |  Method resolution order:\n",
-      " |      defaultdict\n",
-      " |      builtins.dict\n",
-      " |      builtins.object\n",
-      " |  \n",
-      " |  Methods defined here:\n",
-      " |  \n",
-      " |  __copy__(...)\n",
-      " |      D.copy() -> a shallow copy of D.\n",
-      " |  \n",
-      " |  __getattribute__(self, name, /)\n",
-      " |      Return getattr(self, name).\n",
-      " |  \n",
-      " |  __init__(self, /, *args, **kwargs)\n",
-      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
-      " |  \n",
-      " |  __missing__(...)\n",
-      " |      __missing__(key) # Called by __getitem__ for missing key; pseudo-code:\n",
-      " |      if self.default_factory is None: raise KeyError((key,))\n",
-      " |      self[key] = value = self.default_factory()\n",
-      " |      return value\n",
-      " |  \n",
-      " |  __reduce__(...)\n",
-      " |      Return state information for pickling.\n",
-      " |  \n",
-      " |  __repr__(self, /)\n",
-      " |      Return repr(self).\n",
-      " |  \n",
-      " |  copy(...)\n",
-      " |      D.copy() -> a shallow copy of D.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors defined here:\n",
-      " |  \n",
-      " |  default_factory\n",
-      " |      Factory for default value called by __missing__().\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from builtins.dict:\n",
-      " |  \n",
-      " |  __contains__(self, key, /)\n",
-      " |      True if D has a key k, else False.\n",
-      " |  \n",
-      " |  __delitem__(self, key, /)\n",
-      " |      Delete self[key].\n",
-      " |  \n",
-      " |  __eq__(self, value, /)\n",
-      " |      Return self==value.\n",
-      " |  \n",
-      " |  __ge__(self, value, /)\n",
-      " |      Return self>=value.\n",
-      " |  \n",
-      " |  __getitem__(...)\n",
-      " |      x.__getitem__(y) <==> x[y]\n",
-      " |  \n",
-      " |  __gt__(self, value, /)\n",
-      " |      Return self>value.\n",
-      " |  \n",
-      " |  __iter__(self, /)\n",
-      " |      Implement iter(self).\n",
-      " |  \n",
-      " |  __le__(self, value, /)\n",
-      " |      Return self<=value.\n",
-      " |  \n",
-      " |  __len__(self, /)\n",
-      " |      Return len(self).\n",
-      " |  \n",
-      " |  __lt__(self, value, /)\n",
-      " |      Return self<value.\n",
-      " |  \n",
-      " |  __ne__(self, value, /)\n",
-      " |      Return self!=value.\n",
-      " |  \n",
-      " |  __new__(*args, **kwargs) from builtins.type\n",
-      " |      Create and return a new object.  See help(type) for accurate signature.\n",
-      " |  \n",
-      " |  __setitem__(self, key, value, /)\n",
-      " |      Set self[key] to value.\n",
-      " |  \n",
-      " |  __sizeof__(...)\n",
-      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
-      " |  \n",
-      " |  clear(...)\n",
-      " |      D.clear() -> None.  Remove all items from D.\n",
-      " |  \n",
-      " |  fromkeys(iterable, value=None, /) from builtins.type\n",
-      " |      Returns a new dict with keys from iterable and values equal to value.\n",
-      " |  \n",
-      " |  get(...)\n",
-      " |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n",
-      " |  \n",
-      " |  items(...)\n",
-      " |      D.items() -> a set-like object providing a view on D's items\n",
-      " |  \n",
-      " |  keys(...)\n",
-      " |      D.keys() -> a set-like object providing a view on D's keys\n",
-      " |  \n",
-      " |  pop(...)\n",
-      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
-      " |      If key is not found, d is returned if given, otherwise KeyError is raised\n",
-      " |  \n",
-      " |  popitem(...)\n",
-      " |      D.popitem() -> (k, v), remove and return some (key, value) pair as a\n",
-      " |      2-tuple; but raise KeyError if D is empty.\n",
-      " |  \n",
-      " |  setdefault(...)\n",
-      " |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\n",
-      " |  \n",
-      " |  update(...)\n",
-      " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
-      " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
-      " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
-      " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
-      " |  \n",
-      " |  values(...)\n",
-      " |      D.values() -> an object providing a view on D's values\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from builtins.dict:\n",
-      " |  \n",
-      " |  __hash__ = None\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "help(d)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'s2': [11, 23]}"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dict(d)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def groupByKey(l):\n",
-    "    d = defaultdict(list)\n",
-    "    for key, value in l:\n",
-    "        d[key].append(value)\n",
-    "    return list(dict(d).items()).pop()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "('s2', [11, 23])"
-      ]
-     },
-     "execution_count": 56,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "r = groupByKey([('s2', 11), ('s2', 23)])\n",
-    "r"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# xf = lambda param: 1.0 + param\n",
-    "# def xf(y, param, s):\n",
-    "#     return s[y] + param\n",
-    "\n",
-    "# def fit_param(param):\n",
-    "#     y = 's2'\n",
-    "#     x = 1 + param\n",
-    "#     return lambda step, sL, s, _input: (y, x)\n",
-    "#\n",
-    "# def fit_param(param):\n",
-    "#     return lambda step, sL, s, _input: (\n",
-    "#         's2',\n",
-    "#         s['s2'] + param\n",
-    "#     )\n",
-    "#\n",
-    "# s2m1 = sweep(\n",
-    "#     params = [Decimal(11.0), Decimal(22.0)],\n",
-    "#     sweep_f = fit_param\n",
-    "# )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from decimal import Decimal\n",
-    "from itertools import product\n",
-    "\n",
-    "# def \n",
-    "\n",
-    "l = {\n",
-    "    's1': 1, \n",
-    "    's2': [Decimal('11'), Decimal('22')], \n",
-    "    's3': [Decimal('12'), Decimal('23')], \n",
-    "    's4': 10, \n",
-    "    'timestamp': '2018-10-01 15:16:25', \n",
-    "    'mech_step': 0, \n",
-    "    'time_step': 1\n",
-    "}\n",
-    "\n",
-    "def flattenDict(l):\n",
-    "    def tupalize(k, vs):\n",
-    "        l = []\n",
-    "        if isinstance(vs, list):\n",
-    "            for v in vs:\n",
-    "                l.append((k, v))\n",
-    "        else:\n",
-    "            l.append((k, vs))\n",
-    "        return l\n",
-    "\n",
-    "    flat_list = [tupalize(k, vs) for k, vs in l.items()]\n",
-    "    flat_dict = [dict(items) for items in product(*flat_list)]\n",
-    "    return flat_dict"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'s1': 1,\n",
-       "  's2': Decimal('11'),\n",
-       "  's3': Decimal('12'),\n",
-       "  's4': 10,\n",
-       "  'timestamp': '2018-10-01 15:16:25',\n",
-       "  'mech_step': 0,\n",
-       "  'time_step': 1},\n",
-       " {'s1': 1,\n",
-       "  's2': Decimal('11'),\n",
-       "  's3': Decimal('23'),\n",
-       "  's4': 10,\n",
-       "  'timestamp': '2018-10-01 15:16:25',\n",
-       "  'mech_step': 0,\n",
-       "  'time_step': 1},\n",
-       " {'s1': 1,\n",
-       "  's2': Decimal('22'),\n",
-       "  's3': Decimal('12'),\n",
-       "  's4': 10,\n",
-       "  'timestamp': '2018-10-01 15:16:25',\n",
-       "  'mech_step': 0,\n",
-       "  'time_step': 1},\n",
-       " {'s1': 1,\n",
-       "  's2': Decimal('22'),\n",
-       "  's3': Decimal('23'),\n",
-       "  's4': 10,\n",
-       "  'timestamp': '2018-10-01 15:16:25',\n",
-       "  'mech_step': 0,\n",
-       "  'time_step': 1}]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "flattenDict(l)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

requirements.txt

@@ -1,5 +1,6 @@
-wheel
 pandas
+wheel
 pathos
 fn
-tabulate
+tabulate
+funcy

setup.py

@@ -1,23 +1,38 @@
 from setuptools import setup, find_packages
 
-long_description = "cadCAD is a differential games based simulation software package for research, validation, and \
-    Computer Aided Design of economic systems. An economic system is treated as a state based model and defined through \
-    a set of endogenous and exogenous state variables which are updated through mechanisms and environmental processes, \
-    respectively. Behavioral models, which may be deterministic or stochastic, provide the evolution of the system \
-    within the action space of the mechanisms. Mathematical formulations of these economic games treat agent utility as \
-    derived from state rather than direct from action, creating a rich dynamic modeling framework. Simulations may be \
-    run with a range of initial conditions and parameters for states, behaviors, mechanisms, and environmental \
-    processes to understand and visualize network behavior under various conditions. Support for A/B testing policies, \
-    monte carlo analysis and other common numerical methods is provided."
+long_description = """
+cadCAD (complex adaptive systems computer-aided design) is a python based, unified modeling framework for stochastic 
+dynamical systems and differential games for research, validation, and Computer Aided Design of economic systems created 
+by BlockScience. It is capable of modeling systems at all levels of abstraction from Agent Based Modeling (ABM) to 
+System Dynamics (SD), and enabling smooth integration of computational social science simulations with empirical data 
+science workflows.
+
+An economic system is treated as a state-based model and defined through a set of endogenous and exogenous state 
+variables which are updated through mechanisms and environmental processes, respectively. Behavioral models, which may 
+be deterministic or stochastic, provide the evolution of the system within the action space of the mechanisms. 
+Mathematical formulations of these economic games treat agent utility as derived from the state rather than direct from 
+an action, creating a rich, dynamic modeling framework. Simulations may be run with a range of initial conditions and 
+parameters for states, behaviors, mechanisms, and environmental processes to understand and visualize network behavior 
+under various conditions. Support for A/B testing policies, Monte Carlo analysis, and other common numerical methods is 
+provided.
+"""
 
 setup(name='cadCAD',
-      version='0.1',
+      version='0.3.1',
       description="cadCAD: a differential games based simulation software package for research, validation, and \
         Computer Aided Design of economic systems",
-      long_description = long_description,
-      url='https://github.com/BlockScience/DiffyQ-cadCAD',
+      long_description=long_description,
+      url='https://github.com/BlockScience/cadCAD',
       author='Joshua E. Jodesty',
-      author_email='joshua@block.science',
-      # license='LICENSE',
-      packages=find_packages()
+      author_email='joshua@block.science, joshua.jodesty@gmail.com',
+      license='LICENSE.txt',
+      packages=find_packages(),
+      install_requires=[
+            "pandas",
+            "wheel",
+            "pathos",
+            "fn",
+            "tabulate",
+            "funcy"
+      ]
 )

simulations/example_run.py

@@ -1,34 +0,0 @@
-import pandas as pd
-from tabulate import tabulate
-# The following imports NEED to be in the exact order
-from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
-from simulations.validation import sweep_config, config1, config2
-from cadCAD import configs
-
-exec_mode = ExecutionMode()
-
-print("Simulation Execution 1")
-print()
-first_config = [configs[0]] # from config1
-single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
-run1 = Executor(exec_context=single_proc_ctx, configs=first_config)
-run1_raw_result, tensor_field = run1.main()
-result = pd.DataFrame(run1_raw_result)
-print()
-print("Tensor Field:")
-print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
-print("Output:")
-print(tabulate(result, headers='keys', tablefmt='psql'))
-print()
-
-print("Simulation Execution 2: Concurrent Execution")
-multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
-run2 = Executor(exec_context=multi_proc_ctx, configs=configs)
-for raw_result, tensor_field in run2.main():
-    result = pd.DataFrame(raw_result)
-    print()
-    print("Tensor Field:")
-    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
-    print("Output:")
-    print(tabulate(result, headers='keys', tablefmt='psql'))
-    print()

simulations/external_data/output.csv

@@ -0,0 +1,27 @@
+ds1,ds2,ds3,run,substep,timestep
+0,0,1,1,0,0
+1,40,5,1,1,1
+2,40,5,1,2,1
+3,40,5,1,3,1
+4,40,5,1,1,2
+5,40,5,1,2,2
+6,40,5,1,3,2
+7,40,5,1,1,3
+8,40,5,1,2,3
+9,40,5,1,3,3
+10,40,5,1,1,4
+11,40,5,1,2,4
+12,40,5,1,3,4
+0,0,1,2,0,0
+1,40,5,2,1,1
+2,40,5,2,2,1
+3,40,5,2,3,1
+4,40,5,2,1,2
+5,40,5,2,2,2
+6,40,5,2,3,2
+7,40,5,2,1,3
+8,40,5,2,2,3
+9,40,5,2,3,3
+10,40,5,2,1,4
+11,40,5,2,2,4
+12,40,5,2,3,4

simulations/external_ds_write.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+# from simulations.validation import config1_test_pipe
+# from simulations.validation import config1
+from simulations.validation import write_simulation
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, _ = run.main()
+result = pd.DataFrame(raw_result)
+result.to_csv('/Users/jjodesty/Projects/DiffyQ-SimCAD/simulations/external_data/output.csv', index=False)
+
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/param_sweep_run.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.validation import sweep_config
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Concurrent Execution")
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+i = 0
+config_names = ['sweep_config_A', 'sweep_config_B']
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print("Tensor Field: " + config_names[i])
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print("Output:")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1

simulations/regression_tests/config1.py

@@ -1,17 +1,15 @@
-from decimal import Decimal
 import numpy as np
 from datetime import timedelta
 
-from cadCAD.configuration import append_configs
-from cadCAD.configuration.utils import proc_trigger, bound_norm_random, ep_time_step
-from cadCAD.configuration.utils.parameterSweep import config_sim
 
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import bound_norm_random, config_sim, time_step, env_trigger
 
 seeds = {
     'z': np.random.RandomState(1),
     'a': np.random.RandomState(2),
     'b': np.random.RandomState(3),
-    'c': np.random.RandomState(3)
+    'c': np.random.RandomState(4)
 }
 
 
@@ -19,7 +17,7 @@ seeds = {
 def p1m1(_g, step, sL, s):
     return {'param1': 1}
 def p2m1(_g, step, sL, s):
-    return {'param2': 4}
+    return {'param1': 1, 'param2': 4}
 
 def p1m2(_g, step, sL, s):
     return {'param1': 'a', 'param2': 2}
@@ -35,7 +33,7 @@ def p2m3(_g, step, sL, s):
 # Internal States per Mechanism
 def s1m1(_g, step, sL, s, _input):
     y = 's1'
-    x = _input['param1']
+    x = s['s1'] + 1
     return (y, x)
 def s2m1(_g, step, sL, s, _input):
     y = 's2'
@@ -44,7 +42,7 @@ def s2m1(_g, step, sL, s, _input):
 
 def s1m2(_g, step, sL, s, _input):
     y = 's1'
-    x = _input['param1']
+    x = s['s1'] + 1
     return (y, x)
 def s2m2(_g, step, sL, s, _input):
     y = 's2'
@@ -53,115 +51,110 @@ def s2m2(_g, step, sL, s, _input):
 
 def s1m3(_g, step, sL, s, _input):
     y = 's1'
-    x = _input['param1']
+    x = s['s1'] + 1
     return (y, x)
 def s2m3(_g, step, sL, s, _input):
     y = 's2'
     x = _input['param2']
     return (y, x)
 
+def policies(_g, step, sL, s, _input):
+    y = 'policies'
+    x = _input
+    return (y, x)
+
 
 # Exogenous States
 proc_one_coef_A = 0.7
 proc_one_coef_B = 1.3
 
-def es3p1(_g, step, sL, s, _input):
+def es3(_g, step, sL, s, _input):
     y = 's3'
     x = s['s3'] * bound_norm_random(seeds['a'], proc_one_coef_A, proc_one_coef_B)
     return (y, x)
 
-def es4p2(_g, step, sL, s, _input):
+def es4(_g, step, sL, s, _input):
     y = 's4'
     x = s['s4'] * bound_norm_random(seeds['b'], proc_one_coef_A, proc_one_coef_B)
     return (y, x)
 
-ts_format = '%Y-%m-%d %H:%M:%S'
-t_delta = timedelta(days=0, minutes=0, seconds=1)
-def es5p2(_g, step, sL, s, _input):
-    y = 'timestep'
-    x = ep_time_step(s, dt_str=s['timestep'], fromat_str=ts_format, _timedelta=t_delta)
-    return (y, x)
-
-
-# Environment States
-def env_a(x):
-    return 5
-def env_b(x):
-    return 10
-# def what_ever(x):
-#     return x + 1
+def update_timestamp(_g, step, sL, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
 
 
 # Genesis States
 genesis_states = {
-    's1': Decimal(0.0),
-    's2': Decimal(0.0),
-    's3': Decimal(1.0),
-    's4': Decimal(1.0),
-#     'timestep': '2018-10-01 15:16:24'
-}
-
-
-raw_exogenous_states = {
-    "s3": es3p1,
-    "s4": es4p2,
-#     "timestep": es5p2
+    's1': 0.0,
+    's2': 0.0,
+    's3': 1.0,
+    's4': 1.0,
+    'timestamp': '2018-10-01 15:16:24'
 }
 
 
+# Environment Process
+# ToDo: Depreciation Waring for env_proc_trigger convention
+trigger_timestamps = ['2018-10-01 15:16:25', '2018-10-01 15:16:27', '2018-10-01 15:16:29']
 env_processes = {
-    "s3": env_a,
-    "s4": proc_trigger(1, env_b)
+    "s3": [lambda _g, x: 5],
+    "s4": env_trigger(3)(trigger_field='timestamp', trigger_vals=trigger_timestamps, funct_list=[lambda _g, x: 10])
 }
 
 
-partial_state_update_block = {
-    "m1": {
+partial_state_update_block = [
+    {
         "policies": {
             "b1": p1m1,
             "b2": p2m1
         },
         "variables": {
             "s1": s1m1,
-            "s2": s2m1
+            "s2": s2m1,
+            "s3": es3,
+            "s4": es4,
+            "timestamp": update_timestamp
         }
     },
-    "m2": {
+    {
         "policies": {
             "b1": p1m2,
             "b2": p2m2
         },
         "variables": {
             "s1": s1m2,
-            "s2": s2m2
+            "s2": s2m2,
+            # "s3": es3p1,
+            # "s4": es4p2,
         }
     },
-    "m3": {
+    {
         "policies": {
             "b1": p1m3,
             "b2": p2m3
         },
         "variables": {
             "s1": s1m3,
-            "s2": s2m3
+            "s2": s2m3,
+            # "s3": es3p1,
+            # "s4": es4p2,
         }
     }
-}
+]
 
 
 sim_config = config_sim(
     {
-        "N": 2,
+        "N": 1,
+        # "N": 5,
         "T": range(5),
     }
 )
 
-
 append_configs(
     sim_configs=sim_config,
     initial_state=genesis_states,
-    seeds=seeds,
-    raw_exogenous_states=raw_exogenous_states,
     env_processes=env_processes,
-    partial_state_update_blocks=partial_state_update_block
-)
+    partial_state_update_blocks=partial_state_update_block,
+    policy_ops=[lambda a, b: a + b]
+)

simulations/regression_tests/config2.py

@@ -1,10 +1,8 @@
-from decimal import Decimal
 import numpy as np
 from datetime import timedelta
 
 from cadCAD.configuration import append_configs
-from cadCAD.configuration.utils import proc_trigger, bound_norm_random, ep_time_step
-from cadCAD.configuration.utils.parameterSweep import config_sim
+from cadCAD.configuration.utils import bound_norm_random, config_sim, env_trigger, time_step
 
 seeds = {
     'z': np.random.RandomState(1),
@@ -64,65 +62,51 @@ def s2m3(_g, step, sL, s, _input):
 proc_one_coef_A = 0.7
 proc_one_coef_B = 1.3
 
-def es3p1(_g, step, sL, s, _input):
+def es3(_g, step, sL, s, _input):
     y = 's3'
     x = s['s3'] * bound_norm_random(seeds['a'], proc_one_coef_A, proc_one_coef_B)
     return (y, x)
 
-def es4p2(_g, step, sL, s, _input):
+def es4(_g, step, sL, s, _input):
     y = 's4'
     x = s['s4'] * bound_norm_random(seeds['b'], proc_one_coef_A, proc_one_coef_B)
     return (y, x)
 
-ts_format = '%Y-%m-%d %H:%M:%S'
-t_delta = timedelta(days=0, minutes=0, seconds=1)
-def es5p2(_g, step, sL, s, _input):
-    y = 'timestep'
-    x = ep_time_step(s, dt_str=s['timestep'], fromat_str=ts_format, _timedelta=t_delta)
-    return (y, x)
-
-
-# Environment States
-def env_a(x):
-    return 10
-def env_b(x):
-    return 10
-# def what_ever(x):
-#     return x + 1
+def update_timestamp(_g, step, sL, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
 
 
 # Genesis States
 genesis_states = {
-    's1': Decimal(0.0),
-    's2': Decimal(0.0),
-    's3': Decimal(1.0),
-    's4': Decimal(1.0),
-#     'timestep': '2018-10-01 15:16:24'
-}
-
-
-raw_exogenous_states = {
-    "s3": es3p1,
-    "s4": es4p2,
-#     "timestep": es5p2
+    's1': 0,
+    's2': 0,
+    's3': 1,
+    's4': 1,
+    'timestamp': '2018-10-01 15:16:24'
 }
 
 
+# Environment Process
+# ToDo: Depreciation Waring for env_proc_trigger convention
+trigger_timestamps = ['2018-10-01 15:16:25', '2018-10-01 15:16:27', '2018-10-01 15:16:29']
 env_processes = {
-    "s3": proc_trigger(1, env_a),
-    "s4": proc_trigger(1, env_b)
+    "s3": [lambda _g, x: 5],
+    "s4": env_trigger(3)(trigger_field='timestamp', trigger_vals=trigger_timestamps, funct_list=[lambda _g, x: 10])
 }
 
-
 partial_state_update_block = {
     "m1": {
         "policies": {
             "b1": p1m1,
             # "b2": p2m1
         },
-        "variables": {
+        "states": {
             "s1": s1m1,
             # "s2": s2m1
+            "s3": es3,
+            "s4": es4,
+            "timestep": update_timestamp
         }
     },
     "m2": {
@@ -130,7 +114,7 @@ partial_state_update_block = {
             "b1": p1m2,
             # "b2": p2m2
         },
-        "variables": {
+        "states": {
             "s1": s1m2,
             # "s2": s2m2
         }
@@ -140,7 +124,7 @@ partial_state_update_block = {
             "b1": p1m3,
             "b2": p2m3
         },
-        "variables": {
+        "states": {
             "s1": s1m3,
             "s2": s2m3
         }
@@ -155,12 +139,9 @@ sim_config = config_sim(
     }
 )
 
-
 append_configs(
     sim_configs=sim_config,
     initial_state=genesis_states,
-    seeds=seeds,
-    raw_exogenous_states=raw_exogenous_states,
     env_processes=env_processes,
     partial_state_update_blocks=partial_state_update_block
-)
+)

simulations/regression_tests/external_dataset.py

@@ -0,0 +1,67 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim
+import pandas as pd
+from cadCAD.utils import SilentDF
+
+df = SilentDF(pd.read_csv('/Users/jjodesty/Projects/DiffyQ-SimCAD/simulations/external_data/output.csv'))
+
+
+def query(s, df):
+    return df[
+            (df['run'] == s['run']) & (df['substep'] == s['substep']) & (df['timestep'] == s['timestep'])
+        ].drop(columns=['run', 'substep', "timestep"])
+
+def p1(_g, substep, sL, s):
+    result_dict = query(s, df).to_dict()
+    del result_dict["ds3"]
+    return {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+def p2(_g, substep, sL, s):
+    result_dict = query(s, df).to_dict()
+    del result_dict["ds1"], result_dict["ds2"]
+    return {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+# ToDo: SilentDF(df) wont work
+#integrate_ext_dataset
+def integrate_ext_dataset(_g, step, sL, s, _input):
+    result_dict = query(s, df).to_dict()
+    return 'external_data', {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+def increment(y, incr_by):
+    return lambda _g, step, sL, s, _input: (y, s[y] + incr_by)
+increment = increment('increment', 1)
+
+def view_policies(_g, step, sL, s, _input):
+    return 'policies', _input
+
+
+external_data = {'ds1': None, 'ds2': None, 'ds3': None}
+state_dict = {
+    'increment': 0,
+    'external_data': external_data,
+    'policies': external_data
+}
+
+
+policies = {"p1": p1, "p2": p2}
+states = {'increment': increment, 'external_data': integrate_ext_dataset, 'policies': view_policies}
+PSUB = {'policies': policies, 'states': states}
+
+# needs M1&2 need behaviors
+partial_state_update_blocks = {
+    'PSUB1': PSUB,
+    'PSUB2': PSUB,
+    'PSUB3': PSUB
+}
+
+sim_config = config_sim({
+    "N": 2,
+    "T": range(4)
+})
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=state_dict,
+    partial_state_update_blocks=partial_state_update_blocks,
+    policy_ops=[lambda a, b: {**a, **b}]
+)

simulations/regression_tests/historical_state_access.py

@@ -0,0 +1,91 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim, access_block
+
+policies, variables = {}, {}
+exclusion_list = ['nonexsistant', 'last_x', '2nd_to_last_x', '3rd_to_last_x', '4th_to_last_x']
+
+# Policies per Mechanism
+
+# WARNING: DO NOT delete elements from sH
+# state_history, target_field, psu_block_offset, exculsion_list
+def last_update(_g, substep, sH, s):
+    return {"last_x": access_block(
+            state_history=sH,
+            target_field="last_x",
+            psu_block_offset=-1,
+            exculsion_list=exclusion_list
+        )
+    }
+policies["last_x"] = last_update
+
+def second2last_update(_g, substep, sH, s):
+    return {"2nd_to_last_x": access_block(sH, "2nd_to_last_x", -2, exclusion_list)}
+policies["2nd_to_last_x"] = second2last_update
+
+
+# Internal States per Mechanism
+
+# WARNING: DO NOT delete elements from sH
+def add(y, x):
+    return lambda _g, substep, sH, s, _input: (y, s[y] + x)
+variables['x'] = add('x', 1)
+
+# last_partial_state_update_block
+def nonexsistant(_g, substep, sH, s, _input):
+    return 'nonexsistant', access_block(sH, "nonexsistant", 0, exclusion_list)
+variables['nonexsistant'] = nonexsistant
+
+# last_partial_state_update_block
+def last_x(_g, substep, sH, s, _input):
+    return 'last_x', _input["last_x"]
+variables['last_x'] = last_x
+
+# 2nd to last partial state update block
+def second_to_last_x(_g, substep, sH, s, _input):
+    return '2nd_to_last_x', _input["2nd_to_last_x"]
+variables['2nd_to_last_x'] = second_to_last_x
+
+# 3rd to last partial state update block
+def third_to_last_x(_g, substep, sH, s, _input):
+    return '3rd_to_last_x', access_block(sH, "3rd_to_last_x", -3, exclusion_list)
+variables['3rd_to_last_x'] = third_to_last_x
+
+# 4th to last partial state update block
+def fourth_to_last_x(_g, substep, sH, s, _input):
+    return '4th_to_last_x', access_block(sH, "4th_to_last_x", -4, exclusion_list)
+variables['4th_to_last_x'] = fourth_to_last_x
+
+
+genesis_states = {
+    'x': 0,
+    'nonexsistant': [],
+    'last_x': [],
+    '2nd_to_last_x': [],
+    '3rd_to_last_x': [],
+    '4th_to_last_x': []
+}
+
+PSUB = {
+    "policies": policies,
+    "variables": variables
+}
+
+partial_state_update_block = {
+    "PSUB1": PSUB,
+    "PSUB2": PSUB,
+    "PSUB3": PSUB
+}
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=partial_state_update_block
+)

simulations/regression_tests/policy_aggregation.py

@@ -0,0 +1,83 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim
+
+
+# Policies per Mechanism
+def p1m1(_g, step, sL, s):
+    return {'policy1': 1}
+def p2m1(_g, step, sL, s):
+    return {'policy2': 2}
+
+def p1m2(_g, step, sL, s):
+    return {'policy1': 2, 'policy2': 2}
+def p2m2(_g, step, sL, s):
+    return {'policy1': 2, 'policy2': 2}
+
+def p1m3(_g, step, sL, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+def p2m3(_g, step, sL, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+
+
+# Internal States per Mechanism
+def add(y, x):
+    return lambda _g, step, sH, s, _input: (y, s[y] + x)
+
+def policies(_g, step, sH, s, _input):
+    y = 'policies'
+    x = _input
+    return (y, x)
+
+
+# Genesis States
+genesis_states = {
+    'policies': {},
+    's1': 0
+}
+
+variables = {
+    's1': add('s1', 1),
+    "policies": policies
+}
+
+partial_state_update_block = {
+    "m1": {
+        "policies": {
+            "p1": p1m1,
+            "p2": p2m1
+        },
+        "variables": variables
+    },
+    "m2": {
+        "policies": {
+            "p1": p1m2,
+            "p2": p2m2
+        },
+        "variables": variables
+    },
+    "m3": {
+        "policies": {
+            "p1": p1m3,
+            "p2": p2m3
+        },
+        "variables": variables
+    }
+}
+
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+# Aggregation == Reduce Map / Reduce Map Aggregation
+# using env functions (include in reg test using / for env proc)
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=partial_state_update_block,
+    # ToDo: subsequent functions should include policy dict for access to each policy (i.e shouldnt be a map)
+    policy_ops=[lambda a, b: a + b, lambda y: y * 2] # Default: lambda a, b: a + b ToDO: reduction function requires high lvl explanation
+)

simulations/regression_tests/sweep_config.py

@@ -0,0 +1,159 @@
+import numpy as np
+from datetime import timedelta
+import pprint
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import env_trigger, var_substep_trigger, config_sim, time_step, psub_list
+
+from typing import Dict, List
+
+pp = pprint.PrettyPrinter(indent=4)
+
+seeds = {
+    'z': np.random.RandomState(1),
+    'a': np.random.RandomState(2),
+    'b': np.random.RandomState(3),
+    'c': np.random.RandomState(3)
+}
+
+# Optional
+g: Dict[str, List[int]] = {
+    'alpha': [1],
+    # 'beta': [2],
+    # 'gamma': [3],
+    'beta': [2, 5],
+    'gamma': [3, 4],
+    'omega': [7]
+}
+
+psu_steps = ['m1', 'm2', 'm3']
+system_substeps = len(psu_steps)
+var_timestep_trigger = var_substep_trigger([0, system_substeps])
+env_timestep_trigger = env_trigger(system_substeps)
+env_process = {}
+psu_block = {k: {"policies": {}, "variables": {}} for k in psu_steps}
+
+# ['s1', 's2', 's3', 's4']
+# Policies per Mechanism
+def p1m1(_g, step, sL, s):
+    return {'param1': 1}
+psu_block['m1']['policies']['p1'] = p1m1
+
+def p2m1(_g, step, sL, s):
+    return {'param2': 4}
+psu_block['m1']['policies']['p2'] = p2m1
+
+def p1m2(_g, step, sL, s):
+    return {'param1': 'a', 'param2': _g['beta']}
+psu_block['m2']['policies']['p1'] = p1m2
+
+def p2m2(_g, step, sL, s):
+    return {'param1': 'b', 'param2': 0}
+psu_block['m2']['policies']['p2'] = p2m2
+
+def p1m3(_g, step, sL, s):
+    return {'param1': np.array([10, 100])}
+psu_block['m3']['policies']['p1'] = p1m3
+
+def p2m3(_g, step, sL, s):
+    return {'param1': np.array([20, 200])}
+psu_block['m3']['policies']['p2'] = p2m3
+
+
+# Internal States per Mechanism
+def s1m1(_g, step, sL, s, _input):
+    return 's1', 0
+psu_block['m1']["variables"]['s1'] = s1m1
+
+def s2m1(_g, step, sL, s, _input):
+    return 's2', _g['beta']
+psu_block['m1']["variables"]['s2'] = s2m1
+
+def s1m2(_g, step, sL, s, _input):
+    return 's1', _input['param2']
+psu_block['m2']["variables"]['s1'] = s1m2
+
+def s2m2(_g, step, sL, s, _input):
+    return 's2', _input['param2']
+psu_block['m2']["variables"]['s2'] = s2m2
+
+def s1m3(_g, step, sL, s, _input):
+    return 's1', 0
+psu_block['m3']["variables"]['s1'] = s1m3
+
+def s2m3(_g, step, sL, s, _input):
+    return 's2', 0
+psu_block['m3']["variables"]['s2'] = s2m3
+
+
+# Exogenous States
+def update_timestamp(_g, step, sL, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
+for m in ['m1','m2','m3']:
+    # psu_block[m]["variables"]['timestamp'] = update_timestamp
+    psu_block[m]["variables"]['timestamp'] = var_timestep_trigger(y='timestamp', f=update_timestamp)
+    # psu_block[m]["variables"]['timestamp'] = var_trigger(
+    #     y='timestamp', f=update_timestamp, pre_conditions={'substep': [0, system_substeps]}, cond_op=lambda a, b: a and b
+    # )
+
+proc_one_coef = 0.7
+def es3(_g, step, sL, s, _input):
+    return 's3', s['s3'] + proc_one_coef
+# use `timestep_trigger` to update every ts
+for m in ['m1','m2','m3']:
+    psu_block[m]["variables"]['s3'] = var_timestep_trigger(y='s3', f=es3)
+
+
+def es4(_g, step, sL, s, _input):
+    return 's4', s['s4'] + _g['gamma']
+for m in ['m1','m2','m3']:
+    psu_block[m]["variables"]['s4'] = var_timestep_trigger(y='s4', f=es4)
+
+
+# ToDo: The number of values entered in sweep should be the # of config objs created,
+# not dependent on the # of times the sweep is applied
+# sweep exo_state func and point to exo-state in every other funtion
+# param sweep on genesis states
+
+# Genesis States
+genesis_states = {
+    's1': 0.0,
+    's2': 0.0,
+    's3': 1.0,
+    's4': 1.0,
+    'timestamp': '2018-10-01 15:16:24'
+}
+
+
+# Environment Process
+# ToDo: Validate - make env proc trigger field agnostic
+env_process["s3"] = [lambda _g, x: _g['beta'], lambda _g, x: x + 1]
+env_process["s4"] = env_timestep_trigger(trigger_field='timestep', trigger_vals=[5], funct_list=[lambda _g, x: _g['beta']])
+
+
+# config_sim Necessary
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+        "M": g, # Optional
+    }
+)
+
+# New Convention
+partial_state_update_blocks = psub_list(psu_block, psu_steps)
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    seeds=seeds,
+    env_processes=env_process,
+    partial_state_update_blocks=partial_state_update_blocks
+)
+
+
+print()
+print("Policie State Update Block:")
+pp.pprint(partial_state_update_blocks)
+print()
+print()

simulations/regression_tests/tests.py

@@ -0,0 +1,36 @@
+import unittest
+
+import pandas as pd
+# from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import policy_aggregation
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+
+class TestStringMethods(unittest.TestCase):
+    def __init__(self, result: pd.DataFrame, tensor_field: pd.DataFrame) -> None:
+        self.result = result
+        self.tensor_field = tensor_field
+
+    def test_upper(self):
+        self.assertEqual('foo'.upper(), 'FOO')
+
+    def test_isupper(self):
+        self.assertTrue('FOO'.isupper())
+        self.assertFalse('Foo'.isupper())
+
+    def test_split(self):
+        s = 'hello world'
+        self.assertEqual(s.split(), ['hello', 'world'])
+        # check that s.split fails when the separator is not a string
+        with self.assertRaises(TypeError):
+            s.split(2)
+
+if __name__ == '__main__':
+    unittest.main()

simulations/regression_tests/udo.py

@@ -0,0 +1,183 @@
+from copy import deepcopy
+
+import pandas as pd
+from fn.func import curried
+from datetime import timedelta
+import pprint as pp
+
+from cadCAD.utils import SilentDF #, val_switch
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import time_step, config_sim, var_trigger, var_substep_trigger, env_trigger, psub_list
+from cadCAD.configuration.utils.userDefinedObject import udoPipe, UDO
+
+
+DF = SilentDF(pd.read_csv('/Users/jjodesty/Projects/DiffyQ-SimCAD/simulations/external_data/output.csv'))
+
+
+class udoExample(object):
+    def __init__(self, x, dataset=None):
+        self.x = x
+        self.mem_id = str(hex(id(self)))
+        self.ds = dataset # for setting ds initially or querying
+        self.perception = {}
+
+    def anon(self, f):
+        return f(self)
+
+    def updateX(self):
+        self.x += 1
+        return self
+
+    def updateDS(self):
+        self.ds.iloc[0,0] -= 10
+        # pp.pprint(self.ds)
+        return self
+
+    def perceive(self, s):
+        self.perception = self.ds[
+            (self.ds['run'] == s['run']) & (self.ds['substep'] == s['substep']) & (self.ds['timestep'] == s['timestep'])
+        ].drop(columns=['run', 'substep']).to_dict()
+        return self
+
+    def read(self, ds_uri):
+        self.ds = SilentDF(pd.read_csv(ds_uri))
+        return self
+
+    def write(self, ds_uri):
+        pd.to_csv(ds_uri)
+
+    # ToDo: Generic update function
+
+    pass
+
+
+state_udo = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+policy_udoA = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+policy_udoB = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+
+
+sim_config = config_sim({
+    "N": 2,
+    "T": range(4)
+})
+
+# ToDo: DataFrame Column order
+state_dict = {
+    'increment': 0,
+    'state_udo': state_udo, 'state_udo_tracker': 0,
+    'state_udo_perception_tracker': {"ds1": None, "ds2": None, "ds3": None, "timestep": None},
+    'udo_policies': {'udo_A': policy_udoA, 'udo_B': policy_udoB},
+    'udo_policy_tracker': (0, 0),
+    'timestamp': '2019-01-01 00:00:00'
+}
+
+psu_steps = ['m1', 'm2', 'm3']
+system_substeps = len(psu_steps)
+var_timestep_trigger = var_substep_trigger([0, system_substeps])
+env_timestep_trigger = env_trigger(system_substeps)
+psu_block = {k: {"policies": {}, "variables": {}} for k in psu_steps}
+
+def udo_policyA(_g, step, sL, s):
+    s['udo_policies']['udo_A'].updateX()
+    return {'udo_A': udoPipe(s['udo_policies']['udo_A'])}
+# policies['a'] = udo_policyA
+for m in psu_steps:
+    psu_block[m]['policies']['a'] = udo_policyA
+
+def udo_policyB(_g, step, sL, s):
+    s['udo_policies']['udo_B'].updateX()
+    return {'udo_B': udoPipe(s['udo_policies']['udo_B'])}
+# policies['b'] = udo_policyB
+for m in psu_steps:
+    psu_block[m]['policies']['b'] = udo_policyB
+
+
+# policies = {"p1": udo_policyA, "p2": udo_policyB}
+# policies = {"A": udo_policyA, "B": udo_policyB}
+
+def add(y: str, added_val):
+    return lambda _g, step, sL, s, _input: (y, s[y] + added_val)
+# state_updates['increment'] = add('increment', 1)
+for m in psu_steps:
+    psu_block[m]["variables"]['increment'] = add('increment', 1)
+
+
+@curried
+def perceive(s, self):
+    self.perception = self.ds[
+        (self.ds['run'] == s['run']) & (self.ds['substep'] == s['substep']) & (self.ds['timestep'] == s['timestep'])
+    ].drop(columns=['run', 'substep']).to_dict()
+    return self
+
+
+def state_udo_update(_g, step, sL, s, _input):
+    y = 'state_udo'
+    # s['hydra_state'].updateX().anon(perceive(s))
+    s['state_udo'].updateX().perceive(s).updateDS()
+    x = udoPipe(s['state_udo'])
+    return y, x
+for m in psu_steps:
+    psu_block[m]["variables"]['state_udo'] = state_udo_update
+
+
+def track(destination, source):
+    return lambda _g, step, sL, s, _input: (destination, s[source].x)
+state_udo_tracker = track('state_udo_tracker', 'state_udo')
+for m in psu_steps:
+    psu_block[m]["variables"]['state_udo_tracker'] = state_udo_tracker
+
+
+def track_state_udo_perception(destination, source):
+    def id(past_perception):
+        if len(past_perception) == 0:
+            return state_dict['state_udo_perception_tracker']
+        else:
+            return past_perception
+    return lambda _g, step, sL, s, _input: (destination, id(s[source].perception))
+state_udo_perception_tracker = track_state_udo_perception('state_udo_perception_tracker', 'state_udo')
+for m in psu_steps:
+    psu_block[m]["variables"]['state_udo_perception_tracker'] = state_udo_perception_tracker
+
+
+def view_udo_policy(_g, step, sL, s, _input):
+    return 'udo_policies', _input
+for m in psu_steps:
+    psu_block[m]["variables"]['udo_policies'] = view_udo_policy
+
+
+def track_udo_policy(destination, source):
+    def val_switch(v):
+        if isinstance(v, pd.DataFrame) is True or isinstance(v, SilentDF) is True:
+            return SilentDF(v)
+        else:
+            return v.x
+    return lambda _g, step, sL, s, _input: (destination, tuple(val_switch(v) for _, v in s[source].items()))
+udo_policy_tracker = track_udo_policy('udo_policy_tracker', 'udo_policies')
+for m in psu_steps:
+    psu_block[m]["variables"]['udo_policy_tracker'] = udo_policy_tracker
+
+
+def update_timestamp(_g, step, sL, s, _input):
+    y = 'timestamp'
+    return y, time_step(dt_str=s[y], dt_format='%Y-%m-%d %H:%M:%S', _timedelta=timedelta(days=0, minutes=0, seconds=1))
+for m in psu_steps:
+    psu_block[m]["variables"]['timestamp'] = var_timestep_trigger(y='timestamp', f=update_timestamp)
+    # psu_block[m]["variables"]['timestamp'] = var_trigger(
+    #     y='timestamp', f=update_timestamp,
+    #     pre_conditions={'substep': [0, system_substeps]}, cond_op=lambda a, b: a and b
+    # )
+    # psu_block[m]["variables"]['timestamp'] = update_timestamp
+
+# ToDo: Bug without specifying parameters
+# New Convention
+partial_state_update_blocks = psub_list(psu_block, psu_steps)
+append_configs(
+    sim_configs=sim_config,
+    initial_state=state_dict,
+    partial_state_update_blocks=partial_state_update_blocks
+)
+
+print()
+print("State Updates:")
+pp.pprint(partial_state_update_blocks)
+print()

simulations/regression_tests/udo_inter_substep_update.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import pprint as pp
+from fn.func import curried
+from datetime import timedelta
+
+from cadCAD.utils import SilentDF #, val_switch
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import time_step, config_sim
+from cadCAD.configuration.utils.userDefinedObject import udoPipe, UDO
+
+
+DF = SilentDF(pd.read_csv('/Users/jjodesty/Projects/DiffyQ-SimCAD/simulations/external_data/output.csv'))
+
+class udoExample(object):
+    def __init__(self, x, dataset=None):
+        self.x = x
+        self.mem_id = str(hex(id(self)))
+        self.ds = dataset # for setting ds initially or querying
+        self.perception = {}
+
+    def anon(self, f):
+        return f(self)
+
+    def updateX(self):
+        self.x += 1
+        return self
+
+    def perceive(self, s):
+        self.perception = self.ds[
+            (self.ds['run'] == s['run']) & (self.ds['substep'] == s['substep']) & (self.ds['timestep'] == s['timestep'])
+        ].drop(columns=['run', 'substep']).to_dict()
+        return self
+
+    def read(self, ds_uri):
+        self.ds = SilentDF(pd.read_csv(ds_uri))
+        return self
+
+    def write(self, ds_uri):
+        pd.to_csv(ds_uri)
+
+    # ToDo: Generic update function
+
+    pass
+
+# can be accessed after an update within the same substep and timestep
+
+state_udo = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+policy_udoA = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+policy_udoB = UDO(udo=udoExample(0, DF), masked_members=['obj', 'perception'])
+
+def udo_policyA(_g, step, sL, s):
+    s['udo_policies']['udo_A'].updateX()
+    return {'udo_A': udoPipe(s['udo_policies']['udo_A'])}
+
+def udo_policyB(_g, step, sL, s):
+    s['udo_policies']['udo_B'].updateX()
+    return {'udo_B': udoPipe(s['udo_policies']['udo_B'])}
+
+
+policies = {"p1": udo_policyA, "p2": udo_policyB}
+
+# ToDo: DataFrame Column order
+state_dict = {
+    'increment': 0,
+    'state_udo': state_udo, 'state_udo_tracker_a': 0, 'state_udo_tracker_b': 0,
+    'state_udo_perception_tracker': {"ds1": None, "ds2": None, "ds3": None, "timestep": None},
+    'udo_policies': {'udo_A': policy_udoA, 'udo_B': policy_udoB},
+    'udo_policy_tracker_a': (0, 0), 'udo_policy_tracker_b': (0, 0),
+    'timestamp': '2019-01-01 00:00:00'
+}
+
+@curried
+def perceive(s, self):
+    self.perception = self.ds[
+        (self.ds['run'] == s['run']) & (self.ds['substep'] == s['substep']) & (self.ds['timestep'] == s['timestep'])
+    ].drop(columns=['run', 'substep']).to_dict()
+    return self
+
+def view_udo_policy(_g, step, sL, s, _input):
+    return 'udo_policies', _input
+
+def state_udo_update(_g, step, sL, s, _input):
+    y = 'state_udo'
+    # s['hydra_state'].updateX().anon(perceive(s))
+    s['state_udo'].updateX().perceive(s)
+    x = udoPipe(s['state_udo'])
+    return y, x
+
+def increment(y, incr_by):
+    return lambda _g, step, sL, s, _input: (y, s[y] + incr_by)
+
+def track(destination, source):
+    return lambda _g, step, sL, s, _input: (destination, s[source].x)
+
+def track_udo_policy(destination, source):
+    def val_switch(v):
+        if isinstance(v, pd.DataFrame) is True or isinstance(v, SilentDF) is True:
+            return SilentDF(v)
+        else:
+            return v.x
+    return lambda _g, step, sL, s, _input: (destination, tuple(val_switch(v) for _, v in s[source].items()))
+
+def track_state_udo_perception(destination, source):
+    def id(past_perception):
+        if len(past_perception) == 0:
+            return state_dict['state_udo_perception_tracker']
+        else:
+            return past_perception
+    return lambda _g, step, sL, s, _input: (destination, id(s[source].perception))
+
+
+def time_model(y, substeps, time_delta, ts_format='%Y-%m-%d %H:%M:%S'):
+    def apply_incriment_condition(s):
+        if s['substep'] == 0 or s['substep'] == substeps:
+            return y, time_step(dt_str=s[y], dt_format=ts_format, _timedelta=time_delta)
+        else:
+            return y, s[y]
+    return lambda _g, step, sL, s, _input: apply_incriment_condition(s)
+
+
+states = {
+    'increment': increment('increment', 1),
+    'state_udo_tracker_a': track('state_udo_tracker_a', 'state_udo'),
+    'state_udo': state_udo_update,
+    'state_udo_perception_tracker': track_state_udo_perception('state_udo_perception_tracker', 'state_udo'),
+    'state_udo_tracker_b': track('state_udo_tracker_b', 'state_udo'),
+    'udo_policy_tracker_a': track_udo_policy('udo_policy_tracker_a', 'udo_policies'),
+    'udo_policies': view_udo_policy,
+    'udo_policy_tracker_b': track_udo_policy('udo_policy_tracker_b', 'udo_policies')
+}
+
+substeps=3
+update_timestamp = time_model(
+    'timestamp',
+    substeps=3,
+    time_delta=timedelta(days=0, minutes=0, seconds=1),
+    ts_format='%Y-%m-%d %H:%M:%S'
+)
+states['timestamp'] = update_timestamp
+
+PSUB = {
+    'policies': policies,
+    'states': states
+}
+
+# needs M1&2 need behaviors
+partial_state_update_blocks = [PSUB] * substeps
+# pp.pprint(partial_state_update_blocks)
+
+sim_config = config_sim({
+    "N": 2,
+    "T": range(4)
+})
+
+# ToDo: Bug without specifying parameters
+append_configs(
+    sim_configs=sim_config,
+    initial_state=state_dict,
+    seeds={},
+    raw_exogenous_states={},
+    env_processes={},
+    partial_state_update_blocks=partial_state_update_blocks,
+    # policy_ops=[lambda a, b: {**a, **b}]
+)
+
+print()
+print("State Updates:")
+pp.pprint(partial_state_update_blocks)
+print()

simulations/test_executions/config1_test.py

@@ -0,0 +1,25 @@
+import pandas as pd
+from typing import List
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import config1
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+print()
+print("Tensor Field: config1")
+# print(raw_result)
+print(tabulate(tensor_field[['m', 'b1', 's1', 's2']], headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/test_executions/config2_test.py

@@ -0,0 +1,23 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import config2
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config2
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/test_executions/external_ds_test.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import external_dataset
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+result = pd.concat([result, result['external_data'].apply(pd.Series)], axis=1)[
+    ['run', 'substep', 'timestep', 'increment', 'external_data', 'policies', 'ds1', 'ds2', 'ds3', ]
+]
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/test_executions/historical_state_access_test.py

@@ -0,0 +1,27 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import historical_state_access
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+# cols = ['run','substep','timestep','x','nonexsistant','last_x','2nd_to_last_x','3rd_to_last_x','4th_to_last_x']
+cols = ['last_x']
+result = result[cols]
+
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/test_executions/multi_config_test.py

@@ -0,0 +1,25 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import config1, config2
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Concurrent Execution")
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+# print(configs)
+i = 0
+config_names = ['config1', 'config2']
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print(f"Tensor Field: {config_names[i]}")
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print("Output:")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1

simulations/test_executions/param_sweep_test.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import sweep_config
+from cadCAD import configs
+
+# pprint(configs)
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Concurrent Execution")
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+i = 0
+config_names = ['sweep_config_A', 'sweep_config_B']
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print("Tensor Field: " + config_names[i])
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print("Output:")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1

simulations/test_executions/policy_agg_test.py

@@ -0,0 +1,25 @@
+from pprint import pprint
+
+import pandas as pd
+from tabulate import tabulate
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import policy_aggregation
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()

simulations/test_executions/udo_test.py

@@ -0,0 +1,48 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import udo
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+
+
+
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=configs)
+# cols = configs[0].initial_state.keys()
+cols = [
+    'increment',
+    'state_udo_tracker', 'state_udo', 'state_udo_perception_tracker',
+    'udo_policies', 'udo_policy_tracker',
+    'timestamp'
+]
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)[['run', 'substep', 'timestep'] + cols]
+# result = pd.concat([result.drop(['c'], axis=1), result['c'].apply(pd.Series)], axis=1)
+
+# print(list(result['c']))
+
+# print(tabulate(result['c'].apply(pd.Series), headers='keys', tablefmt='psql'))
+
+# print(result.iloc[8,:]['state_udo'].ds)
+
+# ctypes.cast(id(v['state_udo']['mem_id']), ctypes.py_object).value
+
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()
+print(result.info(verbose=True))
+
+# def f(df, col):
+#     for k in df[col].iloc[0].keys():
+#         df[k] = None
+#     for index, row in df.iterrows():
+#         # df.apply(lambda row:, axis=1)

simulations/test_executions/udo_update_test.py

@@ -0,0 +1,44 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import udo_inter_substep_update
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+
+
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+# cols = configs[0].initial_state.keys()
+cols = [
+    'increment',
+    'state_udo_tracker_a', 'state_udo', 'state_udo_perception_tracker', 'state_udo_tracker_b',
+    'udo_policy_tracker_a', 'udo_policies', 'udo_policy_tracker_b',
+    'timestamp'
+]
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)[['run', 'substep', 'timestep'] + cols]
+# result = pd.concat([result.drop(['c'], axis=1), result['c'].apply(pd.Series)], axis=1)
+
+# print(list(result['c']))
+
+# print(tabulate(result['c'].apply(pd.Series), headers='keys', tablefmt='psql'))
+
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print()
+print(result.info(verbose=True))
+
+# def f(df, col):
+#     for k in df[col].iloc[0].keys():
+#         df[k] = None
+#     for index, row in df.iterrows():
+#         # df.apply(lambda row:, axis=1)

simulations/tutorials/marbles.py

@@ -0,0 +1,166 @@
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD.configuration import Configuration
+from cadCAD.configuration.utils.userDefinedObject import udoPipe, UDO
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+import pprint as pp
+
+T = 50 #iterations in our simulation
+n = 3 #number of boxes in our network
+m = 2 #for barabasi graph type number of edges is (n-2)*m
+
+G = nx.barabasi_albert_graph(n, m)
+k = len(G.edges)
+
+
+# class udoExample(object):
+#     def __init__(self, G):
+#         self.G = G
+#         self.mem_id = str(hex(id(self)))
+
+
+g = UDO(udo=G)
+print()
+# print(g.edges)
+# print(G.edges)
+# pp.pprint(f"{type(g)}: {g}")
+# next
+balls = np.zeros(n,)
+
+for node in g.nodes:
+    rv = np.random.randint(1,25)
+    g.nodes[node]['initial_balls'] = rv
+    balls[node] = rv
+
+# pp.pprint(balls)
+
+# next
+scale=100
+nx.draw_kamada_kawai(G, node_size=balls*scale,labels=nx.get_node_attributes(G,'initial_balls'))
+
+# next
+
+initial_conditions = {'balls':balls, 'network':G}
+print(initial_conditions)
+
+# next
+
+def update_balls(params, step, sL, s, _input):
+    delta_balls = _input['delta']
+    new_balls = s['balls']
+    for e in G.edges:
+        move_ball = delta_balls[e]
+        src = e[0]
+        dst = e[1]
+        if (new_balls[src] >= move_ball) and (new_balls[dst] >= -move_ball):
+            new_balls[src] = new_balls[src] - move_ball
+            new_balls[dst] = new_balls[dst] + move_ball
+
+    key = 'balls'
+    value = new_balls
+
+    return (key, value)
+
+
+def update_network(params, step, sL, s, _input):
+    new_nodes = _input['nodes']
+    new_edges = _input['edges']
+    new_balls = _input['quantity']
+
+    graph = s['network']
+
+    for node in new_nodes:
+        graph.add_node(node)
+        graph.nodes[node]['initial_balls'] = new_balls[node]
+        graph.nodes[node]['strat'] = _input['node_strats'][node]
+
+    for edge in new_edges:
+        graph.add_edge(edge[0], edge[1])
+        graph.edges[edge]['strat'] = _input['edge_strats'][edge]
+
+    key = 'network'
+    value = graph
+    return (key, value)
+
+
+def update_network_balls(params, step, sL, s, _input):
+    new_nodes = _input['nodes']
+    new_balls = _input['quantity']
+    balls = np.zeros(len(s['balls']) + len(new_nodes))
+
+    for node in s['network'].nodes:
+        balls[node] = s['balls'][node]
+
+    for node in new_nodes:
+        balls[node] = new_balls[node]
+
+    key = 'balls'
+    value = balls
+
+    return (key, value)
+
+# next
+
+
+def greedy_robot(src_balls, dst_balls):
+    # robot wishes to accumlate balls at its source
+    # takes half of its neighbors balls
+    if src_balls < dst_balls:
+        delta = -np.floor(dst_balls / 2)
+    else:
+        delta = 0
+
+    return delta
+
+
+def fair_robot(src_balls, dst_balls):
+    # robot follows the simple balancing rule
+    delta = np.sign(src_balls - dst_balls)
+
+    return delta
+
+
+def giving_robot(src_balls, dst_balls):
+    # robot wishes to gice away balls one at a time
+    if src_balls > 0:
+        delta = 1
+    else:
+        delta = 0
+
+    return delta
+
+# next
+
+robot_strategies = [greedy_robot,fair_robot, giving_robot]
+
+for node in G.nodes:
+    nstrats = len(robot_strategies)
+    rv  = np.random.randint(0,nstrats)
+    G.nodes[node]['strat'] = robot_strategies[rv]
+
+for e in G.edges:
+    owner_node = e[0]
+    G.edges[e]['strat'] = G.nodes[owner_node]['strat']
+
+# next
+
+def robotic_network(params, step, sL, s):
+    graph = s['network']
+
+    delta_balls = {}
+    for e in graph.edges:
+        src = e[0]
+        src_balls = s['balls'][src]
+        dst = e[1]
+        dst_balls = s['balls'][dst]
+
+        # transfer balls according to specific robot strat
+        strat = graph.edges[e]['strat']
+        delta_balls[e] = strat(src_balls, dst_balls)
+
+    return_dict = {'nodes': [], 'edges': {}, 'quantity': {}, 'node_strats': {}, 'edge_strats': {}, 'delta': delta_balls}
+
+    return (return_dict)

simulations/tutorials/marbles2.py

@@ -0,0 +1,221 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils.userDefinedObject import udoPipe, UDO
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+T = 50 #iterations in our simulation
+n = 3 #number of boxes in our network
+m = 2 #for barabasi graph type number of edges is (n-2)*m
+
+G = nx.barabasi_albert_graph(n, m)
+k = len(G.edges)
+
+balls = np.zeros(n,)
+
+for node in G.nodes:
+    rv = np.random.randint(1,25)
+    G.nodes[node]['initial_balls'] = rv
+    balls[node] = rv
+
+scale=100
+nx.draw_kamada_kawai(G, node_size=balls*scale,labels=nx.get_node_attributes(G,'initial_balls'))
+
+def greedy_robot(src_balls, dst_balls):
+    # robot wishes to accumlate balls at its source
+    # takes half of its neighbors balls
+    if src_balls < dst_balls:
+        return -np.floor(dst_balls / 2)
+    else:
+        return 0
+
+
+def fair_robot(src_balls, dst_balls):
+    # robot follows the simple balancing rule
+    return np.sign(src_balls - dst_balls)
+
+
+def giving_robot(src_balls, dst_balls):
+    # robot wishes to gice away balls one at a time
+    if src_balls > 0:
+        return 1
+    else:
+        return 0
+
+robot_strategies = [greedy_robot,fair_robot, giving_robot]
+
+for node in G.nodes:
+    nstrats = len(robot_strategies)
+    rv = np.random.randint(0,nstrats)
+    G.nodes[node]['strat'] = robot_strategies[rv]
+
+for e in G.edges:
+    owner_node = e[0]
+    G.edges[e]['strat'] = G.nodes[owner_node]['strat']
+
+default_policy = {'nodes': [], 'edges': {}, 'quantity': {}, 'node_strats': {}, 'edge_strats': {}, 'delta': {}}
+class robot(object):
+    def __init__(self, graph, balls, internal_policy=default_policy):
+        self.mem_id = str(hex(id(self)))
+        self.internal_policy = internal_policy
+        self.graph = graph
+        self.balls = balls
+
+
+    def robotic_network(self, graph, balls): # move balls
+        self.graph, self.balls = graph, balls
+        delta_balls = {}
+        for e in self.graph.edges:
+            src = e[0]
+            src_balls = self.balls[src]
+            dst = e[1]
+            dst_balls = self.balls[dst]
+
+            # transfer balls according to specific robot strat
+            strat = self.graph.edges[e]['strat']
+            delta_balls[e] = strat(src_balls, dst_balls)
+
+        self.internal_policy = {'nodes': [], 'edges': {}, 'quantity': {}, 'node_strats': {}, 'edge_strats': {}, 'delta': delta_balls}
+        return self
+
+    def agent_arrival(self, graph, balls): # add node
+        self.graph, self.balls = graph, balls
+        node = len(self.graph.nodes)
+        edge_list = self.graph.edges
+
+        # choose a m random edges without replacement
+        # new = np.random.choose(edgelist,m)
+        new = [0, 1]  # tester
+
+        nodes = [node]
+        edges = [(node, new_node) for new_node in new]
+
+        initial_balls = {node: np.random.randint(1, 25)}
+
+        rv = np.random.randint(0, nstrats)
+        node_strat = {node: robot_strategies[rv]}
+
+        edge_strats = {e: robot_strategies[rv] for e in edges}
+
+        self.internal_policy = {'nodes': nodes,
+                       'edges': edges,
+                       'quantity': initial_balls,
+                       'node_strats': node_strat,
+                       'edge_strats': edge_strats,
+                       'delta': np.zeros(node + 1)
+                       }
+
+        return self
+
+robot_udo = UDO(udo=robot(G, balls), masked_members=['obj'])
+initial_conditions = {'balls': balls, 'network': G, 'robot': robot_udo}
+
+
+def update_balls(params, step, sL, s, _input):
+    delta_balls = _input['robot'].internal_policy['delta']
+    new_balls = s['balls']
+    for e in G.edges:
+        move_ball = delta_balls[e]
+        src = e[0]
+        dst = e[1]
+        if (new_balls[src] >= move_ball) and (new_balls[dst] >= -move_ball):
+            new_balls[src] = new_balls[src] - move_ball
+            new_balls[dst] = new_balls[dst] + move_ball
+
+    key = 'balls'
+    value = new_balls
+
+    return (key, value)
+
+
+def update_network(params, step, sL, s, _input):
+    new_nodes = _input['robot'].internal_policy['nodes']
+    new_edges = _input['robot'].internal_policy['edges']
+    new_balls = _input['robot'].internal_policy['quantity']
+
+    graph = s['network']
+
+    for node in new_nodes:
+        graph.add_node(node)
+        graph.nodes[node]['initial_balls'] = new_balls[node]
+        graph.nodes[node]['strat'] = _input['robot'].internal_policy['node_strats'][node]
+
+    for edge in new_edges:
+        graph.add_edge(edge[0], edge[1])
+        graph.edges[edge]['strat'] = _input['robot'].internal_policy['edge_strats'][edge]
+
+    key = 'network'
+    value = graph
+    return (key, value)
+
+
+def update_network_balls(params, step, sL, s, _input):
+    new_nodes = _input['robot'].internal_policy['nodes']
+    new_balls = _input['robot'].internal_policy['quantity']
+    balls = np.zeros(len(s['balls']) + len(new_nodes))
+
+    for node in s['network'].nodes:
+        balls[node] = s['balls'][node]
+
+    for node in new_nodes:
+        balls[node] = new_balls[node]
+
+    key = 'balls'
+    value = balls
+
+    return (key, value)
+
+
+def robotic_network(params, step, sL, s):
+    s['robot'].robotic_network(s['network'], s['balls'])
+    return {'robot': udoPipe(s['robot'])}
+
+
+def agent_arrival(params, step, sL, s):
+    s['robot'].agent_arrival(s['network'], s['balls'])
+    return {'robot': udoPipe(s['robot'])}
+
+def get_robot(params, step, sL, s, _input):
+    return 'robot', _input['robot']
+
+partial_state_update_blocks = [
+    {
+        'policies': {
+        # The following policy functions will be evaluated and their returns will be passed to the state update functions
+            'p1': robotic_network
+        },
+        'variables': {  # The following state variables will be updated simultaneously
+            'balls': update_balls,
+            'robot': get_robot
+
+        }
+    },
+    {
+        'policies': {
+        # The following policy functions will be evaluated and their returns will be passed to the state update functions
+            'p1': agent_arrival
+        },
+        'variables': {  # The following state variables will be updated simultaneously
+            'network': update_network,
+            'balls': update_network_balls,
+            'robot': get_robot
+        }
+    }
+]
+
+simulation_parameters = {
+    'T': range(T),
+    'N': 1,
+    'M': {}
+}
+append_configs(
+    sim_configs=simulation_parameters, #dict containing state update functions
+    initial_state=initial_conditions, #dict containing variable names and initial values
+    partial_state_update_blocks= partial_state_update_blocks #, #dict containing state update functions
+    # policy_ops=[lambda a, b: {**a, **b}]
+)
+# config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values
+#                        partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions
+#                        sim_config=simulation_parameters #dict containing simulation parameters
+#                       )

simulations/tutorials/marbles2_run.py

@@ -0,0 +1,25 @@
+import pandas as pd
+from tabulate import tabulate
+# The following imports NEED to be in the exact order
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs # only contains config1
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.main()
+result = pd.DataFrame(raw_result)
+print()
+print("Tensor Field: config1")
+print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+print("Output:")
+print(tabulate(result, headers='keys', tablefmt='psql'))
+print(result[['network']])
+print()
+
+print(result[['network', 'substep']])

simulations/validation/config4.py

@@ -3,8 +3,7 @@ import numpy as np
 from datetime import timedelta
 
 from cadCAD.configuration import append_configs
-from cadCAD.configuration.utils import proc_trigger, bound_norm_random, ep_time_step
-from cadCAD.configuration.utils.parameterSweep import config_sim
+from cadCAD.configuration.utils import env_proc_trigger, bound_norm_random, ep_time_step, config_sim
 
 
 seeds = {
@@ -93,8 +92,6 @@ def env_a(x):
     return 5
 def env_b(x):
     return 10
-# def what_ever(x):
-#     return x + 1
 
 
 # Genesis States
@@ -116,7 +113,7 @@ raw_exogenous_states = {
 
 env_processes = {
     "s3": env_a,
-    "s4": proc_trigger('2018-10-01 15:16:25', env_b)
+    "s4": env_proc_trigger('2018-10-01 15:16:25', env_b)
 }
 
 
@@ -139,4 +136,4 @@ append_configs(
     raw_exogenous_states={},
     env_processes={},
     partial_state_update_blocks=partial_state_update_block
-)
+)

simulations/validation/conviction_helpers.py

@@ -0,0 +1,150 @@
+import networkx as nx
+from scipy.stats import expon, gamma
+import numpy as np
+import matplotlib.pyplot as plt
+
+#helper functions
+def get_nodes_by_type(g, node_type_selection):
+    return [node for node in g.nodes if g.nodes[node]['type']== node_type_selection ]
+
+def get_edges_by_type(g, edge_type_selection):
+    return [edge for edge in g.edges if g.edges[edge]['type']== edge_type_selection ]
+
+def total_funds_given_total_supply(total_supply):
+    
+    #can put any bonding curve invariant here for initializatio!
+    total_funds = total_supply
+    
+    return total_funds
+
+#maximum share of funds a proposal can take
+default_beta = .2 #later we should set this to be param so we can sweep it
+# tuning param for the trigger function
+default_rho = .001
+
+def trigger_threshold(requested, funds, supply, beta = default_beta, rho = default_rho):
+    
+    share = requested/funds
+    if share < beta:
+        return rho*supply/(beta-share)**2
+    else: 
+        return np.inf
+
+def initialize_network(n,m, funds_func=total_funds_given_total_supply, trigger_func =trigger_threshold ):
+    network = nx.DiGraph()
+    for i in range(n):
+        network.add_node(i)
+        network.nodes[i]['type']="participant"
+        
+        h_rv = expon.rvs(loc=0.0, scale=1000)
+        network.nodes[i]['holdings'] = h_rv
+        
+        s_rv = np.random.rand() 
+        network.nodes[i]['sentiment'] = s_rv
+    
+    participants = get_nodes_by_type(network, 'participant')
+    initial_supply = np.sum([ network.nodes[i]['holdings'] for i in participants])
+    
+    initial_funds = funds_func(initial_supply)    
+    
+    #generate initial proposals
+    for ind in range(m):
+        j = n+ind
+        network.add_node(j)
+        network.nodes[j]['type']="proposal"
+        network.nodes[j]['conviction']=0
+        network.nodes[j]['status']='candidate'
+        network.nodes[j]['age']=0
+        
+        r_rv = gamma.rvs(3,loc=0.001, scale=10000)
+        network.node[j]['funds_requested'] = r_rv
+        
+        network.nodes[j]['trigger']= trigger_threshold(r_rv, initial_funds, initial_supply)
+        
+        for i in range(n):
+            network.add_edge(i, j)
+            
+            rv = np.random.rand()
+            a_rv = 1-4*(1-rv)*rv #polarized distribution
+            network.edges[(i, j)]['affinity'] = a_rv
+            network.edges[(i,j)]['tokens'] = 0
+            network.edges[(i, j)]['conviction'] = 0
+            
+        proposals = get_nodes_by_type(network, 'proposal')
+        total_requested = np.sum([ network.nodes[i]['funds_requested'] for i in proposals])
+        
+    return network, initial_funds, initial_supply, total_requested
+
+def trigger_sweep(field, trigger_func,xmax=.2,default_alpha=.5):
+    
+    if field == 'token_supply':
+        alpha = default_alpha
+        share_of_funds = np.arange(.001,xmax,.001)
+        total_supply = np.arange(0,10**9, 10**6) 
+        demo_data_XY = np.outer(share_of_funds,total_supply)
+
+        demo_data_Z0=np.empty(demo_data_XY.shape)
+        demo_data_Z1=np.empty(demo_data_XY.shape)
+        demo_data_Z2=np.empty(demo_data_XY.shape)
+        demo_data_Z3=np.empty(demo_data_XY.shape)
+        for sof_ind in range(len(share_of_funds)):
+            sof = share_of_funds[sof_ind]
+            for ts_ind in range(len(total_supply)):
+                ts = total_supply[ts_ind]
+                tc = ts /(1-alpha)
+                trigger = trigger_func(sof, 1, ts)
+                demo_data_Z0[sof_ind,ts_ind] = np.log10(trigger)
+                demo_data_Z1[sof_ind,ts_ind] = trigger
+                demo_data_Z2[sof_ind,ts_ind] = trigger/tc #share of maximum possible conviction
+                demo_data_Z3[sof_ind,ts_ind] = np.log10(trigger/tc)
+        return {'log10_trigger':demo_data_Z0,
+                'trigger':demo_data_Z1,
+                'share_of_max_conv': demo_data_Z2,
+                'log10_share_of_max_conv':demo_data_Z3,
+                'total_supply':total_supply,
+                'share_of_funds':share_of_funds}
+    elif field == 'alpha':
+        alpha = np.arange(.5,1,.01)
+        share_of_funds = np.arange(.001,xmax,.001)
+        total_supply = 10**9
+        demo_data_XY = np.outer(share_of_funds,alpha)
+
+        demo_data_Z4=np.empty(demo_data_XY.shape)
+        demo_data_Z5=np.empty(demo_data_XY.shape)
+        demo_data_Z6=np.empty(demo_data_XY.shape)
+        demo_data_Z7=np.empty(demo_data_XY.shape)
+        for sof_ind in range(len(share_of_funds)):
+            sof = share_of_funds[sof_ind]
+            for a_ind in range(len(alpha)):
+                ts = total_supply
+                a = alpha[a_ind]
+                tc = ts /(1-a)
+                trigger = trigger_func(sof, 1, ts)
+                demo_data_Z4[sof_ind,a_ind] = np.log10(trigger)
+                demo_data_Z5[sof_ind,a_ind] = trigger
+                demo_data_Z6[sof_ind,a_ind] = trigger/tc #share of maximum possible conviction
+                demo_data_Z7[sof_ind,a_ind] = np.log10(trigger/tc)
+        
+        return {'log10_trigger':demo_data_Z4,
+               'trigger':demo_data_Z5,
+               'share_of_max_conv': demo_data_Z6,
+               'log10_share_of_max_conv':demo_data_Z7,
+               'alpha':alpha,
+               'share_of_funds':share_of_funds}
+        
+    else:
+        return "invalid field"
+    
+def trigger_plotter(share_of_funds,Z, color_label,y, ylabel,cmap='jet'):
+    dims = (10, 5)
+    fig, ax = plt.subplots(figsize=dims)
+
+    cf = plt.contourf(share_of_funds, y, Z.T, 100, cmap=cmap)
+    cbar=plt.colorbar(cf)
+    plt.axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]])
+    #ax.set_xscale('log')
+    plt.ylabel(ylabel)
+    plt.xlabel('Share of Funds Requested')
+    plt.title('Trigger Function Map')
+
+    cbar.ax.set_ylabel(color_label)

simulations/validation/conviction_system_logic.py

@@ -0,0 +1,548 @@
+import numpy as np
+
+from cadCAD.configuration.utils import config_sim
+from simulations.validation.conviction_helpers import *
+#import networkx as nx
+from scipy.stats import expon, gamma
+
+
+#functions for partial state update block 1
+
+#Driving processes: arrival of participants, proposals and funds
+##-----------------------------------------
+def gen_new_participant(network, new_participant_holdings):
+    
+    i = len([node for node in network.nodes])
+    
+    network.add_node(i)
+    network.nodes[i]['type']="participant"
+    
+    s_rv = np.random.rand() 
+    network.nodes[i]['sentiment'] = s_rv
+    network.nodes[i]['holdings']=new_participant_holdings
+    
+    for j in get_nodes_by_type(network, 'proposal'):
+        network.add_edge(i, j)
+        
+        rv = np.random.rand()
+        a_rv = 1-4*(1-rv)*rv #polarized distribution
+        network.edges[(i, j)]['affinity'] = a_rv
+        network.edges[(i,j)]['tokens'] = a_rv*network.nodes[i]['holdings']
+        network.edges[(i, j)]['conviction'] = 0
+    
+    return network
+    
+
+scale_factor = 1000
+
+def gen_new_proposal(network, funds, supply, total_funds, trigger_func):
+    j = len([node for node in network.nodes])
+    network.add_node(j)
+    network.nodes[j]['type']="proposal"
+    
+    network.nodes[j]['conviction']=0
+    network.nodes[j]['status']='candidate'
+    network.nodes[j]['age']=0
+    
+    rescale = scale_factor*funds/total_funds
+    r_rv = gamma.rvs(3,loc=0.001, scale=rescale)
+    network.node[j]['funds_requested'] = r_rv
+    
+    network.nodes[j]['trigger']= trigger_func(r_rv, funds, supply)
+    
+    participants = get_nodes_by_type(network, 'participant')
+    proposing_participant = np.random.choice(participants)
+    
+    for i in participants:
+        network.add_edge(i, j)
+        if i==proposing_participant:
+            network.edges[(i, j)]['affinity']=1
+        else:
+            rv = np.random.rand()
+            a_rv = 1-4*(1-rv)*rv #polarized distribution
+            network.edges[(i, j)]['affinity'] = a_rv
+            
+        network.edges[(i, j)]['conviction'] = 0
+        network.edges[(i,j)]['tokens'] = 0
+    return network
+        
+        
+
+def driving_process(params, step, sL, s):
+    
+    #placeholder plumbing for random processes
+    arrival_rate = 10/s['sentiment']
+    rv1 = np.random.rand()
+    new_participant = bool(rv1<1/arrival_rate)
+    if new_participant:
+        h_rv = expon.rvs(loc=0.0, scale=1000)
+        new_participant_holdings = h_rv
+    else:
+        new_participant_holdings = 0
+    
+    network = s['network']
+    affinities = [network.edges[e]['affinity'] for e in network.edges ]
+    median_affinity = np.median(affinities)
+    
+    proposals = get_nodes_by_type(network, 'proposal')
+    fund_requests = [network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate' ]
+    
+    funds = s['funds']
+    total_funds_requested = np.sum(fund_requests)
+    
+    proposal_rate = 10/median_affinity * total_funds_requested/funds
+    rv2 = np.random.rand()
+    new_proposal = bool(rv2<1/proposal_rate)
+    
+    sentiment = s['sentiment']
+    funds = s['funds']
+    scale_factor = 1+4000*sentiment**2
+    
+    #this shouldn't happen but expon is throwing domain errors
+    if scale_factor > 1: 
+        funds_arrival = expon.rvs(loc = 0, scale = scale_factor )
+    else:
+        funds_arrival = 0
+    
+    return({'new_participant':new_participant,
+            'new_participant_holdings':new_participant_holdings,
+            'new_proposal':new_proposal, 
+            'funds_arrival':funds_arrival})
+
+    
+#Mechanisms for updating the state based on driving processes
+##---
+def update_network(params, step, sL, s, _input):
+    
+    print(params)
+    print(type(params))
+    
+    network = s['network']
+    funds = s['funds']
+    supply = s['supply']
+    trigger_func = params['trigger_func']
+
+    new_participant = _input['new_participant'] #T/F
+    new_proposal = _input['new_proposal'] #T/F
+
+    if new_participant:
+        new_participant_holdings = _input['new_participant_holdings']
+        network = gen_new_participant(network, new_participant_holdings)
+    
+    if new_proposal:
+        network= gen_new_proposal(network,funds,supply )
+    
+    #update age of the existing proposals
+    proposals = get_nodes_by_type(network, 'proposal')
+    
+    for j in proposals:
+        network.nodes[j]['age'] =  network.nodes[j]['age']+1
+        if network.nodes[j]['status'] == 'candidate':
+            requested = network.nodes[j]['funds_requested']
+            network.nodes[j]['trigger'] = trigger_func(requested, funds, supply)
+        else:
+            network.nodes[j]['trigger'] = np.nan
+            
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def increment_funds(params, step, sL, s, _input):
+    
+    funds = s['funds']
+    funds_arrival = _input['funds_arrival']
+
+    #increment funds
+    funds = funds + funds_arrival
+    
+    key = 'funds'
+    value = funds
+    
+    return (key, value)
+
+def increment_supply(params, step, sL, s, _input):
+    
+    supply = s['supply']
+    supply_arrival = _input['new_participant_holdings']
+
+    #increment funds
+    supply = supply + supply_arrival
+    
+    key = 'supply'
+    value = supply
+    
+    return (key, value)
+
+#functions for partial state update block 2
+
+#Driving processes: completion of previously funded proposals
+##-----------------------------------------
+
+def check_progress(params, step, sL, s):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    
+    completed = []
+    for j in proposals:
+        if network.nodes[j]['status'] == 'active':
+            grant_size = network.nodes[j]['funds_requested']
+            base_completion_rate=params['base_completion_rate']
+            likelihood = 1.0/(base_completion_rate+np.log(grant_size))
+            if np.random.rand() < likelihood:
+                completed.append(j)
+    
+    return({'completed':completed})
+
+
+#Mechanisms for updating the state based on check progress
+##---
+def complete_proposal(params, step, sL, s, _input):
+    
+    network = s['network']
+    participants = get_nodes_by_type(network, 'participant')
+    
+    completed = _input['completed']
+    for j in completed:
+        network.nodes[j]['status']='completed'
+        for i in participants:
+            force = network.edges[(i,j)]['affinity']
+            sentiment = network.node[i]['sentiment']
+            network.node[i]['sentiment'] = get_sentimental(sentiment, force, decay=0)
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_sentiment_on_completion(params, step, sL, s, _input):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    completed = _input['completed']
+    
+    grants_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='active'])
+    
+    grants_completed = np.sum([network.nodes[j]['funds_requested'] for j in completed])
+    
+    sentiment = s['sentiment']
+    
+    force = grants_completed/grants_outstanding
+    mu = params['sentiment_decay']
+    if (force >=0) and (force <=1):
+        sentiment = get_sentimental(sentiment, force, mu)
+    else:
+        sentiment = get_sentimental(sentiment, 0, mu)
+    
+    
+    key = 'sentiment'
+    value = sentiment
+    
+    return (key, value)
+
+def get_sentimental(sentiment, force, decay=0):
+    mu = decay
+    sentiment = sentiment*(1-mu) + force
+    
+    if sentiment > 1:
+        sentiment = 1
+        
+    return sentiment
+
+#functions for partial state update block 3
+
+#Decision processes: trigger function policy
+##-----------------------------------------
+
+def trigger_function(params, step, sL, s):
+    
+    network = s['network']
+    funds = s['funds']
+    supply = s['supply']
+    proposals = get_nodes_by_type(network, 'proposal')
+    tmin = params['tmin']
+    
+    accepted = []
+    triggers = {}
+    for j in proposals:
+        if network.nodes[j]['status'] == 'candidate':
+            requested = network.nodes[j]['funds_requested']
+            age = network.nodes[j]['age']
+            threshold = trigger_threshold(requested, funds, supply)
+            if age > tmin:
+                conviction = network.nodes[j]['conviction']
+                if conviction >threshold:
+                    accepted.append(j)
+        else:
+            threshold = np.nan
+            
+        triggers[j] = threshold
+                
+        
+                    
+    return({'accepted':accepted, 'triggers':triggers})
+
+def decrement_funds(params, step, sL, s, _input):
+    
+    funds = s['funds']
+    network = s['network']
+    accepted = _input['accepted']
+
+    #decrement funds
+    for j in accepted:
+        funds = funds - network.nodes[j]['funds_requested']
+    
+    key = 'funds'
+    value = funds
+    
+    return (key, value)
+
+def update_proposals(params, step, sL, s, _input):
+    
+    network = s['network']
+    accepted = _input['accepted']
+    triggers = _input['triggers']
+    participants = get_nodes_by_type(network, 'participant')
+    proposals = get_nodes_by_type(network, 'proposals')
+    sensitivity = params['sensitivity']
+    
+    for j in proposals:
+        network.nodes[j]['trigger'] = triggers[j]
+    
+    #bookkeeping conviction and participant sentiment
+    for j in accepted:
+        network.nodes[j]['status']='active'
+        network.nodes[j]['conviction']=np.nan
+        #change status to active
+        for i in participants:
+        
+            #operating on edge = (i,j)
+            #reset tokens assigned to other candidates
+            network.edges[(i,j)]['tokens']=0
+            network.edges[(i,j)]['conviction'] = np.nan
+            
+            #update participants sentiments (positive or negative) 
+            affinities = [network.edges[(i,p)]['affinity'] for p in proposals if not(p in accepted)]
+            if len(affinities)>1:
+                max_affinity = np.max(affinities)
+                force = network.edges[(i,j)]['affinity']-sensitivity*max_affinity
+            else:
+                force = 0
+            
+            #based on what their affinities to the accepted proposals
+            network.nodes[i]['sentiment'] = get_sentimental(network.nodes[i]['sentiment'], force, False)
+            
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_sentiment_on_release(params, step, sL, s, _input):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    accepted = _input['accepted']
+    
+    proposals_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate'])
+    
+    proposals_accepted = np.sum([network.nodes[j]['funds_requested'] for j in accepted])
+    
+    sentiment = s['sentiment']
+    force = proposals_accepted/proposals_outstanding
+    if (force >=0) and (force <=1):
+        sentiment = get_sentimental(sentiment, force, False)
+    else:
+        sentiment = get_sentimental(sentiment, 0, False)
+    
+    key = 'sentiment'
+    value = sentiment
+    
+    return (key, value)
+
+def participants_decisions(params, step, sL, s):
+    network = s['network']
+    participants = get_nodes_by_type(network, 'participant')
+    proposals = get_nodes_by_type(network, 'proposal')
+    candidates = [j for j in proposals if network.nodes[j]['status']=='candidate']
+    sensitivity = params['sensitivity']
+    
+    gain = .01
+    delta_holdings={}
+    proposals_supported ={}
+    for i in participants:
+        force = network.nodes[i]['sentiment']-sensitivity
+        delta_holdings[i] = network.nodes[i]['holdings']*gain*force
+        
+        support = []
+        for j in candidates:
+            affinity = network.edges[(i, j)]['affinity']
+            cutoff = sensitivity*np.max([network.edges[(i,p)]['affinity'] for p in candidates])
+            if cutoff <.5:
+                cutoff = .5
+            
+            if affinity > cutoff:
+                support.append(j)
+        
+        proposals_supported[i] = support
+    
+    return({'delta_holdings':delta_holdings, 'proposals_supported':proposals_supported})
+
+def update_tokens(params, step, sL, s, _input):
+    
+    network = s['network']
+    delta_holdings = _input['delta_holdings']
+    proposals = get_nodes_by_type(network, 'proposal')
+    proposals_supported = _input['proposals_supported']
+    participants = get_nodes_by_type(network, 'participant')
+    alpha = params['alpha']
+    
+    for i in participants:
+        network.nodes[i]['holdings'] = network.nodes[i]['holdings']+delta_holdings[i]
+        supported = proposals_supported[i]
+        total_affinity = np.sum([ network.edges[(i, j)]['affinity'] for j in supported])
+        for j in proposals:
+            if j in supported:
+                normalized_affinity = network.edges[(i, j)]['affinity']/total_affinity
+                network.edges[(i, j)]['tokens'] = normalized_affinity*network.nodes[i]['holdings']
+            else:
+                network.edges[(i, j)]['tokens'] = 0
+            
+            prior_conviction = network.edges[(i, j)]['conviction']
+            current_tokens = network.edges[(i, j)]['tokens']
+            network.edges[(i, j)]['conviction'] =current_tokens+alpha*prior_conviction
+    
+    for j in proposals:
+        network.nodes[j]['conviction'] = np.sum([ network.edges[(i, j)]['conviction'] for i in participants])
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_supply(params, step, sL, s, _input):
+    
+    supply = s['supply']
+    delta_holdings = _input['delta_holdings']
+    delta_supply = np.sum([v for v in delta_holdings.values()])
+    
+    supply = supply + delta_supply
+    
+    key = 'supply'
+    value = supply
+    
+    return (key, value)
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# The Partial State Update Blocks
+partial_state_update_blocks = [
+    {
+        'policies': {
+            #new proposals or new participants
+            'random': driving_process
+        },
+        'variables': {
+            'network': update_network,
+            'funds':increment_funds,
+            'supply':increment_supply
+        }
+    },
+    {
+      'policies': {
+          'completion': check_progress #see if any of the funded proposals completes
+        },
+        'variables': { # The following state variables will be updated simultaneously
+            'sentiment': update_sentiment_on_completion, #note completing decays sentiment, completing bumps it
+            'network': complete_proposal #book-keeping
+        }
+    },
+        {
+      'policies': {
+          'release': trigger_function #check each proposal to see if it passes
+        },
+        'variables': { # The following state variables will be updated simultaneously
+            'funds': decrement_funds, #funds expended
+            'sentiment': update_sentiment_on_release, #releasing funds can bump sentiment
+            'network': update_proposals #reset convictions, and participants sentiments
+                                        #update based on affinities
+        }
+    },
+    {
+        'policies': {
+            'participants_act': participants_decisions, #high sentiment, high affinity =>buy
+                                                        #low sentiment, low affinities => burn
+                                                        #assign tokens to top affinities
+        },
+        'variables': {
+            'supply': update_supply,
+            'network': update_tokens #update everyones holdings
+                                    #and their conviction for each proposal
+        }
+    }
+]
+
+n= 25 #initial participants
+m= 3 #initial proposals
+
+initial_sentiment = .5
+
+network, initial_funds, initial_supply, total_requested = initialize_network(n,m,total_funds_given_total_supply,trigger_threshold)
+
+initial_conditions = {'network':network,
+                      'supply': initial_supply,
+                      'funds':initial_funds,
+                      'sentiment': initial_sentiment}
+
+#power of 1 token forever
+# conviction_capactity = [2]
+# alpha = [1-1/cc for cc in conviction_capactity]
+# print(alpha)
+
+params={
+    'sensitivity': [.75],
+    'tmin': [7], #unit days; minimum periods passed before a proposal can pass
+    'sentiment_decay': [.001], #termed mu in the state update function
+    'alpha': [0.5, 0.9],
+    'base_completion_rate': [10],
+    'trigger_func': [trigger_threshold]
+}
+
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# Settings of general simulation parameters, unrelated to the system itself
+# `T` is a range with the number of discrete units of time the simulation will run for;
+# `N` is the number of times the simulation will be run (Monte Carlo runs)
+time_periods_per_run = 250
+monte_carlo_runs = 1
+
+simulation_parameters = config_sim({
+    'T': range(time_periods_per_run),
+    'N': monte_carlo_runs,
+    'M': params
+})
+
+
+from cadCAD.configuration import append_configs
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# The configurations above are then packaged into a `Configuration` object
+append_configs(
+    initial_state=initial_conditions, #dict containing variable names and initial values
+    partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions
+    sim_configs=simulation_parameters #dict containing simulation parameters
+)
+
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+raw_result, tensor = run.execute()
+
+# exec_mode = ExecutionMode()
+# exec_context = ExecutionContext(context=exec_mode.multi_proc)
+# # run = Executor(exec_context=exec_context, configs=configs)
+# executor = Executor(exec_context, configs) # Pass the configuration object inside an array
+# raw_result, tensor = executor.execute() # The `main()` method returns a tuple; its first elements contains the raw results

simulations/validation/conviction_system_logic_sim.py

@@ -0,0 +1,555 @@
+from pprint import pprint
+
+import numpy as np
+from tabulate import tabulate
+
+from cadCAD.configuration.utils import config_sim
+from simulations.validation.conviction_helpers import *
+#import networkx as nx
+from scipy.stats import expon, gamma
+
+
+#functions for partial state update block 1
+
+#Driving processes: arrival of participants, proposals and funds
+##-----------------------------------------
+
+
+def gen_new_participant(network, new_participant_holdings):
+    
+    i = len([node for node in network.nodes])
+    
+    network.add_node(i)
+    network.nodes[i]['type']="participant"
+    
+    s_rv = np.random.rand() 
+    network.nodes[i]['sentiment'] = s_rv
+    network.nodes[i]['holdings']=new_participant_holdings
+    
+    for j in get_nodes_by_type(network, 'proposal'):
+        network.add_edge(i, j)
+        
+        rv = np.random.rand()
+        a_rv = 1-4*(1-rv)*rv #polarized distribution
+        network.edges[(i, j)]['affinity'] = a_rv
+        network.edges[(i,j)]['tokens'] = a_rv*network.nodes[i]['holdings']
+        network.edges[(i, j)]['conviction'] = 0
+    
+    return network
+    
+
+scale_factor = 1000
+
+def gen_new_proposal(network, funds, supply, trigger_func):
+    j = len([node for node in network.nodes])
+    network.add_node(j)
+    network.nodes[j]['type']="proposal"
+    
+    network.nodes[j]['conviction']=0
+    network.nodes[j]['status']='candidate'
+    network.nodes[j]['age']=0
+    
+    rescale = scale_factor*funds
+    r_rv = gamma.rvs(3,loc=0.001, scale=rescale)
+    network.node[j]['funds_requested'] = r_rv
+    
+    network.nodes[j]['trigger']= trigger_func(r_rv, funds, supply)
+    
+    participants = get_nodes_by_type(network, 'participant')
+    proposing_participant = np.random.choice(participants)
+    
+    for i in participants:
+        network.add_edge(i, j)
+        if i==proposing_participant:
+            network.edges[(i, j)]['affinity']=1
+        else:
+            rv = np.random.rand()
+            a_rv = 1-4*(1-rv)*rv #polarized distribution
+            network.edges[(i, j)]['affinity'] = a_rv
+            
+        network.edges[(i, j)]['conviction'] = 0
+        network.edges[(i,j)]['tokens'] = 0
+    return network
+        
+        
+
+def driving_process(params, step, sL, s):
+    
+    #placeholder plumbing for random processes
+    arrival_rate = 10/s['sentiment']
+    rv1 = np.random.rand()
+    new_participant = bool(rv1<1/arrival_rate)
+    if new_participant:
+        h_rv = expon.rvs(loc=0.0, scale=1000)
+        new_participant_holdings = h_rv
+    else:
+        new_participant_holdings = 0
+    
+    network = s['network']
+    affinities = [network.edges[e]['affinity'] for e in network.edges ]
+    median_affinity = np.median(affinities)
+    
+    proposals = get_nodes_by_type(network, 'proposal')
+    fund_requests = [network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate' ]
+    
+    funds = s['funds']
+    total_funds_requested = np.sum(fund_requests)
+    
+    proposal_rate = 10/median_affinity * total_funds_requested/funds
+    rv2 = np.random.rand()
+    new_proposal = bool(rv2<1/proposal_rate)
+    
+    sentiment = s['sentiment']
+    funds = s['funds']
+    scale_factor = 1+4000*sentiment**2
+    
+    #this shouldn't happen but expon is throwing domain errors
+    if scale_factor > 1: 
+        funds_arrival = expon.rvs(loc = 0, scale = scale_factor )
+    else:
+        funds_arrival = 0
+    
+    return({'new_participant':new_participant,
+            'new_participant_holdings':new_participant_holdings,
+            'new_proposal':new_proposal, 
+            'funds_arrival':funds_arrival})
+
+    
+#Mechanisms for updating the state based on driving processes
+##---
+def update_network(params, step, sL, s, _input):
+
+    network = s['network']
+    funds = s['funds']
+    supply = s['supply']
+    trigger_func = params['trigger_func']
+
+    new_participant = _input['new_participant'] #T/F
+    new_proposal = _input['new_proposal'] #T/F
+
+    if new_participant:
+        new_participant_holdings = _input['new_participant_holdings']
+        network = gen_new_participant(network, new_participant_holdings)
+    
+    if new_proposal:
+        network= gen_new_proposal(network,funds,supply,trigger_func )
+    
+    #update age of the existing proposals
+    proposals = get_nodes_by_type(network, 'proposal')
+    
+    for j in proposals:
+        network.nodes[j]['age'] =  network.nodes[j]['age']+1
+        if network.nodes[j]['status'] == 'candidate':
+            requested = network.nodes[j]['funds_requested']
+            network.nodes[j]['trigger'] = trigger_func(requested, funds, supply)
+        else:
+            network.nodes[j]['trigger'] = np.nan
+            
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def increment_funds(params, step, sL, s, _input):
+    
+    funds = s['funds']
+    funds_arrival = _input['funds_arrival']
+
+    #increment funds
+    funds = funds + funds_arrival
+    
+    key = 'funds'
+    value = funds
+    
+    return (key, value)
+
+def increment_supply(params, step, sL, s, _input):
+    
+    supply = s['supply']
+    supply_arrival = _input['new_participant_holdings']
+
+    #increment funds
+    supply = supply + supply_arrival
+    
+    key = 'supply'
+    value = supply
+    
+    return (key, value)
+
+#functions for partial state update block 2
+
+#Driving processes: completion of previously funded proposals
+##-----------------------------------------
+
+def check_progress(params, step, sL, s):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    
+    completed = []
+    for j in proposals:
+        if network.nodes[j]['status'] == 'active':
+            grant_size = network.nodes[j]['funds_requested']
+            base_completion_rate=params['base_completion_rate']
+            likelihood = 1.0/(base_completion_rate+np.log(grant_size))
+            if np.random.rand() < likelihood:
+                completed.append(j)
+    
+    return({'completed':completed})
+
+
+#Mechanisms for updating the state based on check progress
+##---
+def complete_proposal(params, step, sL, s, _input):
+    
+    network = s['network']
+    participants = get_nodes_by_type(network, 'participant')
+    
+    completed = _input['completed']
+    for j in completed:
+        network.nodes[j]['status']='completed'
+        for i in participants:
+            force = network.edges[(i,j)]['affinity']
+            sentiment = network.node[i]['sentiment']
+            network.node[i]['sentiment'] = get_sentimental(sentiment, force, decay=0)
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_sentiment_on_completion(params, step, sL, s, _input):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    completed = _input['completed']
+    
+    grants_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='active'])
+    
+    grants_completed = np.sum([network.nodes[j]['funds_requested'] for j in completed])
+    
+    sentiment = s['sentiment']
+    
+    force = grants_completed/grants_outstanding
+    mu = params['sentiment_decay']
+    if (force >=0) and (force <=1):
+        sentiment = get_sentimental(sentiment, force, mu)
+    else:
+        sentiment = get_sentimental(sentiment, 0, mu)
+    
+    
+    key = 'sentiment'
+    value = sentiment
+    
+    return (key, value)
+
+def get_sentimental(sentiment, force, decay=0):
+    mu = decay
+    sentiment = sentiment*(1-mu) + force
+    
+    if sentiment > 1:
+        sentiment = 1
+        
+    return sentiment
+
+#functions for partial state update block 3
+
+#Decision processes: trigger function policy
+##-----------------------------------------
+
+def trigger_function(params, step, sL, s):
+    
+    network = s['network']
+    funds = s['funds']
+    supply = s['supply']
+    proposals = get_nodes_by_type(network, 'proposal')
+    tmin = params['tmin']
+    
+    accepted = []
+    triggers = {}
+    for j in proposals:
+        if network.nodes[j]['status'] == 'candidate':
+            requested = network.nodes[j]['funds_requested']
+            age = network.nodes[j]['age']
+            threshold = trigger_threshold(requested, funds, supply)
+            if age > tmin:
+                conviction = network.nodes[j]['conviction']
+                if conviction >threshold:
+                    accepted.append(j)
+        else:
+            threshold = np.nan
+            
+        triggers[j] = threshold
+                
+        
+                    
+    return({'accepted':accepted, 'triggers':triggers})
+
+def decrement_funds(params, step, sL, s, _input):
+    
+    funds = s['funds']
+    network = s['network']
+    accepted = _input['accepted']
+
+    #decrement funds
+    for j in accepted:
+        funds = funds - network.nodes[j]['funds_requested']
+    
+    key = 'funds'
+    value = funds
+    
+    return (key, value)
+
+def update_proposals(params, step, sL, s, _input):
+    
+    network = s['network']
+    accepted = _input['accepted']
+    triggers = _input['triggers']
+    participants = get_nodes_by_type(network, 'participant')
+    proposals = get_nodes_by_type(network, 'proposals')
+    sensitivity = params['sensitivity']
+    
+    for j in proposals:
+        network.nodes[j]['trigger'] = triggers[j]
+    
+    #bookkeeping conviction and participant sentiment
+    for j in accepted:
+        network.nodes[j]['status']='active'
+        network.nodes[j]['conviction']=np.nan
+        #change status to active
+        for i in participants:
+        
+            #operating on edge = (i,j)
+            #reset tokens assigned to other candidates
+            network.edges[(i,j)]['tokens']=0
+            network.edges[(i,j)]['conviction'] = np.nan
+            
+            #update participants sentiments (positive or negative) 
+            affinities = [network.edges[(i,p)]['affinity'] for p in proposals if not(p in accepted)]
+            if len(affinities)>1:
+                max_affinity = np.max(affinities)
+                force = network.edges[(i,j)]['affinity']-sensitivity*max_affinity
+            else:
+                force = 0
+            
+            #based on what their affinities to the accepted proposals
+            network.nodes[i]['sentiment'] = get_sentimental(network.nodes[i]['sentiment'], force, False)
+            
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_sentiment_on_release(params, step, sL, s, _input):
+    
+    network = s['network']
+    proposals = get_nodes_by_type(network, 'proposal')
+    accepted = _input['accepted']
+    
+    proposals_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate'])
+    
+    proposals_accepted = np.sum([network.nodes[j]['funds_requested'] for j in accepted])
+    
+    sentiment = s['sentiment']
+    force = proposals_accepted/proposals_outstanding
+    if (force >=0) and (force <=1):
+        sentiment = get_sentimental(sentiment, force, False)
+    else:
+        sentiment = get_sentimental(sentiment, 0, False)
+    
+    key = 'sentiment'
+    value = sentiment
+    
+    return (key, value)
+
+def participants_decisions(params, step, sL, s):
+    network = s['network']
+    participants = get_nodes_by_type(network, 'participant')
+    proposals = get_nodes_by_type(network, 'proposal')
+    candidates = [j for j in proposals if network.nodes[j]['status']=='candidate']
+    sensitivity = params['sensitivity']
+    
+    gain = .01
+    delta_holdings={}
+    proposals_supported ={}
+    for i in participants:
+        force = network.nodes[i]['sentiment']-sensitivity
+        delta_holdings[i] = network.nodes[i]['holdings']*gain*force
+        
+        support = []
+        for j in candidates:
+            affinity = network.edges[(i, j)]['affinity']
+            cutoff = sensitivity*np.max([network.edges[(i,p)]['affinity'] for p in candidates])
+            if cutoff <.5:
+                cutoff = .5
+            
+            if affinity > cutoff:
+                support.append(j)
+        
+        proposals_supported[i] = support
+    
+    return({'delta_holdings':delta_holdings, 'proposals_supported':proposals_supported})
+
+def update_tokens(params, step, sL, s, _input):
+    
+    network = s['network']
+    delta_holdings = _input['delta_holdings']
+    proposals = get_nodes_by_type(network, 'proposal')
+    proposals_supported = _input['proposals_supported']
+    participants = get_nodes_by_type(network, 'participant')
+    alpha = params['alpha']
+    
+    for i in participants:
+        network.nodes[i]['holdings'] = network.nodes[i]['holdings']+delta_holdings[i]
+        supported = proposals_supported[i]
+        total_affinity = np.sum([ network.edges[(i, j)]['affinity'] for j in supported])
+        for j in proposals:
+            if j in supported:
+                normalized_affinity = network.edges[(i, j)]['affinity']/total_affinity
+                network.edges[(i, j)]['tokens'] = normalized_affinity*network.nodes[i]['holdings']
+            else:
+                network.edges[(i, j)]['tokens'] = 0
+            
+            prior_conviction = network.edges[(i, j)]['conviction']
+            current_tokens = network.edges[(i, j)]['tokens']
+            network.edges[(i, j)]['conviction'] =current_tokens+alpha*prior_conviction
+    
+    for j in proposals:
+        network.nodes[j]['conviction'] = np.sum([ network.edges[(i, j)]['conviction'] for i in participants])
+    
+    key = 'network'
+    value = network
+    
+    return (key, value)
+
+def update_supply(params, step, sL, s, _input):
+    
+    supply = s['supply']
+    delta_holdings = _input['delta_holdings']
+    delta_supply = np.sum([v for v in delta_holdings.values()])
+    
+    supply = supply + delta_supply
+    
+    key = 'supply'
+    value = supply
+    
+    return (key, value)
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# The Partial State Update Blocks
+partial_state_update_blocks = [
+    {
+        'policies': {
+            #new proposals or new participants
+            'random': driving_process
+        },
+        'variables': {
+            'network': update_network,
+            'funds':increment_funds,
+            'supply':increment_supply
+        }
+    },
+    {
+      'policies': {
+          'completion': check_progress #see if any of the funded proposals completes
+        },
+        'variables': { # The following state variables will be updated simultaneously
+            'sentiment': update_sentiment_on_completion, #note completing decays sentiment, completing bumps it
+            'network': complete_proposal #book-keeping
+        }
+    },
+        {
+      'policies': {
+          'release': trigger_function #check each proposal to see if it passes
+        },
+        'variables': { # The following state variables will be updated simultaneously
+            'funds': decrement_funds, #funds expended
+            'sentiment': update_sentiment_on_release, #releasing funds can bump sentiment
+            'network': update_proposals #reset convictions, and participants sentiments
+                                        #update based on affinities
+        }
+    },
+    {
+        'policies': {
+            'participants_act': participants_decisions, #high sentiment, high affinity =>buy
+                                                        #low sentiment, low affinities => burn
+                                                        #assign tokens to top affinities
+        },
+        'variables': {
+            'supply': update_supply,
+            'network': update_tokens #update everyones holdings
+                                    #and their conviction for each proposal
+        }
+    }
+]
+
+n= 25 #initial participants
+m= 3 #initial proposals
+
+initial_sentiment = .5
+
+network, initial_funds, initial_supply, total_requested = initialize_network(n,m,total_funds_given_total_supply,trigger_threshold)
+
+initial_conditions = {'network':network,
+                      'supply': initial_supply,
+                      'funds':initial_funds,
+                      'sentiment': initial_sentiment}
+
+#power of 1 token forever
+# conviction_capactity = [2]
+# alpha = [1-1/cc for cc in conviction_capactity]
+# print(alpha)
+
+params={
+    'sensitivity': [.75],
+    'tmin': [7], #unit days; minimum periods passed before a proposal can pass
+    'sentiment_decay': [.001], #termed mu in the state update function
+    'alpha': [0.5],
+    'base_completion_rate': [10],
+    'trigger_func': [trigger_threshold]
+}
+
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# Settings of general simulation parameters, unrelated to the system itself
+# `T` is a range with the number of discrete units of time the simulation will run for;
+# `N` is the number of times the simulation will be run (Monte Carlo runs)
+time_periods_per_run = 250
+monte_carlo_runs = 1
+
+simulation_parameters = config_sim({
+    'T': range(time_periods_per_run),
+    'N': monte_carlo_runs,
+    'M': params
+})
+
+
+from cadCAD.configuration import append_configs
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# The configurations above are then packaged into a `Configuration` object
+append_configs(
+    initial_state=initial_conditions, #dict containing variable names and initial values
+    partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions
+    sim_configs=simulation_parameters #dict containing simulation parameters
+)
+
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from cadCAD import configs
+import pandas as pd
+
+exec_mode = ExecutionMode()
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+i = 0
+for raw_result, tensor_field in run.execute():
+    result = pd.DataFrame(raw_result)
+    print()
+    print(f"Tensor Field: {type(tensor_field)}")
+    print(tabulate(tensor_field, headers='keys', tablefmt='psql'))
+    print(f"Output: {type(result)}")
+    print(tabulate(result, headers='keys', tablefmt='psql'))
+    print()
+    i += 1

simulations/validation/exo_example.ipynb

@@ -0,0 +1,763 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exogenous Example\n",
+    "## Authored by BlockScience, MV Barlin\n",
+    "### Updated July-10-2019 \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Key assumptions and space:\n",
+    "1. Implementation of System Model in cell 2\n",
+    "2. Timestep = day\n",
+    "3. Launch simulation, without intervention from changing governance policies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Library Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Image\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import math\n",
+    "#from tabulate import tabulate\n",
+    "from scipy import stats\n",
+    "sns.set_style('whitegrid')\n",
+    "from decimal import Decimal\n",
+    "from datetime import timedelta\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## cadCAD Setup\n",
+    "#### ----------------cadCAD LIBRARY IMPORTS------------------------"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cadCAD.engine import ExecutionMode, ExecutionContext, Executor\n",
+    "#from simulations.validation import sweep_config\n",
+    "from cadCAD import configs\n",
+    "from cadCAD.configuration import append_configs\n",
+    "from cadCAD.configuration.utils import proc_trigger, ep_time_step, config_sim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#from cadCAD.configuration.utils.parameterSweep import config_sim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Dict, List"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### ----------------Random State Seed-----------------------------"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = {\n",
+    "#    'z': np.random.RandomState(1)\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Timestamp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ts_format = '%Y-%m-%d %H:%M:%S'\n",
+    "t_delta = timedelta(days=0, minutes=0, seconds=1)\n",
+    "def set_time(_g, step, sL, s, _input):\n",
+    "    y = 'timestamp'\n",
+    "    x = ep_time_step(s, dt_str=s['timestamp'], fromat_str=ts_format, _timedelta=t_delta)\n",
+    "    return (y, x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ASSUMED PARAMETERS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### PRICE LIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dai_xns_conversion = 1.0 # Assumed for static conversion 'PUBLISHED PRICE LIST' DEPRECATED"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Initial Condition State Variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "del_stake_pct = 2\n",
+    "\n",
+    "starting_xns = float(10**10)   # initial supply of xns tokens\n",
+    "starting_broker_xns = float(1 * 10**8) # inital holding of xns token by broker app\n",
+    "starting_broker_fiat = float(1 * 10**5) # inital holding of xns token by broker app\n",
+    "starting_broker_stable = float(1 * 10**6) # inital holding of stable token by broker app\n",
+    "starting_deposit_acct = float(100) # inital deposit locked for first month of resources TBD: make function of resource*price\n",
+    "starting_entrance = float(1 * 10**4) # TBD: make function of entrance fee % * cost * # of initial apps\n",
+    "starting_app_usage = float(10) # initial fees from app usage \n",
+    "starting_platform = float(100) # initial platform fees  \n",
+    "starting_resource_fees = float(10) # initial resource fees usage paid by apps  \n",
+    "starting_app_subsidy = float(0.25* 10**9) # initial application subsidy pool\n",
+    "starting_stake = float(4 * 10**7)\n",
+    "starting_stake_pool = starting_stake + ((3*10**7)*(del_stake_pct))  # initial staked pool + ((3*10**7)*(del_stake_pct))\n",
+    "\n",
+    "#starting_block_reward = float(0) # initial block reward   MOVED ABOVE TO POLICY\n",
+    "starting_capacity_subsidy = float(7.5 * 10**7)  # initial capacity subsidy pool\n",
+    "starting_delegate_holdings = 0.15 * starting_xns\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Initial Condition Composite State Variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# subsidy limit is 30% of the 10B supply\n",
+    "starting_treasury = float(5.5 * 10**9) \n",
+    "starting_app_income = float(0) # initial income to application\n",
+    "starting_resource_income = float(0) # initial income to application\n",
+    "starting_delegate_income = float(0) # initial income to delegate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Initial Condition Exogoneous State Variables "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "starting_xns_fiat = float(0.01) # initial xns per fiat signal\n",
+    "starting_fiat_ext = float(1) # initial xns per fiat signal\n",
+    "starting_stable_ext = float(1) # initial stable signal"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exogenous Price Updates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def delta_price(mean,sd):\n",
+    "    '''Returns normal random variable generated by first two central moments of price change of input ticker'''\n",
+    "    rv = np.random.normal(mean, sd)\n",
+    "    return rv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def xns_ext_update(_g, step, sL, s, _input):\n",
+    "    key = 'XNS_fiat_external'\n",
+    "    \n",
+    "    value = s['XNS_fiat_external'] * (1 + delta_price(0.000000, 0.005))\n",
+    "    \n",
+    "    return key, value"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From Currency Analysis of DAI-USD pair  \n",
+    "May-09-2018 through June-10-2019  \n",
+    "Datasource: BitFinex  \n",
+    "Analysis of daily return percentage performed by BlockScience"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DAI_mean = 0.0000719\n",
+    "DAI_sd = 0.006716"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The daily return is computed as:  \n",
+    "$$ r = \\frac{Price_n - Price_{n-1}}{Price_{n-1}} $$  \n",
+    "Thus, the modelled current price can be as:  \n",
+    "$$ Price_n = Price_{n-1} * r + Price_{n-1} $$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def stable_update(_g, step, sL, s, _input):\n",
+    "    key = 'stable_external'\n",
+    "    \n",
+    "    value = s['stable_external'] * (1 + delta_price(DAI_mean, DAI_sd))\n",
+    "    return key, value\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Assumed Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "apps_deployed = 1 # Make part of test- application deployment model\n",
+    "\n",
+    "starting_deposit_acct = float(100) # inital deposit locked for first month of resources TBD: make function of resource*price\n",
+    "\n",
+    "app_resource_fee_constant  =  10**1 # in STABLE, assumed per day per total nodes \n",
+    "platform_fee_constant = 10 # in XNS\n",
+    "# ^^^^^^^^^^^^ MAKE A PERCENTAGE OR FLAT FEE as PART of TESTING"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1000"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "alpha = 100  # Fee Rate\n",
+    "beta = 0.10  # FIXED Too high because multiplied by constant and resource fees\n",
+    "app_platform = alpha * platform_fee_constant\n",
+    "app_platform"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10.0"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "beta_out =beta*100\n",
+    "beta_out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.15"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "starting_capacity_subsidy / (5 * 10**7) / 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "weight = 0.95 # 0.95 internal weight 5% friction from external markets\n",
+    "\n",
+    "def xns_int_update(_g, step, sL, s, _input):\n",
+    "    key = 'XNS_fiat_internal'\n",
+    "\n",
+    "    internal = s['XNS_fiat_internal']  * weight\n",
+    "    external = s['XNS_fiat_external'] * (1 - weight)\n",
+    "    value = internal + external\n",
+    "    \n",
+    "    return key, value"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### CONFIGURATION DICTIONARY"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time_step_count = 3652 # days = 10 years\n",
+    "run_count = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Genesis States"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#----------STATE VARIABLE Genesis DICTIONARY---------------------------\n",
+    "genesis_states = {\n",
+    "    'XNS_fiat_external' : starting_xns_fiat,\n",
+    "    'XNS_fiat_internal' : starting_xns_fiat,\n",
+    " #   'fiat_external' : starting_fiat_ext,\n",
+    "    'stable_external' : starting_stable_ext,\n",
+    "    'timestamp': '2018-10-01 15:16:24',     #es5\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#--------------EXOGENOUS STATE MECHANISM DICTIONARY--------------------\n",
+    "exogenous_states =     {\n",
+    "    'XNS_fiat_external' : xns_ext_update,\n",
+    "#     'fiat_external' : starting_fiat_ext,\n",
+    "    'stable_external' : stable_update,\n",
+    "    \"timestamp\": set_time,\n",
+    "    }\n",
+    "\n",
+    "#--------------ENVIRONMENTAL PROCESS DICTIONARY------------------------\n",
+    "env_processes = {\n",
+    "#     \"Poisson\": env_proc_id\n",
+    "}\n",
+    "#----------------------SIMULATION RUN SETUP----------------------------\n",
+    "sim_config = config_sim(\n",
+    "    {\n",
+    "    \"N\": run_count,\n",
+    "    \"T\": range(time_step_count)\n",
+    "#     \"M\": g  # for parameter sweep\n",
+    "}\n",
+    ")\n",
+    "#----------------------MECHANISM AND BEHAVIOR DICTIONARY---------------\n",
+    "partial_state_update_block = {\n",
+    "    \"price\": {                 \n",
+    "        \"policies\": {  \n",
+    "        },\n",
+    "        \"variables\": {\n",
+    "            'XNS_fiat_internal'     : xns_int_update\n",
+    "#            'app_income'            : app_earn,\n",
+    "        }\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "append_configs(\n",
+    "    sim_configs=sim_config,\n",
+    "    initial_state=genesis_states,\n",
+    "    seeds=seed,\n",
+    "    raw_exogenous_states= exogenous_states,\n",
+    "    env_processes=env_processes,\n",
+    "    partial_state_update_blocks=partial_state_update_block\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Running cadCAD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulation Execution: Single Configuration\n",
+      "\n",
+      "single_proc: [<cadCAD.configuration.Configuration object at 0x0000024B3B37AF60>]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\mbarl\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\cadCAD\\utils\\__init__.py:89: FutureWarning: The use of a dictionary to describe Partial State Update Blocks will be deprecated. Use a list instead.\n",
+      "  FutureWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "exec_mode = ExecutionMode()\n",
+    "\n",
+    "print(\"Simulation Execution: Single Configuration\")\n",
+    "print()\n",
+    "first_config = configs # only contains config1\n",
+    "single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)\n",
+    "run1 = Executor(exec_context=single_proc_ctx, configs=first_config)\n",
+    "run1_raw_result, tensor_field = run1.main()\n",
+    "result = pd.DataFrame(run1_raw_result)\n",
+    "# print()\n",
+    "# print(\"Tensor Field: config1\")\n",
+    "# print(tabulate(tensor_field, headers='keys', tablefmt='psql'))\n",
+    "# print(\"Output:\")\n",
+    "# print(tabulate(result, headers='keys', tablefmt='psql'))\n",
+    "# print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>XNS_fiat_external</th>\n",
+       "      <th>XNS_fiat_internal</th>\n",
+       "      <th>run</th>\n",
+       "      <th>stable_external</th>\n",
+       "      <th>substep</th>\n",
+       "      <th>timestamp</th>\n",
+       "      <th>timestep</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.010000</td>\n",
+       "      <td>0.010000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2018-10-01 15:16:24</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.009944</td>\n",
+       "      <td>0.010000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.000172</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:25</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.009889</td>\n",
+       "      <td>0.009997</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.003516</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:26</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.009848</td>\n",
+       "      <td>0.009992</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.990655</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:27</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.009814</td>\n",
+       "      <td>0.009985</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.001346</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:28</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0.009798</td>\n",
+       "      <td>0.009976</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.002495</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:29</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0.009706</td>\n",
+       "      <td>0.009967</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.994911</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:30</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>0.009625</td>\n",
+       "      <td>0.009954</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.998919</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:31</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.009632</td>\n",
+       "      <td>0.009938</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.995047</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:32</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>0.009648</td>\n",
+       "      <td>0.009922</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.980786</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2018-10-01 15:16:33</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   XNS_fiat_external  XNS_fiat_internal  run  stable_external  substep  \\\n",
+       "0           0.010000           0.010000    1         1.000000        0   \n",
+       "1           0.009944           0.010000    1         1.000172        1   \n",
+       "2           0.009889           0.009997    1         1.003516        1   \n",
+       "3           0.009848           0.009992    1         0.990655        1   \n",
+       "4           0.009814           0.009985    1         1.001346        1   \n",
+       "5           0.009798           0.009976    1         1.002495        1   \n",
+       "6           0.009706           0.009967    1         0.994911        1   \n",
+       "7           0.009625           0.009954    1         0.998919        1   \n",
+       "8           0.009632           0.009938    1         0.995047        1   \n",
+       "9           0.009648           0.009922    1         0.980786        1   \n",
+       "\n",
+       "             timestamp  timestep  \n",
+       "0  2018-10-01 15:16:24         0  \n",
+       "1  2018-10-01 15:16:25         1  \n",
+       "2  2018-10-01 15:16:26         2  \n",
+       "3  2018-10-01 15:16:27         3  \n",
+       "4  2018-10-01 15:16:28         4  \n",
+       "5  2018-10-01 15:16:29         5  \n",
+       "6  2018-10-01 15:16:30         6  \n",
+       "7  2018-10-01 15:16:31         7  \n",
+       "8  2018-10-01 15:16:32         8  \n",
+       "9  2018-10-01 15:16:33         9  "
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

simulations/validation/new_sweep_config.py

@@ -0,0 +1,183 @@
+from decimal import Decimal
+import numpy as np
+from datetime import timedelta
+import pprint
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import env_proc_trigger, ep_time_step, config_sim
+
+from typing import Dict, List
+
+# from cadCAD.utils.sys_config import exo, exo_check
+
+pp = pprint.PrettyPrinter(indent=4)
+
+seeds = {
+    'z': np.random.RandomState(1),
+    'a': np.random.RandomState(2),
+    'b': np.random.RandomState(3),
+    'c': np.random.RandomState(3)
+}
+
+# Optional
+g: Dict[str, List[int]] = {
+    'alpha': [1],
+    'beta': [2, 5],
+    'gamma': [3, 4],
+    'omega': [7]
+}
+
+# Policies per Mechanism
+def p1m1(_g, step, sL, s):
+    return {'param1': 1}
+
+def p2m1(_g, step, sL, s):
+    return {'param2': 4}
+
+def p1m2(_g, step, sL, s):
+    return {'param1': 'a', 'param2': _g['beta']}
+
+def p2m2(_g, step, sL, s):
+    return {'param1': 'b', 'param2': 0}
+
+def p1m3(_g, step, sL, s):
+    return {'param1': np.array([10, 100])}
+
+def p2m3(_g, step, sL, s):
+    return {'param1': np.array([20, 200])}
+
+# Internal States per Mechanism
+def s1m1(_g, step, sL, s, _input):
+    return 's1', 0
+
+def s2m1(_g, step, sL, s, _input):
+    return 's2', _g['beta']
+
+def s1m2(_g, step, sL, s, _input):
+    return 's1', _input['param2']
+
+def s2m2(_g, step, sL, s, _input):
+    return 's2', _input['param2']
+
+def s1m3(_g, step, sL, s, _input):
+    return 's1', 0
+
+def s2m3(_g, step, sL, s, _input):
+    return 's2', 0
+
+
+# Exogenous States
+proc_one_coef_A = 0.7
+proc_one_coef_B = 1.3
+
+
+def es3p1(_g, step, sL, s, _input):
+    return 's3', _g['gamma']
+# @curried
+def es4p2(_g, step, sL, s, _input):
+    return 's4', _g['gamma']
+
+ts_format = '%Y-%m-%d %H:%M:%S'
+t_delta = timedelta(days=0, minutes=0, seconds=1)
+def es5p2(_g, step, sL, s, _input):
+    y = 'timestep'
+    x = ep_time_step(s, dt_str=s['timestep'], fromat_str=ts_format, _timedelta=t_delta)
+    return (y, x)
+
+
+# Environment States
+# @curried
+# def env_a(param, x):
+#     return x + param
+def env_a(x):
+    return x
+def env_b(x):
+    return 10
+
+
+# Genesis States
+genesis_states = {
+    's1': Decimal(0.0),
+    's2': Decimal(0.0),
+    's3': Decimal(1.0),
+    's4': Decimal(1.0),
+#     'timestep': '2018-10-01 15:16:24'
+}
+
+
+# remove `exo_update_per_ts` to update every ts
+raw_exogenous_states = {
+    "s3": es3p1,
+    "s4": es4p2,
+#     "timestep": es5p2
+}
+
+
+# ToDo: make env proc trigger field agnostic
+# ToDo: input json into function renaming __name__
+triggered_env_b = env_proc_trigger(1, env_b)
+env_processes = {
+    "s3": env_a, #sweep(beta, env_a),
+    "s4": triggered_env_b #rename('parameterized', triggered_env_b) #sweep(beta, triggered_env_b)
+}
+# parameterized_env_processes = parameterize_states(env_processes)
+#
+# pp.pprint(parameterized_env_processes)
+# exit()
+
+# ToDo: The number of values entered in sweep should be the # of config objs created,
+# not dependent on the # of times the sweep is applied
+# sweep exo_state func and point to exo-state in every other funtion
+# param sweep on genesis states
+
+partial_state_update_block = {
+    "m1": {
+        "policies": {
+            "b1": p1m1,
+            "b2": p2m1
+        },
+        "variables": {
+            "s1": s1m1,
+            "s2": s2m1
+        }
+    },
+    "m2": {
+        "policies": {
+            "b1": p1m2,
+            "b2": p2m2,
+        },
+        "variables": {
+            "s1": s1m2,
+            "s2": s2m2
+        }
+    },
+    "m3": {
+        "policies": {
+            "b1": p1m3,
+            "b2": p2m3
+        },
+        "variables": {
+            "s1": s1m3,
+            "s2": s2m3
+        }
+    }
+}
+
+# config_sim Necessary
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+        "M": g # Optional
+    }
+)
+
+# New Convention
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    seeds=seeds,
+    raw_exogenous_states={}, #raw_exogenous_states,
+    env_processes={}, #env_processes,
+    partial_state_update_blocks=partial_state_update_block
+)

simulations/validation/sweep_config.py

@@ -4,8 +4,9 @@ from datetime import timedelta
 import pprint
 
 from cadCAD.configuration import append_configs
-from cadCAD.configuration.utils import proc_trigger, ep_time_step
-from cadCAD.configuration.utils.parameterSweep import config_sim
+from cadCAD.configuration.utils import env_proc_trigger, ep_time_step, config_sim
+
+from typing import Dict, List
 
 pp = pprint.PrettyPrinter(indent=4)
 
@@ -16,8 +17,8 @@ seeds = {
     'c': np.random.RandomState(3)
 }
 
-
-g = {
+# Optional
+g: Dict[str, List[int]] = {
     'alpha': [1],
     'beta': [2, 5],
     'gamma': [3, 4],
@@ -45,34 +46,22 @@ def p2m3(_g, step, sL, s):
 
 # Internal States per Mechanism
 def s1m1(_g, step, sL, s, _input):
-    y = 's1'
-    x = 0
-    return (y, x)
+    return 's1', 0
 
 def s2m1(_g, step, sL, s, _input):
-    y = 's2'
-    x = _g['beta']
-    return (y, x)
+    return 's2', _g['beta']
 
 def s1m2(_g, step, sL, s, _input):
-    y = 's1'
-    x = _input['param2']
-    return (y, x)
+    return 's1', _input['param2']
 
 def s2m2(_g, step, sL, s, _input):
-    y = 's2'
-    x = _input['param2']
-    return (y, x)
+    return 's2', _input['param2']
 
 def s1m3(_g, step, sL, s, _input):
-    y = 's1'
-    x = 0
-    return (y, x)
+    return 's1', 0
 
 def s2m3(_g, step, sL, s, _input):
-    y = 's2'
-    x = 0
-    return (y, x)
+    return 's2', 0
 
 
 # Exogenous States
@@ -81,14 +70,10 @@ proc_one_coef_B = 1.3
 
 
 def es3p1(_g, step, sL, s, _input):
-    y = 's3'
-    x = _g['gamma']
-    return (y, x)
+    return 's3', _g['gamma']
 # @curried
 def es4p2(_g, step, sL, s, _input):
-    y = 's4'
-    x = _g['gamma']
-    return (y, x)
+    return 's4', _g['gamma']
 
 ts_format = '%Y-%m-%d %H:%M:%S'
 t_delta = timedelta(days=0, minutes=0, seconds=1)
@@ -128,7 +113,7 @@ raw_exogenous_states = {
 
 # ToDo: make env proc trigger field agnostic
 # ToDo: input json into function renaming __name__
-triggered_env_b = proc_trigger(1, env_b)
+triggered_env_b = env_proc_trigger(1, env_b)
 env_processes = {
     "s3": env_a, #sweep(beta, env_a),
     "s4": triggered_env_b #rename('parameterized', triggered_env_b) #sweep(beta, triggered_env_b)
@@ -176,16 +161,16 @@ partial_state_update_block = {
     }
 }
 
-
+# config_sim Necessary
 sim_config = config_sim(
     {
         "N": 2,
         "T": range(5),
-        "M": g
+        "M": g # Optional
     }
 )
 
-
+# New Convention
 append_configs(
     sim_configs=sim_config,
     initial_state=genesis_states,

simulations/validation/write_simulation.py

@@ -0,0 +1,118 @@
+from decimal import Decimal
+
+import numpy as np
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import bound_norm_random, config_sim
+
+seeds = {
+    'z': np.random.RandomState(1),
+    'a': np.random.RandomState(2),
+    'b': np.random.RandomState(3),
+    'c': np.random.RandomState(3)
+}
+
+
+# Policies per Mechanism
+def p1(_g, step, sL, s):
+    return {'param1': 10}
+def p2(_g, step, sL, s):
+    return {'param1': 10, 'param2': 40}
+
+
+# Internal States per Mechanism
+def s1(_g, step, sL, s, _input):
+    y = 'ds1'
+    x = s['ds1'] + 1
+    return (y, x)
+def s2(_g, step, sL, s, _input):
+    y = 'ds2'
+    x = _input['param2']
+    return (y, x)
+
+
+# Exogenous States
+proc_one_coef_A = 0.7
+proc_one_coef_B = 1.3
+
+def es(_g, step, sL, s, _input):
+    y = 'ds3'
+    x = s['ds3'] * bound_norm_random(seeds['a'], proc_one_coef_A, proc_one_coef_B)
+    return (y, x)
+
+
+# Environment States
+def env_a(x):
+    return 5
+def env_b(x):
+    return 10
+
+
+# Genesis States
+genesis_states = {
+    'ds1': Decimal(0.0),
+    'ds2': Decimal(0.0),
+    'ds3': Decimal(1.0)
+}
+
+
+raw_exogenous_states = {
+    "ds3": es
+}
+
+
+env_processes = {
+    "ds3": env_a
+}
+
+
+partial_state_update_block = {
+    "m1": {
+        "policies": {
+            "p1": p1,
+            "p2": p2
+        },
+        "variables": {
+            "ds1": s1,
+            "ds2": s2
+        }
+    },
+    "m2": {
+        "policies": {
+            "p1": p1,
+            "p2": p2
+        },
+        "variables": {
+            "ds1": s1,
+            "ds2": s2
+        }
+    },
+    "m3": {
+        "policies": {
+            "p1": p1,
+            "p2": p2
+        },
+        "variables": {
+            "ds1": s1,
+            "ds2": s2
+        }
+    }
+}
+
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(4),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    seeds=seeds,
+    raw_exogenous_states=raw_exogenous_states,
+    env_processes=env_processes,
+    partial_state_update_blocks=partial_state_update_block,
+    policy_ops=[lambda a, b: a + b]
+)

testing/generic_test.py

@@ -0,0 +1,57 @@
+import unittest
+from parameterized import parameterized
+from functools import reduce
+
+
+def generate_assertions_df(df, expected_results, target_cols, evaluations):
+    test_names = []
+    for eval_f in evaluations:
+        def wrapped_eval(a, b):
+            try:
+                return eval_f(a, b)
+            except KeyError:
+                return True
+
+        test_name = f"{eval_f.__name__}_test"
+        test_names.append(test_name)
+        df[test_name] = df.apply(
+            lambda x: wrapped_eval(
+                x.filter(items=target_cols).to_dict(),
+                expected_results[(x['run'], x['timestep'], x['substep'])]
+            ),
+            axis=1
+        )
+
+    return df, test_names
+
+
+def make_generic_test(params):
+    class TestSequence(unittest.TestCase):
+
+        def generic_test(self, tested_df, expected_reults, test_name):
+            erroneous = tested_df[(tested_df[test_name] == False)]
+            # print(tabulate(tested_df, headers='keys', tablefmt='psql'))
+
+            if erroneous.empty is False:  # Or Entire df IS NOT erroneous
+                for index, row in erroneous.iterrows():
+                    expected = expected_reults[(row['run'], row['timestep'], row['substep'])]
+                    unexpected = {f"invalid_{k}": expected[k] for k in expected if k in row and expected[k] != row[k]}
+
+                    for key in unexpected.keys():
+                        erroneous[key] = None
+                        erroneous.at[index, key] = unexpected[key]
+                # etc.
+
+            # ToDo: Condition that will change false to true
+            self.assertTrue(reduce(lambda a, b: a and b, tested_df[test_name]))
+
+
+        @parameterized.expand(params)
+        def test_validation(self, name, result_df, expected_reults, target_cols, evaluations):
+            # alt for (*) Exec Debug mode
+            tested_df, test_names = generate_assertions_df(result_df, expected_reults, target_cols, evaluations)
+
+            for test_name in test_names:
+                self.generic_test(tested_df, expected_reults, test_name)
+
+    return TestSequence

testing/system_models/external_dataset.py

@@ -0,0 +1,66 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim
+import pandas as pd
+from cadCAD.utils import SilentDF
+
+df = SilentDF(pd.read_csv('/DiffyQ-SimCAD/simulations/external_data/output.csv'))
+
+
+def query(s, df):
+    return df[
+            (df['run'] == s['run']) & (df['substep'] == s['substep']) & (df['timestep'] == s['timestep'])
+        ].drop(columns=['run', 'substep', "timestep"])
+
+def p1(_g, substep, sL, s):
+    result_dict = query(s, df).to_dict()
+    del result_dict["ds3"]
+    return {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+def p2(_g, substep, sL, s):
+    result_dict = query(s, df).to_dict()
+    del result_dict["ds1"], result_dict["ds2"]
+    return {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+# integrate_ext_dataset
+def integrate_ext_dataset(_g, step, sL, s, _input):
+    result_dict = query(s, df).to_dict()
+    return 'external_data', {k: list(v.values()).pop() for k, v in result_dict.items()}
+
+def increment(y, incr_by):
+    return lambda _g, step, sL, s, _input: (y, s[y] + incr_by)
+increment = increment('increment', 1)
+
+def view_policies(_g, step, sL, s, _input):
+    return 'policies', _input
+
+
+external_data = {'ds1': None, 'ds2': None, 'ds3': None}
+state_dict = {
+    'increment': 0,
+    'external_data': external_data,
+    'policies': external_data
+}
+
+
+policies = {"p1": p1, "p2": p2}
+states = {'increment': increment, 'external_data': integrate_ext_dataset, 'policies': view_policies}
+PSUB = {'policies': policies, 'states': states}
+
+# needs M1&2 need behaviors
+partial_state_update_blocks = {
+    'PSUB1': PSUB,
+    'PSUB2': PSUB,
+    'PSUB3': PSUB
+}
+
+sim_config = config_sim({
+    "N": 2,
+    "T": range(4)
+})
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=state_dict,
+    partial_state_update_blocks=partial_state_update_blocks,
+    policy_ops=[lambda a, b: {**a, **b}]
+)

testing/system_models/historical_state_access.py

@@ -0,0 +1,93 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim, access_block
+
+
+policies, variables = {}, {}
+exclusion_list = ['nonexsistant', 'last_x', '2nd_to_last_x', '3rd_to_last_x', '4th_to_last_x']
+
+# Policies per Mechanism
+
+# WARNING: DO NOT delete elements from sH
+# state_history, target_field, psu_block_offset, exculsion_list
+def last_update(_g, substep, sH, s):
+    return {"last_x": access_block(
+            state_history=sH,
+            target_field="last_x",
+            psu_block_offset=-1,
+            exculsion_list=exclusion_list
+        )
+    }
+policies["last_x"] = last_update
+
+def second2last_update(_g, substep, sH, s):
+    return {"2nd_to_last_x": access_block(sH, "2nd_to_last_x", -2, exclusion_list)}
+policies["2nd_to_last_x"] = second2last_update
+
+
+# Internal States per Mechanism
+
+# WARNING: DO NOT delete elements from sH
+def add(y, x):
+    return lambda _g, substep, sH, s, _input: (y, s[y] + x)
+variables['x'] = add('x', 1)
+
+# last_partial_state_update_block
+def nonexsistant(_g, substep, sH, s, _input):
+    return 'nonexsistant', access_block(sH, "nonexsistant", 0, exclusion_list)
+variables['nonexsistant'] = nonexsistant
+
+# last_partial_state_update_block
+def last_x(_g, substep, sH, s, _input):
+    return 'last_x', _input["last_x"]
+variables['last_x'] = last_x
+
+# 2nd to last partial state update block
+def second_to_last_x(_g, substep, sH, s, _input):
+    return '2nd_to_last_x', _input["2nd_to_last_x"]
+variables['2nd_to_last_x'] = second_to_last_x
+
+# 3rd to last partial state update block
+def third_to_last_x(_g, substep, sH, s, _input):
+    return '3rd_to_last_x', access_block(sH, "3rd_to_last_x", -3, exclusion_list)
+variables['3rd_to_last_x'] = third_to_last_x
+
+# 4th to last partial state update block
+def fourth_to_last_x(_g, substep, sH, s, _input):
+    return '4th_to_last_x', access_block(sH, "4th_to_last_x", -4, exclusion_list)
+variables['4th_to_last_x'] = fourth_to_last_x
+
+
+genesis_states = {
+    'x': 0,
+    'nonexsistant': [],
+    'last_x': [],
+    '2nd_to_last_x': [],
+    '3rd_to_last_x': [],
+    '4th_to_last_x': []
+}
+
+PSUB = {
+    "policies": policies,
+    "variables": variables
+}
+
+partial_state_update_block = {
+    "PSUB1": PSUB,
+    "PSUB2": PSUB,
+    "PSUB3": PSUB
+}
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=partial_state_update_block
+)
+
+

testing/system_models/param_sweep.py

@@ -0,0 +1,98 @@
+import pprint
+from typing import Dict, List
+
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import env_trigger, var_substep_trigger, config_sim, psub_list
+
+pp = pprint.PrettyPrinter(indent=4)
+
+def some_function(x):
+    return x
+
+# Optional
+# dict must contain lists opf 2 distinct lengths
+g: Dict[str, List[int]] = {
+    'alpha': [1],
+    'beta': [2, some_function],
+    'gamma': [3, 4],
+    'omega': [7]
+}
+
+psu_steps = ['m1', 'm2', 'm3']
+system_substeps = len(psu_steps)
+var_timestep_trigger = var_substep_trigger([0, system_substeps])
+env_timestep_trigger = env_trigger(system_substeps)
+env_process = {}
+
+
+# ['s1', 's2', 's3', 's4']
+# Policies per Mechanism
+def gamma(_g, step, sL, s):
+    return {'gamma': _g['gamma']}
+
+
+def omega(_g, step, sL, s):
+    return {'omega': _g['omega']}
+
+
+# Internal States per Mechanism
+def alpha(_g, step, sL, s, _input):
+    return 'alpha', _g['alpha']
+
+
+def beta(_g, step, sL, s, _input):
+    return 'beta', _g['beta']
+
+
+def policies(_g, step, sL, s, _input):
+    return 'policies', _input
+
+
+def sweeped(_g, step, sL, s, _input):
+    return 'sweeped', {'beta': _g['beta'], 'gamma': _g['gamma']}
+
+psu_block = {k: {"policies": {}, "variables": {}} for k in psu_steps}
+for m in psu_steps:
+    psu_block[m]['policies']['gamma'] = gamma
+    psu_block[m]['policies']['omega'] = omega
+    psu_block[m]["variables"]['alpha'] = alpha
+    psu_block[m]["variables"]['beta'] = beta
+    psu_block[m]['variables']['policies'] = policies
+    psu_block[m]["variables"]['sweeped'] = var_timestep_trigger(y='sweeped', f=sweeped)
+
+
+# Genesis States
+genesis_states = {
+    'alpha': 0,
+    'beta': 0,
+    'policies': {},
+    'sweeped': {}
+}
+
+# Environment Process
+env_process['sweeped'] = env_timestep_trigger(trigger_field='timestep', trigger_vals=[5], funct_list=[lambda _g, x: _g['beta']])
+
+
+sim_config = config_sim(
+    {
+        "N": 2,
+        "T": range(5),
+        "M": g, # Optional
+    }
+)
+
+# New Convention
+partial_state_update_blocks = psub_list(psu_block, psu_steps)
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    env_processes=env_process,
+    partial_state_update_blocks=partial_state_update_blocks
+)
+
+
+print()
+print("Policie State Update Block:")
+pp.pprint(partial_state_update_blocks)
+print()
+print()

testing/system_models/policy_aggregation.py

@@ -0,0 +1,83 @@
+from cadCAD.configuration import append_configs
+from cadCAD.configuration.utils import config_sim
+
+
+# Policies per Mechanism
+def p1m1(_g, step, sL, s):
+    return {'policy1': 1}
+def p2m1(_g, step, sL, s):
+    return {'policy2': 2}
+
+def p1m2(_g, step, sL, s):
+    return {'policy1': 2, 'policy2': 2}
+def p2m2(_g, step, sL, s):
+    return {'policy1': 2, 'policy2': 2}
+
+def p1m3(_g, step, sL, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+def p2m3(_g, step, sL, s):
+    return {'policy1': 1, 'policy2': 2, 'policy3': 3}
+
+
+# Internal States per Mechanism
+def add(y, x):
+    return lambda _g, step, sH, s, _input: (y, s[y] + x)
+
+def policies(_g, step, sH, s, _input):
+    y = 'policies'
+    x = _input
+    return (y, x)
+
+
+# Genesis States
+genesis_states = {
+    'policies': {},
+    's1': 0
+}
+
+variables = {
+    's1': add('s1', 1),
+    "policies": policies
+}
+
+partial_state_update_block = {
+    "m1": {
+        "policies": {
+            "p1": p1m1,
+            "p2": p2m1
+        },
+        "variables": variables
+    },
+    "m2": {
+        "policies": {
+            "p1": p1m2,
+            "p2": p2m2
+        },
+        "variables": variables
+    },
+    "m3": {
+        "policies": {
+            "p1": p1m3,
+            "p2": p2m3
+        },
+        "variables": variables
+    }
+}
+
+
+sim_config = config_sim(
+    {
+        "N": 1,
+        "T": range(3),
+    }
+)
+
+
+append_configs(
+    sim_configs=sim_config,
+    initial_state=genesis_states,
+    partial_state_update_blocks=partial_state_update_block,
+    policy_ops=[lambda a, b: a + b, lambda y: y * 2] # Default: lambda a, b: a + b
+)
+
+

testing/tests/external_dataset.py

@@ -0,0 +1,110 @@
+import unittest
+
+import pandas as pd
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from simulations.regression_tests import external_dataset
+from cadCAD import configs
+from testing.generic_test import make_generic_test
+
+exec_mode = ExecutionMode()
+
+print("Simulation Execution: Single Configuration")
+print()
+first_config = configs
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=first_config)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+
+
+def get_expected_results(run):
+    return {
+        (run, 0, 0): {
+            'external_data': {'ds1': None, 'ds2': None, 'ds3': None},
+            'increment': 0,
+            'policies': {'ds1': None, 'ds2': None, 'ds3': None}
+        },
+        (run, 1, 1): {
+            'external_data': {'ds1': 0, 'ds2': 0, 'ds3': 1},
+             'increment': 1,
+             'policies': {'ds1': 0, 'ds2': 0, 'ds3': 1}
+        },
+        (run, 1, 2): {
+            'external_data': {'ds1': 1, 'ds2': 40, 'ds3': 5},
+             'increment': 2,
+             'policies': {'ds1': 1, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 1, 3): {
+            'external_data': {'ds1': 2, 'ds2': 40, 'ds3': 5},
+             'increment': 3,
+             'policies': {'ds1': 2, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 2, 1): {
+            'external_data': {'ds1': 3, 'ds2': 40, 'ds3': 5},
+             'increment': 4,
+             'policies': {'ds1': 3, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 2, 2): {
+            'external_data': {'ds1': 4, 'ds2': 40, 'ds3': 5},
+             'increment': 5,
+             'policies': {'ds1': 4, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 2, 3): {
+            'external_data': {'ds1': 5, 'ds2': 40, 'ds3': 5},
+            'increment': 6,
+            'policies': {'ds1': 5, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 3, 1): {
+            'external_data': {'ds1': 6, 'ds2': 40, 'ds3': 5},
+            'increment': 7,
+            'policies': {'ds1': 6, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 3, 2): {
+            'external_data': {'ds1': 7, 'ds2': 40, 'ds3': 5},
+            'increment': 8,
+            'policies': {'ds1': 7, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 3, 3): {
+            'external_data': {'ds1': 8, 'ds2': 40, 'ds3': 5},
+            'increment': 9,
+            'policies': {'ds1': 8, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 4, 1): {
+            'external_data': {'ds1': 9, 'ds2': 40, 'ds3': 5},
+            'increment': 10,
+            'policies': {'ds1': 9, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 4, 2): {
+            'external_data': {'ds1': 10, 'ds2': 40, 'ds3': 5},
+            'increment': 11,
+            'policies': {'ds1': 10, 'ds2': 40, 'ds3': 5}
+        },
+        (run, 4, 3): {
+            'external_data': {'ds1': 11, 'ds2': 40, 'ds3': 5},
+            'increment': 12,
+            'policies': {'ds1': 11, 'ds2': 40, 'ds3': 5}
+        }
+    }
+
+
+expected_results = {}
+expected_results_1 = get_expected_results(1)
+expected_results_2 = get_expected_results(2)
+expected_results.update(expected_results_1)
+expected_results.update(expected_results_2)
+
+
+def row(a, b):
+    return a == b
+
+
+params = [["external_dataset", result, expected_results, ['increment', 'external_data', 'policies'], [row]]]
+
+
+class GenericTest(make_generic_test(params)):
+    pass
+
+
+if __name__ == '__main__':
+    unittest.main()

testing/tests/historical_state_access.py

@@ -0,0 +1,124 @@
+import unittest
+import pandas as pd
+
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from testing.generic_test import make_generic_test
+from testing.system_models import historical_state_access
+from cadCAD import configs
+
+
+exec_mode = ExecutionMode()
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=configs)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+expected_results = {
+    (1, 0, 0): {'x': 0, 'nonexsistant': [], 'last_x': [], '2nd_to_last_x': [], '3rd_to_last_x': [], '4th_to_last_x': []},
+    (1, 1, 1): {'x': 1,
+                'nonexsistant': [],
+                'last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '2nd_to_last_x': [],
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 1, 2): {'x': 2,
+                'nonexsistant': [],
+                'last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '2nd_to_last_x': [],
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 1, 3): {'x': 3,
+                'nonexsistant': [],
+                'last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '2nd_to_last_x': [],
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 2, 1): {'x': 4,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 4, 'run': 1, 'substep': 1, 'timestep': 1}, # x: 1
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '2nd_to_last_x': [{'x': -1, 'run': 1, 'substep': 0, 'timestep': 0}], # x: 0
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 2, 2): {'x': 5,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 1, 'run': 1, 'substep': 1, 'timestep': 1},
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '2nd_to_last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 2, 3): {'x': 6,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 1, 'run': 1, 'substep': 1, 'timestep': 1},
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '2nd_to_last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '3rd_to_last_x': [],
+                '4th_to_last_x': []},
+    (1, 3, 1): {'x': 7,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 4, 'run': 1, 'substep': 1, 'timestep': 2},
+                    {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2},
+                    {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}
+                ],
+                '2nd_to_last_x': [
+                    {'x': 1, 'run': 1, 'substep': 1, 'timestep': 1},
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '3rd_to_last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '4th_to_last_x': []},
+    (1, 3, 2): {'x': 8,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 4, 'run': 1, 'substep': 1, 'timestep': 2},
+                    {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2},
+                    {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}
+                ],
+                '2nd_to_last_x': [
+                    {'x': 1, 'run': 1, 'substep': 1, 'timestep': 1},
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '3rd_to_last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '4th_to_last_x': []},
+    (1, 3, 3): {'x': 9,
+                'nonexsistant': [],
+                'last_x': [
+                    {'x': 4, 'run': 1, 'substep': 1, 'timestep': 2},
+                    {'x': 5, 'run': 1, 'substep': 2, 'timestep': 2},
+                    {'x': 6, 'run': 1, 'substep': 3, 'timestep': 2}
+                ],
+                '2nd_to_last_x': [
+                    {'x': 1, 'run': 1, 'substep': 1, 'timestep': 1},
+                    {'x': 2, 'run': 1, 'substep': 2, 'timestep': 1},
+                    {'x': 3, 'run': 1, 'substep': 3, 'timestep': 1}
+                ],
+                '3rd_to_last_x': [{'x': 0, 'run': 1, 'substep': 0, 'timestep': 0}],
+                '4th_to_last_x': []}
+}
+
+
+def row(a, b):
+    return a == b
+params = [
+    ["historical_state_access", result, expected_results,
+           ['x', 'nonexsistant', 'last_x', '2nd_to_last_x', '3rd_to_last_x', '4th_to_last_x'], [row]]
+    ]
+
+
+class GenericTest(make_generic_test(params)):
+    pass
+
+
+if __name__ == '__main__':
+    unittest.main()

testing/tests/param_sweep.py

@@ -0,0 +1,73 @@
+import unittest
+import pandas as pd
+
+
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from testing.system_models import param_sweep
+from cadCAD import configs
+
+from testing.generic_test import make_generic_test
+from testing.system_models.param_sweep import some_function
+
+
+exec_mode = ExecutionMode()
+multi_proc_ctx = ExecutionContext(context=exec_mode.multi_proc)
+run = Executor(exec_context=multi_proc_ctx, configs=configs)
+
+
+def get_expected_results(run, beta, gamma):
+    return {
+        (run, 0, 0): {'policies': {}, 'sweeped': {}, 'alpha': 0, 'beta': 0},
+        (run, 1, 1): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 1, 2): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 1, 3): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 2, 1): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 2, 2): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 2, 3): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 3, 1): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 3, 2): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 3, 3): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 4, 1): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 4, 2): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 4, 3): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': {'beta': beta, 'gamma': gamma}, 'alpha': 1, 'beta': beta},
+        (run, 5, 1): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': beta, 'alpha': 1, 'beta': beta},
+        (run, 5, 2): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': beta, 'alpha': 1, 'beta': beta},
+        (run, 5, 3): {'policies': {'gamma': gamma, 'omega': 7}, 'sweeped': beta, 'alpha': 1, 'beta': beta}
+    }
+
+
+expected_results_1 = {}
+expected_results_1a = get_expected_results(1, 2, 3)
+expected_results_1b = get_expected_results(2, 2, 3)
+expected_results_1.update(expected_results_1a)
+expected_results_1.update(expected_results_1b)
+
+expected_results_2 = {}
+expected_results_2a = get_expected_results(1, some_function, 4)
+expected_results_2b = get_expected_results(2, some_function, 4)
+expected_results_2.update(expected_results_2a)
+expected_results_2.update(expected_results_2b)
+
+
+i = 0
+expected_results = [expected_results_1, expected_results_2]
+config_names = ['sweep_config_A', 'sweep_config_B']
+
+def row(a, b):
+    return a == b
+def create_test_params(feature, fields):
+    i = 0
+    for raw_result, _ in run.execute():
+        yield [feature, pd.DataFrame(raw_result), expected_results[i], fields, [row]]
+        i += 1
+
+
+params = list(create_test_params("param_sweep", ['alpha', 'beta', 'policies', 'sweeped']))
+
+
+class GenericTest(make_generic_test(params)):
+    pass
+
+
+if __name__ == '__main__':
+    unittest.main()

testing/tests/policy_aggregation.py

@@ -0,0 +1,43 @@
+import unittest
+import pandas as pd
+
+from cadCAD.engine import ExecutionMode, ExecutionContext, Executor
+from testing.generic_test import make_generic_test
+from testing.system_models import policy_aggregation
+from cadCAD import configs
+
+exec_mode = ExecutionMode()
+single_proc_ctx = ExecutionContext(context=exec_mode.single_proc)
+run = Executor(exec_context=single_proc_ctx, configs=configs)
+
+raw_result, tensor_field = run.execute()
+result = pd.DataFrame(raw_result)
+
+expected_results = {
+    (1, 0, 0): {'policies': {}, 's1': 0},
+    (1, 1, 1): {'policies': {'policy1': 1, 'policy2': 4}, 's1': 1}, # 'policy1': 2
+    (1, 1, 2): {'policies': {'policy1': 8, 'policy2': 8}, 's1': 2},
+    (1, 1, 3): {'policies': {'policy1': 4, 'policy2': 8, 'policy3': 12}, 's1': 3},
+    (1, 2, 1): {'policies': {'policy1': 2, 'policy2': 4}, 's1': 4},
+    (1, 2, 2): {'policies': {'policy1': 8, 'policy2': 8}, 's1': 5},
+    (1, 2, 3): {'policies': {'policy1': 4, 'policy2': 8, 'policy3': 12}, 's1': 6},
+    (1, 3, 1): {'policies': {'policy1': 2, 'policy2': 4}, 's1': 7},
+    (1, 3, 2): {'policies': {'policy1': 8, 'policy2': 8}, 's1': 8},
+    (1, 3, 3): {'policies': {'policy1': 4, 'policy2': 8, 'policy3': 12}, 's1': 9}
+}
+
+
+def row(a, b):
+    return a == b
+
+
+params = [["policy_aggregation", result, expected_results, ['policies', 's1'], [row]]]
+
+
+class GenericTest(make_generic_test(params)):
+    pass
+
+
+if __name__ == '__main__':
+    unittest.main()
+

testing/utils.py

@@ -0,0 +1,21 @@
+#
+# def record_generator(row, cols):
+#     return {col: row[col] for col in cols}
+
+def gen_metric_row(row, cols):
+    return ((row['run'], row['timestep'], row['substep']), {col: row[col] for col in cols})
+
+# def gen_metric_row(row):
+#     return ((row['run'], row['timestep'], row['substep']), {'s1': row['s1'], 'policies': row['policies']})
+
+# def gen_metric_row(row):
+#     return {
+#         'run': row['run'],
+#         'timestep': row['timestep'],
+#         'substep': row['substep'],
+#         's1': row['s1'],
+#         'policies': row['policies']
+#     }
+
+def gen_metric_dict(df, cols):
+    return dict([gen_metric_row(row, cols) for index, row in df.iterrows()])

tutorials/README.md

@@ -0,0 +1,11 @@
+**Robot and Marbles Tutorial Series**
+
+In this series, we introduce basic concepts of cadCAD and system modelling in general using a simple toy model.  
+[Part 1](robot-marbles-part-1/robot-marbles-part-1.ipynb) - States and State Update Functions  
+[Part 2](robot-marbles-part-2/robot-marbles-part-2.ipynb) - Actions and State Dependent Policies  
+[Part 3](robot-marbles-part-3/robot-marbles-part-3.ipynb) - From Synchronous to Asynchronous Time  
+[Part 4](robot-marbles-part-4/robot-marbles-part-4.ipynb) - Uncertainty and Stochastic Processes  
+[Part 5](robot-marbles-part-5/robot-marbles-part-5.ipynb) - Using class objects as state variables  
+[Part 6](robot-marbles-part-6/robot-marbles-part-6.ipynb) - A/B testing  
+
+Check out the [videos](videos) folder for detailed walkthroughs of each one of the tutorials.

tutorials/videos/robot-marbles-part-1/README.md

@@ -0,0 +1 @@
+(https://youtu.be/uJEiYHRWA9g)