def test_rhs_atoms_in_namespace(self):
from nineml.abstraction_layer import Expression
e = Expression("random.randn() + random.randn() + random.randint() / sin(t)")
self.assertEquals(set(e.rhs_atoms), set(["t", "random.randn", "random.randint", "sin"]))
self.assertEquals(set(e.rhs_atoms_in_namespace("random")), set(["randn", "randint"]))
def test_rhs_atoms_in_namespace(self):
e = Expression(
"random.randn() + random.randn() + random.randint() / sin(t)")
self.assertEquals(set(e.rhs_atoms),
set(['t', 'random.randn', 'random.randint', 'sin']))
self.assertEquals(set(e.rhs_atoms_in_namespace('random')),
set(['randn', 'randint']))
def test_escape_of_carets(self):
try:
expr = Expression("a^2") # @UnusedVariable
expr = Expression("(a - 2)^2") # @UnusedVariable
expr = Expression("(a - (a^2 - 2))^2") # @UnusedVariable
expr = Expression("a^(a - 2)") # @UnusedVariable
except NineMLMathParseError as e:
self.fail("Carets (signifying exponents) were not escaped properly"
" in expression: {}".format(e))
self.assertTrue(True)
def test_rhs_atoms_in_namespace(self):
e = Expression("random.randn() + random.randn() + random.randint() / sin(t)")
self.assertEquals(
set(e.rhs_atoms),
set(['t', 'random.randn', 'random.randint', 'sin'])
)
self.assertEquals(
set(e.rhs_atoms_in_namespace('random')),
set(['randn', 'randint'])
)
def test_rhs_name_transform_inplace(self):
# Signature: name(self, name_map)
# Replace atoms on the RHS with values in the name_map
e = Expression("V/(1 + mg_conc*eta*exp(-1*gamma*V*V)) * sin(V)")
e.rhs_name_transform_inplace({'V': 'VNEW'})
self.assertEquals(
e.rhs,
"VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Don't Change builtin function names:
e.rhs_name_transform_inplace({'sin': 'SIN'})
self.assertEquals(
e.rhs,
"VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
e.rhs_name_transform_inplace({'exp': 'EXP'})
self.assertEquals(
e.rhs,
"VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Check the attributes:
self.assertEquals(
set(e.rhs_atoms),
set(['VNEW', 'mg_conc', 'eta', 'gamma', 'exp', 'sin']))
self.assertEquals(set(e.rhs_funcs), set(['exp', 'sin']))
def test_rhs_name_transform_inplace(self):
# Signature: name(self, name_map)
# Replace atoms on the RHS with values in the name_map
e = Expression("V/(1 + mg_conc*eta*exp(-1*gamma*V*V)) * sin(V)")
e.rhs_name_transform_inplace({'V': 'VNEW'})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Don't Change builtin function names:
e.rhs_name_transform_inplace({'sin': 'SIN'})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
e.rhs_name_transform_inplace({'exp': 'EXP'})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Check the attributes:
self.assertEquals(set(e.rhs_atoms), set(
['VNEW', 'mg_conc', 'eta', 'gamma', 'exp', 'sin']))
self.assertEquals(set(e.rhs_funcs), set(['exp', 'sin']))
def test_rhs_name_transform_inplace(self):
# Signature: name(self, name_map)
# Replace atoms on the RHS with values in the name_map
from nineml.abstraction_layer import Expression
e = Expression("V/(1 + mg_conc*eta*exp(-1*gamma*V*V)) * sin(V)")
e.rhs_name_transform_inplace({"V": "VNEW"})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Don't Change builtin function names:
e.rhs_name_transform_inplace({"sin": "SIN"})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
e.rhs_name_transform_inplace({"exp": "EXP"})
self.assertEquals(e.rhs, "VNEW/(1 + mg_conc*eta*exp(-1*gamma*VNEW*VNEW)) * sin(VNEW)")
# Check the attributes:
self.assertEquals(set(e.rhs_atoms), set(["VNEW", "mg_conc", "eta", "gamma", "exp", "sin"]))
self.assertEquals(set(e.rhs_funcs), set(["exp", "sin"]))
def test_Valid(self):
# rhs, expt_vars, expt_funcs, result, values
valid_rhses = [
(('a'), ('a'), (), 5, {'a': 5}, ),
(('b'), ('b'), (), 7, {'b': 7}, ),
(('a+b'), ('a', 'b'),
(), 13, {'a': 12, 'b': 1}),
(('1./(alpha+2*beta)'), ('alpha', 'beta'),
(), 0.2, {'alpha': 1, 'beta': 2}),
(('pi'), (), (), 3.14159265, {}),
]
for rhs, exp_var, exp_func, exp_res, params in valid_rhses:
e = Expression(rhs)
self.assertEquals(set(e.rhs_names), set(exp_var))
self.assertEquals(set(e.rhs_funcs), set(exp_func))
self.assertAlmostEqual(e.rhs_as_python_func()(**params), exp_res, places=4)
import numpy
expr_vars = [["-A/tau_r", ("A", "tau_r"), ()],
["V*V", ("V",), ()],
["a*(b*V - U)", ("U", "V", "b", "a"), ()],
[" 0.04*V*V + 5.0*V + 1. + 140.0 - U + Isyn", ("V", "U", "Isyn"), ()],
["c", ("c"), ()],
["1", (), ()],
["atan2(sin(x),cos(y))", ("x", "y"), ("atan2", "sin", "cos")],
["1.*V", ("V"), ()],
["1.0", (), ()],
[".1", (), ()],
["1/(1 + mg_conc*eta*exp(-1*gamma*V))", (
"mg_conc", "eta", "gamma", "V"), ('exp',)],
["1 / ( 1 + mg_conc * eta * exp( -1 * gamma*V))",
("mg_conc", "eta", "gamma", "V"), ('exp',)],
["1 / ( 1 + mg_conc * sin(0.5) * exp ( -1 * gamma*V))",
("mg_conc", "gamma", "V"), ('exp', "sin")],
[".1 / ( 1.0 + mg_conc * sin(V) * exp ( -1.0 * gamma*V))",
("mg_conc", "gamma", "V"), ('exp', "sin")],
["sin(w)", ("w"), ("sin",)]]
namespace = {
"A": 10.0,
"tau_r": 11.0,
"V": -70.0,
"a": 1.2,
"b": 3.0,
"U": -80.0,
"Isyn": 2.0,
"c": 10.0,
"mg_conc": 1.0,
"eta": 2.0,
"gamma": -20.0,
"x": 1.0,
"y": 1.0,
"w": numpy.arange(10)
}
return_values = [-0.909090909091, 4900.0, -156.0, 69.0, 10.0, 1,
1.0, -70.0, 1.0, 0.1, 1.0, 1.0, 1.0, 0.1, numpy.sin(namespace['w'])]
for i, (expr, expt_vars, expt_funcs) in enumerate(expr_vars):
c = Expression(expr)
self.assertEqual(set(c.rhs_names), set(expt_vars))
self.assertEqual(set(c.rhs_funcs), set(expt_funcs))
python_func = c.rhs_as_python_func(namespace=namespace)
param_dict = dict([(v, namespace[v]) for v in expt_vars])
v = return_values[i] - python_func(**param_dict)
self.assertAlmostEqual(numpy.dot(v, v), 0)
def test_Valid(self):
# rhs, expt_vars, expt_funcs, result, values
valid_rhses = [
(
('a'),
('a'),
(),
5,
{
'a': 5
},
),
(
('b'),
('b'),
(),
7,
{
'b': 7
},
),
(('a+b'), ('a', 'b'), (), 13, {
'a': 12,
'b': 1
}),
(('1./(alpha+2*beta)'), ('alpha', 'beta'), (), 0.2, {
'alpha': 1,
'beta': 2
}),
(('pi'), (), (), 3.14159265, {}),
]
for rhs, exp_var, exp_func, exp_res, params in valid_rhses:
e = Expression(rhs)
self.assertEquals(set(e.rhs_names), set(exp_var))
self.assertEquals(set(e.rhs_funcs), set(exp_func))
self.assertAlmostEqual(e.rhs_as_python_func()(**params),
exp_res,
places=4)
import numpy
expr_vars = [
["-A/tau_r", ("A", "tau_r"), ()], ["V*V", ("V", ), ()],
["a*(b*V - U)", ("U", "V", "b", "a"), ()],
[
" 0.04*V*V + 5.0*V + 1. + 140.0 - U + Isyn",
("V", "U", "Isyn"), ()
], ["c", ("c"), ()], ["1", (), ()],
["atan2(sin(x),cos(y))", ("x", "y"), ("atan2", "sin", "cos")],
["1.*V", ("V"), ()], ["1.0", (), ()], [".1", (), ()],
[
"1/(1 + mg_conc*eta*exp(-1*gamma*V))",
("mg_conc", "eta", "gamma", "V"), ('exp', )
],
[
"1 / ( 1 + mg_conc * eta * exp( -1 * gamma*V))",
("mg_conc", "eta", "gamma", "V"), ('exp', )
],
[
"1 / ( 1 + mg_conc * sin(0.5) * exp ( -1 * gamma*V))",
("mg_conc", "gamma", "V"), ('exp', "sin")
],
[
".1 / ( 1.0 + mg_conc * sin(V) * exp ( -1.0 * gamma*V))",
("mg_conc", "gamma", "V"), ('exp', "sin")
], ["sin(w)", ("w"), ("sin", )]
]
namespace = {
"A": 10.0,
"tau_r": 11.0,
"V": -70.0,
"a": 1.2,
"b": 3.0,
"U": -80.0,
"Isyn": 2.0,
"c": 10.0,
"mg_conc": 1.0,
"eta": 2.0,
"gamma": -20.0,
"x": 1.0,
"y": 1.0,
"w": numpy.arange(10)
}
return_values = [
-0.909090909091, 4900.0, -156.0, 69.0, 10.0, 1, 1.0, -70.0, 1.0,
0.1, 1.0, 1.0, 1.0, 0.1,
numpy.sin(namespace['w'])
]
for i, (expr, expt_vars, expt_funcs) in enumerate(expr_vars):
c = Expression(expr)
self.assertEqual(set(c.rhs_names), set(expt_vars))
self.assertEqual(set(c.rhs_funcs), set(expt_funcs))
python_func = c.rhs_as_python_func(namespace=namespace)
param_dict = dict([(v, namespace[v]) for v in expt_vars])
v = return_values[i] - python_func(**param_dict)
self.assertAlmostEqual(numpy.dot(v, v), 0)
