def testValue(self):
"""Make sure the convolution operator is working properly."""
import numpy
pi = numpy.pi
exp = numpy.exp
x = numpy.linspace(0, 10, 1000)
mu1 = 4.5
sig1 = 0.1
mu2 = 2.5
sig2 = 0.4
g1 = exp(-0.5 * ((x - mu1) / sig1)**2)
a1 = literals.Argument(name="g1", value=g1)
g2 = exp(-0.5 * ((x - mu2) / sig2)**2)
a2 = literals.Argument(name="g2", value=g2)
op = literals.ConvolutionOperator()
op.addLiteral(a1)
op.addLiteral(a2)
g3c = op.value
mu3 = mu1
sig3 = (sig1**2 + sig2**2)**0.5
g3 = exp(-0.5 * ((x - mu3) / sig3)**2)
g3 *= sum(g1) / sum(g3)
self.assertAlmostEquals(sum(g3c), sum(g3))
self.assertAlmostEquals(0, sum((g3 - g3c)**2))
return
def testAddLiteral(self):
"""Test adding a literal to an operator node."""
op = literals.Operator(name="add",
symbol="+",
operation=numpy.add,
nin=2,
nout=1)
self.assertRaises(ValueError, op.getValue)
op._value = 1
self.assertEqual(op.getValue(), 1)
# Test addition and operations
a = literals.Argument(name="a", value=0)
b = literals.Argument(name="b", value=0)
op.addLiteral(a)
self.assertRaises(ValueError, op.getValue)
op.addLiteral(b)
self.assertAlmostEqual(0, op.value)
a.setValue(1)
b.setValue(2)
self.assertAlmostEqual(3, op.value)
a.setValue(None)
# Test for self-references
# Try to add self
op = literals.Operator(name="add",
symbol="+",
operation=numpy.add,
nin=2,
nout=1)
op.addLiteral(a)
self.assertRaises(ValueError, op.addLiteral, op)
# Try to add argument that contains self
op2 = literals.Operator(name="sub",
symbol="-",
operation=numpy.subtract,
nin=2,
nout=1)
op2.addLiteral(op)
self.assertRaises(ValueError, op.addLiteral, op2)
return
def testInit(self):
"""Test that everthing initializes as expected."""
a = literals.Argument()
self.assertEqual(None, a._value)
self.assertTrue(False is a.const)
self.assertTrue(None is a.name)
return
def __evalBinary(self, other, OperatorClass, onleft=True):
"""Evaluate a binary function.
Other can be an BaseBuilder or a constant.
onleft -- Indicates that the operator was passed on the left side
(defualt True).
"""
# Create the Operator
op = OperatorClass()
# onleft takes care of non-commutative operators, and assures that the
# ordering is perserved.
if onleft:
# Add the literals to the operator
op.addLiteral(self.literal)
# Deal with constants
if not isinstance(other, BaseBuilder):
literal = literals.Argument(value=other, const=True)
else:
literal = other.literal
op.addLiteral(literal)
if not onleft:
# Add the literals to the operator
op.addLiteral(self.literal)
# Create a new OperatorBuilder for the Operator
opbuilder = OperatorBuilder(op.name)
opbuilder.literal = op
return opbuilder
def registerConstant(self, name, value):
"""Register a named constant with the factory.
Returns the registered builder.
"""
arg = literals.Argument(name=name, value=value, const=True)
return self.registerArgument(name, arg)
def makeEquation(self,
eqstr,
buildargs=True,
argclass=literals.Argument,
argkw={}):
"""Make an equation from an equation string.
Arguments
eqstr -- An equation in string form using standard python
syntax. The equation string can use any function
registered literal or function, including numpy ufuncs
that are automatically registered.
buildargs -- A flag indicating whether missing arguments can be
created by the Factory (default True). If False, then
the a ValueError will be raised if there are undefined
arguments in the eqstr. Built arguments will be of type
argclass.
argclass -- Class to use when creating new Arguments (default
diffpy.srfit.equation.literals.Argument). The class
constructor must accept the 'name' key word.
argkw -- Key word dictionary to pass to the argclass constructor
(default {}).
Returns a callable Literal representing the equation string.
"""
self._prepareBuilders(eqstr, buildargs, argclass, argkw)
beq = eval(eqstr, {}, self.builders)
# handle scalar numbers or numpy arrays
if isinstance(beq, (numbers.Number, numpy.ndarray)):
lit = literals.Argument(value=beq, const=True)
eq = Equation(name='', root=lit)
else:
eq = beq.getEquation()
self.equations.add(eq)
return eq
def test_value(self):
"""Check ArrayOperator.value.
"""
x = literals.Argument('x', 1.0)
y = literals.Argument('y', 2.0)
z = literals.Argument('z', 3.0)
# check empty array
op = literals.ArrayOperator()
self.assertEqual(0, len(op.value))
self.assertTrue(isinstance(op.value, numpy.ndarray))
# check behavior with 2 arguments
op.addLiteral(x)
self.assertTrue(numpy.array_equal([1], op.value))
op.addLiteral(y)
op.addLiteral(z)
self.assertTrue(numpy.array_equal([1, 2, 3], op.value))
z.value = 7
self.assertTrue(numpy.array_equal([1, 2, 7], op.value))
return
def testValue(self):
"""Test value."""
# Test addition and operations
op = literals.Operator(symbol="+", operation=numpy.add, nin=2)
a = literals.Argument(value=0)
b = literals.Argument(value=0)
op.addLiteral(a)
op.addLiteral(b)
self.assertAlmostEquals(0, op.value)
# Test update from the nodes
a.setValue(4)
self.assertTrue(op._value is None)
self.assertAlmostEqual(4, op.value)
self.assertAlmostEqual(4, op.getValue())
b.value = 2
self.assertTrue(op._value is None)
self.assertAlmostEqual(6, op.value)
return
def testValue(self):
"""Test value setting."""
a = literals.Argument()
self.assertEquals(None, a.getValue())
# Test setting value
a.setValue(3.14)
self.assertAlmostEqual(3.14, a._value)
a.setValue(3.14)
self.assertAlmostEqual(3.14, a.value)
self.assertAlmostEqual(3.14, a.getValue())
return
def wipeout(self, eq):
"""Invalidate the specified equation and remove it from the factory.
This will remove the equation from the purview of the factory and
also change its formula to return NaN. This ensures that eq does
not observe any object in the factory and thus prevents its indirect
pickling with the factory because of observer callback function.
No return value.
"""
if eq is None:
assert eq not in self.equations
return
self.equations.discard(eq)
# invalidate this equation to clean up any observer relations of
# objects in the factory towards its literals tree.
nan = literals.Argument('nan', value=numpy.nan, const=True)
eq.setRoot(nan)
return
def __init__(self, value=None, name=None, const=False, arg=None):
"""Create an ArgumentBuilder instance, containing a new Argument.
Arguments
value -- The value of the wrapped Argument (float, default None)
name -- The name of the wrapped Argument (string, default None)
const -- Flag indicating whether the Argument is constant (bool,
default False)
arg -- A pre-defined Argument to use. If this is None (default),
then a new Argument will be created from value, name and
const.
"""
BaseBuilder.__init__(self)
if arg is None:
self.literal = literals.Argument(value=value,
name=name,
const=const)
else:
self.literal = arg
return
def _makeArgs(num):
args = []
for i in xrange(num):
j=i+1
args.append(literals.Argument(name="v%i"%j, value=j))
return args
def testIdentity(self):
"""Make sure an Argument is an Argument."""
a = literals.Argument()
self.assertTrue(abcs.issubclass(literals.Argument, abcs.ArgumentABC))
self.assertTrue(abcs.isinstance(a, abcs.ArgumentABC))
return
