diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/equation/literals/operators.py

@@ -0,0 +1,380 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Operator classes.
+
+Operators are combined with other Literals to create an equation.
+Operators are non-leaf nodes on a Literal tree. These trees can be
+evaluated by the Evaluator visitor, or otherwise inspected.
+
+The Operator class contains all the information necessary to be
+identified and evaluated by a Visitor. Thus, a single onOperator method
+exists in the Visitor base class. Other Operators can be derived from
+Operator (see AdditionOperator), but they all identify themselves with
+the Visitor.onOperator method.
+"""
+
+__all__ = [
+    "Operator",
+    "AdditionOperator",
+    "SubtractionOperator",
+    "MultiplicationOperator",
+    "DivisionOperator",
+    "ExponentiationOperator",
+    "RemainderOperator",
+    "NegationOperator",
+    "ConvolutionOperator",
+    "SumOperator",
+    "UFuncOperator",
+    "ArrayOperator",
+    "PolyvalOperator",
+]
+
+import numpy
+
+from diffpy.srfit.equation.literals.abcs import OperatorABC
+from diffpy.srfit.equation.literals.literal import Literal
+
+
+class Operator(Literal, OperatorABC):
+    """Abstract class for specifying a general operator.
+
+    This class provides several methods that are common to a derived
+    classes for concrete operations.
+
+    Class Attributes
+    ----------------
+    nin : int, abstract
+        Number of input arguments for the operator.  Any number of
+        arguments is allowed when -1.  This attribute must be defined
+        in a derived class.
+    nout : int, abstract
+        Number of outputs returned by the `operation`.  This attribute
+        must be defined in a derived class.
+    operation : callable, abstract
+        Function that performs the operation, e.g., `numpy.add`.
+        This must be defined in a derived class.
+    symbol : str, abstract
+        The symbolic representation for the operator such as
+        "+" or "sin".  This attribute must be defined in a derived
+        class.
+
+    Attributes
+    ----------
+    args : list
+        The list of `Literal` arguments.  Read-only, use the
+        `addLiteral` method to change its content.
+    """
+
+    # Private Attributes
+    # ------------------
+    # _value : float, numpy.ndarray or None
+    #     The last value of the operator or None.
+
+    # We must declare the abstract `args` here.
+    args = None
+    # default for the value
+    _value = None
+
+    def __init__(self, name=None):
+        """Initialize the operator object with the specified name.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name for the operator object.  When not specified,
+            use the class attribute `name`.
+        """
+        Literal.__init__(self, name)
+        self.args = []
+        return
+
+    def identify(self, visitor):
+        """Identify self to a visitor."""
+        return visitor.onOperator(self)
+
+    def addLiteral(self, literal):
+        """Add a literal to this operator.
+
+        Note that order of operation matters. The first literal added is
+        the leftmost argument. The last is the rightmost.
+
+        Raises ValueError if the literal causes a self-reference.
+        """
+        # Make sure we don't have self-reference
+        self._loopCheck(literal)
+        self.args.append(literal)
+        literal.addObserver(self._flush)
+        self._flush(other=(self,))
+        return
+
+    def getValue(self):
+        """Get or evaluate the value of the operator."""
+        if self._value is None:
+            vals = [arg.value for arg in self.args]
+            self._value = self.operation(*vals)
+        return self._value
+
+    value = property(lambda self: self.getValue())
+
+    def _loopCheck(self, literal):
+        """Check if a literal causes self-reference."""
+        if literal is self:
+            raise ValueError("'%s' causes self-reference" % literal)
+
+        # Check to see if I am a dependency of the literal.
+        if hasattr(literal, "args"):
+            for lit_arg in literal.args:
+                self._loopCheck(lit_arg)
+        return
+
+
+class UnaryOperator(Operator):
+    """Abstract class for an unary operator with one input and one result.
+
+    This base class defines the `nin` and `nout` attributes.  The derived
+    concrete operator must provide the remaining abstract attributes
+    of the `Operator` class.
+    """
+
+    nin = 1
+    nout = 1
+    pass
+
+
+class BinaryOperator(Operator):
+    """Abstract class for a binary operator with two inputs and one result.
+
+    This base class defines the `nin` and `nout` attributes.  The derived
+    concrete operator must define the remaining abstract attributes
+    of the `Operator` class.
+    """
+
+    nin = 2
+    nout = 1
+    pass
+
+
+class CustomOperator(Operator):
+    """Concrete class for a user-defined Operator.
+
+    Use the `makeOperator` factory function to create an instance.
+    """
+
+    # declare all abstract attributes from the Operator base.
+    nin = None
+    nout = None
+    operation = None
+    symbol = None
+    pass
+
+
+def makeOperator(name, symbol, operation, nin, nout):
+    """Return a new custom operator object.
+
+    Parameters
+    ----------
+    name : str
+        Name of the custom operator object.
+    symbol : str
+        The symbolic representation for the operator such as
+        "+" or "sin".
+    operation : callable
+        Function that performs the operation, e.g., `numpy.add`.
+    nin : int
+        Number of input arguments for the operator.  Any number of
+        arguments is allowed when -1.
+    nout : in
+        Number of outputs returned by the `operation`.
+
+    Returns
+    -------
+    CustomOperator
+        The new custom operator object.
+    """
+    op = CustomOperator(name=name)
+    op.symbol = symbol
+    op.operation = operation
+    op.nin = nin
+    op.nout = nout
+    return op
+
+
+# Some specified operators
+
+
+class AdditionOperator(BinaryOperator):
+    """Addition operator."""
+
+    name = "add"
+    symbol = "+"
+    operation = staticmethod(numpy.add)
+    pass
+
+
+class SubtractionOperator(BinaryOperator):
+    """Subtraction operator."""
+
+    name = "subtract"
+    symbol = "-"
+    operation = staticmethod(numpy.subtract)
+    pass
+
+
+class MultiplicationOperator(BinaryOperator):
+    """Multiplication operator."""
+
+    name = "multiply"
+    symbol = "*"
+    operation = staticmethod(numpy.multiply)
+    pass
+
+
+class DivisionOperator(BinaryOperator):
+    """Division operator."""
+
+    name = "divide"
+    symbol = "/"
+    operation = staticmethod(numpy.divide)
+    pass
+
+
+class ExponentiationOperator(BinaryOperator):
+    """Exponentiation operator."""
+
+    name = "power"
+    symbol = "**"
+    operation = staticmethod(numpy.power)
+    pass
+
+
+class RemainderOperator(BinaryOperator):
+    """Remainder operator."""
+
+    name = "mod"
+    symbol = "%"
+    operation = staticmethod(numpy.mod)
+    pass
+
+
+class NegationOperator(UnaryOperator):
+    """Negation operator."""
+
+    name = "negative"
+    symbol = "-"
+    operation = staticmethod(numpy.negative)
+    pass
+
+
+def _conv(v1, v2):
+    # Get the full convolution
+    c = numpy.convolve(v1, v2, mode="full")
+    # Find the centroid of the first signal
+    s1 = sum(v1)
+    x1 = numpy.arange(len(v1), dtype=float)
+    c1idx = numpy.sum(v1 * x1) / s1
+    # Find the centroid of the convolution
+    xc = numpy.arange(len(c), dtype=float)
+    ccidx = numpy.sum(c * xc) / sum(c)
+    # Interpolate the convolution such that the centroids line up. This
+    # uses linear interpolation.
+    shift = ccidx - c1idx
+    x1 += shift
+    c = numpy.interp(x1, xc, c)
+
+    # Normalize
+    sc = sum(c)
+    if sc > 0:
+        c *= s1 / sc
+
+    return c
+
+
+class ConvolutionOperator(BinaryOperator):
+    """Convolve two signals.
+
+    This convolves two signals such that centroid of the first array is
+    not altered by the convolution. Furthermore, the integrated
+    amplitude of the convolution is scaled to be that of the first
+    signal. This is mean to act as a convolution of a signal by a
+    probability distribution.
+
+    Note that this is only possible when the signals are computed over
+    the same range.
+    """
+
+    name = "convolve"
+    symbol = "convolve"
+    operation = staticmethod(_conv)
+    pass
+
+
+class SumOperator(UnaryOperator):
+    """numpy.sum operator."""
+
+    name = "sum"
+    symbol = "sum"
+    operation = staticmethod(numpy.sum)
+
+
+class UFuncOperator(Operator):
+    """A operator wrapper around a numpy ufunc.
+
+    The name and symbol attributes are set equal to the ufunc.__name__
+    attribute. nin and nout are also taken from the ufunc.
+    """
+
+    symbol = None
+    nin = None
+    nout = None
+    operation = None
+
+    def __init__(self, op):
+        """Initialization.
+
+        Arguments
+
+        op  --  A numpy ufunc
+        """
+        Operator.__init__(self, name=op.__name__)
+        self.symbol = op.__name__
+        self.nin = op.nin
+        self.nout = op.nout
+        self.operation = op
+        return
+
+
+class ArrayOperator(Operator):
+    """Operator that will take parameters and turn them into an array."""
+
+    name = "array"
+    symbol = "array"
+    nin = -1
+    nout = 1
+
+    @staticmethod
+    def operation(*args):
+        return numpy.array(args)
+
+
+class PolyvalOperator(BinaryOperator):
+    """Operator for numpy polyval."""
+
+    name = "polyval"
+    symbol = "polyval"
+    operation = staticmethod(numpy.polyval)
+    pass
+
+
+# End of file

diffpy/srfit/equation/visitors/__init__.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Visitors that perform on Literal networks.
+
+Visitors are designed to traverse and extract information from Literal
+networks (diffpy.srfit.equation.literals). Visitors are used to
+validate, print and extracting Arguments from Literal networks.
+
+The Literal-Visitor relationship is that described by the Visitor
+pattern (
+
+http://en.wikipedia.org/wiki/Visitor_pattern).
+"""
+
+from __future__ import print_function
+
+from diffpy.srfit.equation.visitors.argfinder import ArgFinder
+from diffpy.srfit.equation.visitors.printer import Printer
+from diffpy.srfit.equation.visitors.swapper import Swapper
+from diffpy.srfit.equation.visitors.validator import Validator
+
+
+def getArgs(literal, getconsts=True):
+    """Get the Arguments of a Literal tree.
+
+    getconsts   --  If True (default), then Arguments designated as constant
+                    are also retrieved.
+
+    Returns a list of Arguments searched for depth-first.
+    """
+    v = ArgFinder(getconsts)
+    return literal.identify(v)
+
+
+def getExpression(literal, eqskip=None):
+    """Get math expression string from the Literal tree object.
+
+    eqskip  --  regular expression pattern for Equation objects that should
+                be printed under their own name.  Expand all Equation objects
+                when None.
+
+    Return string.
+    """
+    v = Printer()
+    v.eqskip = eqskip
+    rv = literal.identify(v)
+    return rv
+
+
+def prettyPrint(literal):
+    """Print a Literal tree."""
+    print(getExpression(literal))
+    return
+
+
+def validate(literal):
+    """Validate a Literal tree.
+
+    Raises ValueError if the tree contains errors.
+    """
+    v = Validator()
+    errors = literal.identify(v)
+    if errors:
+        m = "Errors found in Literal tree '%s'\n" % literal
+        m += "\n".join(errors)
+        raise ValueError(m)
+    return
+
+
+def swap(literal, oldlit, newlit):
+    """Swap one literal for another in a Literal tree.
+
+    Corrections are done in-place unless literal is oldlit, in which
+    case the return value is newlit.
+
+    Returns the literal tree with oldlit swapped for newlit.
+    """
+    if literal is oldlit:
+        return newlit
+    v = Swapper(oldlit, newlit)
+    literal.identify(v)
+    return literal

