def test_composite_condition_multi(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
B = TransferMechanism(function=Linear(intercept=4.0), name='B')
C = TransferMechanism(function=Linear(intercept=1.5), name='C')
for m in [A, B, C]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A, B)
comp.add_projection(MappingProjection(), B, C)
sched = Scheduler(composition=comp)
sched.add_condition(A, EveryNPasses(1))
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, All(
Any(
AfterPass(6),
AfterNCalls(B, 2)
),
Any(
AfterPass(2),
AfterNCalls(B, 3)
)
)
)
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 3)
output = list(sched.run(termination_conds=termination_conds))
expected_output = [
A, A, B, A, A, B, C, A, C, A, B, C
]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_two_ABB(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
c = Composition(pathways=[A, B])
term_conds = {TimeScale.TRIAL: AfterNCalls(B, 2)}
stim_list = {A: [[1]]}
sched = Scheduler(composition=c)
sched.add_condition(A, Any(AtPass(0), AfterNCalls(B, 2)))
sched.add_condition(B, Any(JustRan(A), JustRan(B)))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
terminal_mech = B
expected_output = [
numpy.array([2.]),
]
for i in range(len(expected_output)):
numpy.testing.assert_allclose(
expected_output[i],
terminal_mech.get_output_values(c)[i])
def test_system_run_with_combined_condition(self):
# Construction
T = TransferMechanism()
P = Process(pathway=[T])
S = System(processes=[P])
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
S.run(inputs={T: 2.0},
runtime_params={
T: {
"noise": (10.0, Any(AtTrial(1), AfterTrial(2)))
}
},
num_trials=5)
# Runtime param NOT used for noise
S.run(inputs={T: 2.0})
assert np.allclose(
S.results,
[
[np.array([2.])], # Trial 0 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 1 - condition 0, NOT condition 1
[np.array([2.])], # Trial 2 - NOT condition 0, NOT condition 1
[np.array([12.])], # Trial 3 - NOT condition 0, condition 1
[np.array([12.])], # Trial 4 - NOT condition 0, condition 1
[np.array([2.])]
]) # New run (runtime param no longer applies)
def test_invtriangle_1(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A')
B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B')
C = TransferMechanism(function=Linear(intercept=1.5), name='scheduler-pytests-C')
for m in [A, B, C]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A, C)
comp.add_projection(MappingProjection(), B, C)
sched = Scheduler(composition=comp)
sched.add_condition(A, EveryNPasses(1))
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, Any(AfterNCalls(A, 3), AfterNCalls(B, 3)))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = AfterNCalls(C, 4, time_scale=TimeScale.TRIAL)
output = list(sched.run(termination_conds=termination_conds))
expected_output = [
A, set([A, B]), A, C, set([A, B]), C, A, C, set([A, B]), C
]
# pprint.pprint(output)
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_composition_run_with_combined_condition(self):
# Construction
T = TransferMechanism()
C = Composition()
C.add_node(T)
# Runtime param used for noise
# ONLY mechanism value should reflect runtime param -- attr should be changed back by the time we inspect it
C.run(inputs={T: 2.0},
runtime_params={
T: {
"noise": (10.0, Any(AtTrial(1), AfterTrial(2)))
}
},
num_trials=5)
# Runtime param NOT used for noise
C.run(inputs={T: 2.0})
assert np.allclose(
C.results,
[
np.array([[2.]]), # Trial 0 - NOT condition 0, NOT condition 1
np.array([[12.]]), # Trial 1 - condition 0, NOT condition 1
np.array([[2.]]), # Trial 2 - NOT condition 0, NOT condition 1
np.array([[12.]]), # Trial 3 - NOT condition 0, condition 1
np.array([[12.]]), # Trial 4 - NOT condition 0, condition 1
np.array([[2.]])
]) # New run (runtime param no longer applies)
def test_function_param_with_combined_condition(self):
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run with runtime param used for slope only on trial 1 and after 2 (i.e., 3 and 4)
C.run(inputs={T: 2.0},
runtime_params={T: {"slope": (10.0, Any(AtTrial(1), AfterTrial(2)))}},
num_trials=5)
# slope restored to default
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run again to insure restored default for slope after last run
C.run(inputs={T: 2.0})
# results reflect runtime_param used for slope only on trials 1, 3 and 4
assert np.allclose(C.results,[np.array([[2.]]), # Trial 0 - NOT condition 0, NOT condition 1
np.array([[20.]]), # Trial 1 - condition 0, NOT condition 1
np.array([[2.]]), # Trial 2 - NOT condition 0, NOT condition 1
np.array([[20.]]), # Trial 3 - NOT condition 0, condition 1
np.array([[20.]]), # Trial 4 - NOT condition 0, condition 1
np.array([[2.]])]) # New run (runtime param no longer applies)
def test_function_params_with_different_but_overlapping_conditions(self):
T = TransferMechanism()
C = Composition()
C.add_node(T)
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
# run with runtime param used for slope only on trial 1 and after 2 (i.e., 3 and 4)
C.run(inputs={T: 2.0},
runtime_params={T: {"slope": (10.0, Any(AtTrial(1), AfterTrial(2))),
"intercept": (1.0, AfterTrial(1))}},
num_trials=4)
# slope restored to default
assert T.function.slope.base == 1.0
assert T.parameter_ports['slope'].value == 1.0
assert T.function.intercept.base == 0.0
assert T.parameter_ports['intercept'].value == 0.0
# run again to insure restored default for slope after last run
C.run(inputs={T: 2.0})
# results reflect runtime_param used for slope only on trials 1, 3 and 4
assert np.allclose(C.results,[np.array([[2.]]), # Trial 0 - neither condition met
np.array([[20.]]), # Trial 1 - slope condition met, intercept not met
np.array([[3.]]), # Trial 2 - slope condition not met, intercept met
np.array([[21.]]), # Trial 3 - both conditions met
np.array([[2.]])]) # New run (runtime param no longer applies)
def test_params_for_modulatory_projection_in_parameter_port(self):
T1 = TransferMechanism()
T2 = TransferMechanism()
CTL = ControlMechanism(control=ControlSignal(projections=('slope',T2)))
C = Composition(pathways=[[T1,T2,CTL]])
# Run 0
C.run(inputs={T1: 2.0},
runtime_params={
T2: {
PARAMETER_PORT_PARAMS: {
CONTROL_PROJECTION_PARAMS: {
'variable':(5, AtTrial(3)), # variable of all Projection to all ParameterPorts
'value':(10, AtTrial(4)),
'value':(21, AtTrial(5)),
},
# Test individual Projection specifications outside of type-specific dict
CTL.control_signals[0].efferents[0]: {'value':(32, AtTrial(6))},
'ControlProjection for TransferMechanism-1[slope]': {'value':(43, AtTrial(7))},
}
},
},
num_trials=8
)
CTL.control_signals[0].modulation = OVERRIDE
# Run 1
C.run(inputs={T1: 2.0},
runtime_params={
T2: {
PARAMETER_PORT_PARAMS: {
CONTROL_PROJECTION_PARAMS: {
'value':(5, Any(AtTrial(0), AtTrial(2))),
'variable':(10, AtTrial(1)),
# Test individual Projection specifications inside of type-specific dict
'ControlProjection for TransferMechanism-1[slope]': {'value':(19, AtTrial(3))},
CTL.control_signals[0].efferents[0]: {'value':(33, AtTrial(4))},
},
}
},
},
num_trials=5
)
assert np.allclose(C.results,[ # Conditions satisfied:
np.array([[2]]), # Run 0, Trial 0: None (2 input; no control since that requires a cycle)
np.array([[4]]), # Run 0, Trial 1: None (2 input * 2 control gathered last cycle)
np.array([[8]]), # Run 0, Trial 2: None (2 input * 4 control gathered last cycle)
np.array([[10]]), # Run 0, Trial 3: ControlProjection variable (2*5)
np.array([[20]]), # Run 0, Trial 4: ControlProjection value (2*10)
np.array([[42]]), # Run 0, Trial 5: ControlProjection value using Projection type-specific keyword (2*210)
np.array([[64]]), # Run 0, Trial 6: ControlProjection value using individual Projection (2*32)
np.array([[86]]), # Run 0, Trial 7: ControlProjection value using individual Projection by name (2*43)
np.array([[10]]), # Run 1, Tria1 0: ControlProjection value with OVERRIDE using value (2*5)
np.array([[20]]), # Run 1, Tria1 1: ControlProjection value with OVERRIDE using variable (2*10)
np.array([[10]]), # Run 1, Tria1 2: ControlProjection value with OVERRIDE using value again (in Any) (2*5)
np.array([[38]]), # Run 1, Tria1 3: ControlProjection value with OVERRIDE using individ Proj by name (2*19)
np.array([[66]]), # Run 1: Trial 4: ControlProjection value with OVERRIDE using individ Proj (2*33)
])
def test_five_ABABCDE(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
D = TransferMechanism(
name='D',
default_variable=[0],
function=Linear(slope=1.0),
)
E = TransferMechanism(
name='E',
default_variable=[0],
function=Linear(slope=2.0),
)
c = Composition(pathways=[[A, C, D], [B, C, E]])
term_conds = {TimeScale.TRIAL: AfterNCalls(E, 1)}
stim_list = {A: [[1]], B: [[2]]}
sched = Scheduler(composition=c)
sched.add_condition(C, Any(EveryNCalls(A, 1), EveryNCalls(B, 1)))
sched.add_condition(D, EveryNCalls(C, 1))
sched.add_condition(E, EveryNCalls(C, 1))
c.scheduler = sched
c.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [D, E]
expected_output = [
[
numpy.array([3.]),
],
[
numpy.array([6.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(c)[i])
def test_multisource_2(self):
comp = Composition()
A1 = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A1')
A2 = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A2')
B1 = TransferMechanism(function=Linear(intercept=4.0), name='B1')
B2 = TransferMechanism(function=Linear(intercept=4.0), name='B2')
B3 = TransferMechanism(function=Linear(intercept=4.0), name='B3')
C1 = TransferMechanism(function=Linear(intercept=1.5), name='C1')
C2 = TransferMechanism(function=Linear(intercept=.5), name='C2')
for m in [A1, A2, B1, B2, B3, C1, C2]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A1, B1)
comp.add_projection(MappingProjection(), A1, B2)
comp.add_projection(MappingProjection(), A2, B1)
comp.add_projection(MappingProjection(), A2, B2)
comp.add_projection(MappingProjection(), A2, B3)
comp.add_projection(MappingProjection(), B1, C1)
comp.add_projection(MappingProjection(), B2, C1)
comp.add_projection(MappingProjection(), B1, C2)
comp.add_projection(MappingProjection(), B3, C2)
sched = Scheduler(composition=comp)
sched.add_condition_set({
A1: Always(),
A2: Always(),
B1: EveryNCalls(A1, 2),
B3: EveryNCalls(A2, 2),
B2: All(EveryNCalls(A1, 4), EveryNCalls(A2, 4)),
C1: Any(AfterNCalls(B1, 2), AfterNCalls(B2, 2)),
C2: Any(AfterNCalls(B2, 2), AfterNCalls(B3, 2)),
})
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = All(AfterNCalls(C1, 1), AfterNCalls(C2, 1))
output = list(sched.run(termination_conds=termination_conds))
expected_output = [
set([A1, A2]), set([A1, A2]), set([B1, B3]), set([A1, A2]), set([A1, A2]), set([B1, B2, B3]), set([C1, C2])
]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_linear_ABB(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A')
B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B')
for m in [A, B]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A, B)
sched = Scheduler(composition=comp)
sched.add_condition(A, Any(AtPass(0), EveryNCalls(B, 2)))
sched.add_condition(B, Any(EveryNCalls(A, 1), EveryNCalls(B, 1)))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = AfterNCalls(B, 8, time_scale=TimeScale.TRIAL)
output = list(sched.run(termination_conds=termination_conds))
expected_output = [A, B, B, A, B, B, A, B, B, A, B, B]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_four_ABBCD(self):
A = TransferMechanism(
name='A',
default_variable=[0],
function=Linear(slope=2.0),
)
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
D = TransferMechanism(
name='D',
default_variable=[0],
function=Linear(slope=1.0),
)
p = Process(default_variable=[0], pathway=[A, B, D], name='p')
q = Process(default_variable=[0], pathway=[A, C, D], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(D, 1)}
stim_list = {A: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 1))
sched.add_condition(C, EveryNCalls(A, 2))
sched.add_condition(D, Any(EveryNCalls(B, 3), EveryNCalls(C, 3)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [D]
expected_output = [
[
numpy.array([4.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(s)[i])
def test_params_for_input_port_and_projection_variable_and_value(self):
SAMPLE_INPUT = TransferMechanism()
TARGET_INPUT = TransferMechanism()
CM = ComparatorMechanism()
P1 = MappingProjection(sender=SAMPLE_INPUT, receiver=CM.input_ports[SAMPLE], name='SAMPLE PROJECTION')
P2 = MappingProjection(sender=TARGET_INPUT, receiver=CM.input_ports[TARGET], name='TARGET PROJECTION')
C = Composition(nodes=[SAMPLE_INPUT, TARGET_INPUT, CM], projections=[P1,P2])
SAMPLE_INPUT.function.slope.base = 3
CM.input_ports[SAMPLE].function.scale.base = 2
TARGET_INPUT.input_port.function.scale.base = 4
CM.input_ports[TARGET].function.scale.base = 1.5
C.run(inputs={SAMPLE_INPUT: 2.0,
TARGET_INPUT: 5.0},
runtime_params={
CM: {
CM.input_ports[SAMPLE]: {'variable':(83,AtTrial(0))}, # InputPort object outside INPUT_PORT_PARAMS
'TARGET': {'value':(999, Any(AtTrial(1),AtTrial(2)))},# InputPort by name outsideINPUT_PORT_PARAMS
INPUT_PORT_PARAMS: {
'scale': (15, AtTrial(2)), # all InputPorts
MAPPING_PROJECTION_PARAMS:{'value':(20, Any(AtTrial(3), AtTrial(4))), # all MappingProjections
'SAMPLE PROJECTION': {'value':(42, AfterTrial(3))}, # By name
P2:{'value':(156, AtTrial(5))}} # By Projection
}}},
num_trials=6
)
assert np.allclose(C.results,[ # Conditions satisfied: CM calculates: TARGET-SAMPLE:
np.array([[-136.0]]), # Trial 0: CM SAMPLE InputPort variable (5*4*2.5 - 83*2)
np.array([[987]]), # Trial 1: CM TARGET InputPort value (999 - 2*3*2)
np.array([[909]]), # Trial 2: CM TARGET InputPort value + CM Inputports SAMPLE fct scale: (999 - 2*3*15)
np.array([[-10]]), # Trial 3: Both CM MappingProjections value, scale default (20*1.5 - 20*2)
np.array([[-54]]), # Trial 4: Same as 3, but superceded by value for SAMPLE Projection (20*1.5 - 42*2)
np.array([[150]]), # Trial 5: Same as 4, but superceded by value for TARGET Projection ((156*1.5-42*2))
])
def test_All_end_after_one_finished(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='A')
for m in [A]:
comp.add_node(m)
sched = Scheduler(composition=comp)
sched.add_condition(A, EveryNPasses(1))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = Any(AfterNCalls(A, 5), AtPass(10))
output = list(sched.run(termination_conds=termination_conds))
expected_output = [A for _ in range(5)]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_three_ABAC_convenience(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=.5))
B = TransferMechanism(
name='B',
default_variable=[0],
function=Linear(slope=2.0),
)
C = TransferMechanism(
name='C',
default_variable=[0],
function=Linear(slope=2.0),
)
p = Process(default_variable=[0], pathway=[A, B], name='p')
q = Process(default_variable=[0], pathway=[A, C], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(C, 1)}
stim_list = {A: [[1]]}
s.scheduler_processing.add_condition(
B, Any(AtNCalls(A, 1), EveryNCalls(A, 2)))
s.scheduler_processing.add_condition(C, EveryNCalls(A, 2))
s.run(inputs=stim_list, termination_processing=term_conds)
terminal_mechs = [B, C]
expected_output = [
[
numpy.array([1.]),
],
[
numpy.array([2.]),
],
]
for m in range(len(terminal_mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(
expected_output[m][i],
terminal_mechs[m].get_output_values(s)[i])
def test_three_integrators(self):
A = IntegratorMechanism(name='A',
default_variable=[0],
function=SimpleIntegrator(rate=1))
B = IntegratorMechanism(name='B',
default_variable=[0],
function=SimpleIntegrator(rate=1))
C = IntegratorMechanism(name='C',
default_variable=[0],
function=SimpleIntegrator(rate=1))
p = Process(default_variable=[0], pathway=[A, C], name='p')
q = Process(default_variable=[0], pathway=[B, C], name='q')
s = System(processes=[p, q], name='s')
term_conds = {TimeScale.TRIAL: AfterNCalls(C, 2)}
stim_list = {A: [[1]], B: [[1]]}
sched = Scheduler(system=s)
sched.add_condition(B, EveryNCalls(A, 2))
sched.add_condition(C, Any(EveryNCalls(A, 1), EveryNCalls(B, 1)))
s.scheduler_processing = sched
s.run(inputs=stim_list, termination_processing=term_conds)
mechs = [A, B, C]
expected_output = [
[
numpy.array([2.]),
],
[
numpy.array([1.]),
],
[
numpy.array([4.]),
],
]
for m in range(len(mechs)):
for i in range(len(expected_output[m])):
numpy.testing.assert_allclose(expected_output[m][i],
mechs[m].get_output_values(s)[i])
def test_10b(self):
comp = Composition()
A = TransferMechanism(function=Linear(slope=5.0, intercept=2.0), name='scheduler-pytests-A')
A._is_finished = False
B = TransferMechanism(function=Linear(intercept=4.0), name='scheduler-pytests-B')
for m in [A, B]:
comp.add_node(m)
comp.add_projection(MappingProjection(), A, B)
sched = Scheduler(composition=comp)
sched.add_condition(A, EveryNPasses(1))
sched.add_condition(B, Any(WhenFinished(A), AfterNCalls(A, 3)))
termination_conds = {}
termination_conds[TimeScale.RUN] = AfterNTrials(1)
termination_conds[TimeScale.TRIAL] = AfterNCalls(B, 4)
output = list(sched.run(termination_conds=termination_conds))
expected_output = [A, A, A, B, A, B, A, B, A, B]
assert output == pytest.helpers.setify_expected_output(expected_output)
def test_params_for_output_port_variable_and_value(self):
T1 = TransferMechanism(output_ports=['FIRST', 'SECOND'])
T2 = TransferMechanism()
T3 = TransferMechanism()
# C = Composition(pathways=[[T1.output_ports['FIRST'],T2],
# [T1.output_ports['SECOND'],T3]])
# FIX 5/8/20 [JDC]: NEED TO ADD PROJECTIONS SINCE CAN'T SPECIFIY OUTPUT PORT IN PATHWAY
P1 = MappingProjection(sender=T1.output_ports['FIRST'], receiver=T2)
P2 = MappingProjection(sender=T1.output_ports['SECOND'], receiver=T2)
C = Composition(nodes=[T1,T2], projections=[P1,P2])
T1.output_ports['SECOND'].function.slope.base = 1.5
# Run 0: Test of both OutputPort variables assigned
C.run(inputs={T1: 10.0},
runtime_params={
T1: {OUTPUT_PORT_PARAMS: {'variable': 2}}}
)
assert T1.value == 0.0 # T1 did not execute since both of its OutputPorts were assigned a variable
assert T2.value == 5 # (2*1 + 2*1.5)
# Run 1: Test of both OutputPort values assigned
C.run(inputs={T1: 11.0},
runtime_params={
T1: {OUTPUT_PORT_PARAMS: {'value': 3}}}
)
assert T1.value == 0.0 # T1 did not execute since both of its OutputPorts were assigned a value
assert T2.value == 6 # (3 + 3)
# Run 2: Test of on OutputPort variable and the other value assigned
C.run(inputs={T1: 12.0},
runtime_params={
T1: {OUTPUT_PORT_PARAMS: {
'FIRST': {'value': 5},
'SECOND': {'variable': 13}}}}
)
assert T1.value == 0.0 # T1 did not execute since both of its OutputPorts were assigned a variable or value
assert T2.value == 24.5 # (5 + 13*1.5)
# Run 3: Tests of numerical accuracy over all permutations of assignments
C.run(inputs={T1: 2.0},
runtime_params={
T1: {
OUTPUT_PORT_PARAMS: {
'variable':(1.7, AtTrial(1)), # variable of all Projection to all ParameterPorts
'value':(3, AtTrial(2)),
'FIRST': {'variable':(5, Any(AtTrial(3),AtTrial(5),AtTrial(9),AtTrial(11))),
'value':(7, Any(AtTrial(6),AtTrial(8),AtTrial(10),AtTrial(12)))
},
'SECOND': {'variable': (11, Any(AtTrial(4),AtTrial(5),AtTrial(10),AtTrial(11),AtTrial(12))),
'value': (13, Any(AtTrial(7),AtTrial(8),AtTrial(9),AtTrial(11),AtTrial(12)))
},
},
},
T2: {
'slope': 3
},
},
num_trials=13
)
assert np.allclose(C.results,[ # OutputPort Conditions satisfied:
np.array([[5]]), # Run 0, Trial 0: See above
np.array([[6]]), # Run 1, Trial 0: See above
np.array([[24.5]]), # Run 2, Trial 0: See above
np.array([[15]]), # Run 3, Trial 0: None (2*1 + 2*1.5) * 3
np.array([[12.75]]), # Run 3, Trial 1: variable general (1.7*1 + 1.7*1.5) * 3
np.array([[18]]), # Run 3, Trial 2: value general (3*1 + 3*1) * 3
np.array([[24]]), # Run 3, Trial 3: FIRST variable (5*1 + 2*1.5) * 3
np.array([[55.5]]), # Run 3, Trial 4: SECOND variable (2*1 + 11*1.5) * 3
np.array([[64.5]]), # Run 3, Trial 5: FIRST and SECOND variable (5*1 + 11*1.5) * 3
np.array([[30]]), # Run 3, Trial 6: FIRST value (7 + 2*1.5) * 3
np.array([[45]]), # Run 3, Trial 7: SECOND value (2*1 + 13) * 3
np.array([[60]]), # Run 3, Trial 8: FIRST and SECOND value (7+13) * 3
np.array([[54]]), # Run 3, Trial 9: FIRST variable and SECOND value (5*1 + 13) * 3
np.array([[70.5]]), # Run 3, Trial 10: FIRST value and SECOND variable (7 + 11*1.5) * 3
np.array([[54]]), # Run 3, Trial 11: FIRST and SECOND variable and SECOND value (5*1 + 13) * 3
np.array([[60]]), # Run 3, Trial 12: FIRST and SECOND value and SECOND variable (7+13) * 3
])