diffpy/srfit/equation/visitors/argfinder.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Visitor for extracting the Argument entries in a Literal tree.
+
+ArgFinder extracts all Arguments from a literal true.
+"""
+
+__all__ = ["ArgFinder"]
+
+from diffpy.srfit.equation.visitors.visitor import Visitor
+
+
+class ArgFinder(Visitor):
+    """ArgFinder extracts Arguments from a Literal tree.
+
+    Attributes
+    args    --  The list of collected Arguments
+    getconsts  --  Flag indicating whether to grab constant arguments.
+    """
+
+    def __init__(self, getconsts=True):
+        """Initialize.
+
+        Arguments
+        getconsts   --  Flag indicating whether to parse constant arguments
+                        (default True).
+        """
+        self.args = []
+        self.getconsts = getconsts
+        return
+
+    def reset(self):
+        """Reset the argument set."""
+        self.args = []
+        return
+
+    def onArgument(self, arg):
+        """Process an Argument node."""
+        if self.getconsts or not arg.const:
+            self.args.append(arg)
+        return self.args
+
+    def onOperator(self, op):
+        """Process an Operator node."""
+        for arg in op.args:
+            arg.identify(self)
+        return self.args
+
+
+# End of file

diffpy/srfit/equation/visitors/printer.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Printer visitor for printing the equation represented by a Literal tree.
+
+The Printer visitor creates a one-line representation of the Literal
+tree, which is valid as a string equivalent of the equation.
+"""
+
+__all__ = ["Printer"]
+
+import re
+
+from diffpy.srfit.equation.visitors.visitor import Visitor
+
+
+class Printer(Visitor):
+    """Printer for printing a Literal tree.
+
+    Attributes:
+
+    eqskip  --  regular expression pattern for Equation objects that should
+                not be expanded, but printed under their own name.  Expand
+                all equations when None.
+    output  --  The output generated by the printer.
+    """
+
+    # store compiled RE pattern for eqskip or None when none.
+    _eqpat = None
+
+    def __init__(self):
+        """Initialize."""
+        self.reset()
+        return
+
+    def reset(self):
+        """Reset the out put string."""
+        self.output = ""
+        return
+
+    @property
+    def eqskip(self):
+        """Pattern for equation objects to be skipped.
+
+        Expand all equations when None.
+        """
+        rv = None
+        if self._eqpat is not None:
+            rv = self._eqpat.pattern
+        return rv
+
+    @eqskip.setter
+    def eqskip(self, value):
+        if value is None:
+            self._eqpat = None
+        else:
+            self._eqpat = re.compile(value)
+        return
+
+    def onArgument(self, arg):
+        """Process an Argument node.
+
+        No assumption is made about the argument type.
+        """
+        if arg.name is None:
+            self.output += str(arg.value)
+        else:
+            self.output += str(arg.name)
+        return self.output
+
+    def onOperator(self, op):
+        """Process an Operator node."""
+        # We have to deal with infix operators
+        if op.name != op.symbol and op.nin == 2:
+            self._onInfix(op)
+            return self.output
+
+        self.output += str(op.name) + "("
+
+        for idx, literal in enumerate(op.args):
+            if idx != 0:
+                self.output += ", "
+            literal.identify(self)
+
+        self.output += ")"
+        return self.output
+
+    def onEquation(self, eq):
+        """Process an Equation node."""
+        skipthis = (
+            self._eqpat is not None and eq.name and self._eqpat.match(eq.name)
+        )
+        if skipthis:
+            self.onArgument(eq)
+        else:
+            eq.root.identify(self)
+        return self.output
+
+    def _onInfix(self, op):
+        """Process infix operators."""
+        self.output += "("
+        op.args[0].identify(self)
+        self.output += " %s " % op.symbol
+        op.args[1].identify(self)
+        self.output += ")"
+        return
+
+
+# End of file