Ticket #9989: trac_9989-operands.take4.patch

module_list.py

@@ -1698 +1698 @@
               depends = ginac_depends,
               libraries = ["pynac", "gmp"]),
     
+    Extension('sage.symbolic.getitem',
+              sources = ['sage/symbolic/getitem.pyx'],
+              language = 'c++',
+              depends = [SAGE_LOCAL + "/include/pynac/ginac.h"],
+              libraries = ["pynac", "gmp"]),
+    
     Extension('sage.symbolic.function',
               sources = ['sage/symbolic/function.pyx'],
               language = 'c++',

sage/symbolic/expression.pyx

@@ -141 +141 @@
 import sage.rings.integer
 import sage.rings.rational
 from sage.structure.element cimport ModuleElement, RingElement, Element
+from sage.symbolic.getitem cimport OperandsWrapper
 from sage.symbolic.function import get_sfunction_from_serial, SymbolicFunction
 from sage.rings.rational import Rational  # Used for sqrt.
 from sage.misc.derivative import multi_derivative
@@ -2474 +2475 @@
             (1+3j)^sqrt(2)
         """
         cdef Expression base, nexp
-        
+
         try:
             # self is an Expression and exp might not be
             base = self
@@ -3779 +3780 @@
             sage: a[:SR(5)]
             [0, 1, 2, 3, 4]
         """
-        return int(self._integer_())   
+        return int(self._integer_())
 
     def iterator(self):
         """
@@ -3816 +3817 @@
                     raise ValueError, "expressions containing only a numeric coefficient, constant or symbol have no operands"
         return new_ExpIter_from_Expression(self)
 
-##     def __getitem__(self, ind):
-##         """
-##         EXAMPLES::
-        
-##             sage: x,y,z = var('x,y,z')
-##             sage: e = x + x*y + z^y + 3*y*z; e
-##             x*y + 3*y*z + z^y + x
-##             sage: e[1]
-##             3*y*z
-##             sage: e[-1]
-##             x
-##             sage: e[1:]
-##             [3*y*z, z^y, x]
-##             sage: e[:2]
-##             [x*y, 3*y*z]
-##             sage: e[-2:]
-##             [z^y, x]
-##             sage: e[:-2]
-##             [x*y, 3*y*z]
-
-##         """
-##         cdef int bind, eind, step, i
-##         cdef int n_ops = self._gobj.nops()
-##         if PY_TYPE_CHECK(ind, slice):
-##             if ind.start:
-##                 bind = ind.start
-##                 if bind != ind.start:
-##                     raise ValueError, "integer index expected"
-##                 if bind < 0:
-##                     bind = n_ops + bind
-##             else:
-##                 bind = 0
-##             if ind.stop:
-##                 eind = ind.stop
-##                 if eind != ind.stop:
-##                     raise ValueError, "integer index expected"
-##                 if eind > n_ops:
-##                     eind = n_ops
-##                 if eind < 0:
-##                     eind = n_ops + eind
-##             else:
-##                 eind = n_ops
-##             if ind.step:
-##                 step = ind.step
-##                 if step != ind.step:
-##                     raise ValueError, "step value must be an integer"
-##             else:
-##                 step = 1
-##             return [new_Expression_from_GEx(self._parent, self._gobj.op(i))
-##                     for i in xrange(bind, eind, step)]
-
-##         try:
-##             bind = ind
-##             if bind != ind:
-##                 raise ValueError, "integer index expected"
-##         except TypeError:
-##             raise TypeError, "index should either be a slice object, or an integer"
-##         if bind < 0:
-##             bind = n_ops + bind
-##         return new_Expression_from_GEx(self._parent, self._gobj.op(bind))
+    property op:
+        def __get__(self):
+            """
+            Provide access to the operands of an expression through a property.
+
+
+            EXAMPLES::
+
+                sage: t = 1+x+x^2
+                sage: t.op
+                Operands of x^2 + x + 1
+                sage: x.op
+                Traceback (most recent call last):
+                ...
+                TypeError: expressions containing only a numeric coefficient, constant or symbol have no operands
+                sage: t.op[0]
+                x^2
+
+            Indexing directly with ``t[1]`` causes problems with numpy types.
+
+                sage: t[1]
+                Traceback (most recent call last):
+                ...
+                TypeError: 'sage.symbolic.expression.Expression' object does not support indexing
+            """
+            if is_a_symbol(self._gobj) or is_a_constant(self._gobj) or \
+                is_a_numeric(self._gobj):
+                    raise TypeError, "expressions containing only a numeric coefficient, constant or symbol have no operands"
+            cdef OperandsWrapper res = OperandsWrapper.__new__(OperandsWrapper)
+            res._expr = self
+            return res
 
     def _numerical_approx(self, prec=None, digits=None):
         """

new file sage/symbolic/getitem.pxd

@@ +1 @@
+include "../libs/ginac/decl.pxi"
+from sage.symbolic.expression cimport Expression
+from sage.structure.sage_object cimport SageObject
+
+cdef class OperandsWrapper(SageObject):
+    cdef Expression _expr

new file sage/symbolic/getitem.pyx

@@ +1 @@
+###############################################################################
+#   Sage: Open Source Mathematical Software
+#       Copyright (C) 2011 Burcin Erocal <burcin@erocal.org>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version.  The full text of the GPL is available at:
+#                  http://www.gnu.org/licenses/
+###############################################################################
+from sage.symbolic.expression cimport new_Expression_from_GEx
+
+cdef inline int normalize_index(object arg, int nops, object err_msg) except -1:
+    """
+    Given an index ``arg`` and the number of operands ``nops`` return
+    an integer between 0 and ``nops`` which will be used as the index to fetch
+    the data from the underlying vector.
+
+    TESTS::
+
+        sage: from sage.symbolic.getitem import normalize_index_for_doctests as normalize_index
+        sage: normalize_index(-1, 4)
+        3
+        sage: normalize_index(1, 4)
+        1
+        sage: normalize_index(1.5, 4)
+        Traceback (most recent call last):
+        ...
+        TypeError: some error message
+        sage: normalize_index(-5, 4)
+        Traceback (most recent call last):
+        ...
+        IndexError: operand index out of range, got -5, expect between -4 and 3
+        sage: normalize_index(5, 4)
+        Traceback (most recent call last):
+        ...
+        IndexError: operand index out of range, got 5, expect between -4 and 3
+    """
+    cdef int i
+    i = arg
+    if i != arg:
+        raise TypeError(err_msg)
+    if i < 0:
+        i = nops + i
+    if i >= nops or i < 0:
+        raise IndexError("operand index out of range, got %s, expect between %s and %s"%(arg,-nops,nops-1))
+    return i
+
+def normalize_index_for_doctests(arg, nops):
+    """
+    Wrapper function to test ``normalize_index``.
+
+    TESTS::
+
+        sage: from sage.symbolic.getitem import normalize_index_for_doctests
+        sage: normalize_index_for_doctests(-1, 4)
+        3
+    """
+    return normalize_index(arg, nops, "some error message")
+
+cdef class OperandsWrapper(SageObject):
+    """
+    Operands wrapper for symbolic expressions.
+
+    EXAMPLES::
+
+        sage: x,y,z = var('x,y,z')
+        sage: e = x + x*y + z^y + 3*y*z; e
+        x*y + 3*y*z + z^y + x
+        sage: e.op[1]
+        3*y*z
+        sage: e.op[1,1]
+        z
+        sage: e.op[-1]
+        x
+        sage: e.op[1:]
+        [3*y*z, z^y, x]
+        sage: e.op[:2]
+        [x*y, 3*y*z]
+        sage: e.op[-2:]
+        [z^y, x]
+        sage: e.op[:-2]
+        [x*y, 3*y*z]
+        sage: e.op[-5]
+        Traceback (most recent call last):
+        ...
+        IndexError: operand index out of range, got -5, expect between -4 and 3
+        sage: e.op[5]
+        Traceback (most recent call last):
+        ...
+        IndexError: operand index out of range, got 5, expect between -4 and 3
+        sage: e.op[1,1,0]
+        Traceback (most recent call last):
+        ...
+        TypeError: expressions containing only a numeric coefficient, constant or symbol have no operands
+        sage: e.op[:1.5]
+        Traceback (most recent call last):
+        ...
+        TypeError: slice indices must be integers or None or have an __index__ method
+        sage: e.op[:2:1.5]
+        Traceback (most recent call last):
+        ...
+        ValueError: step value must be an integer
+    """
+    def __getitem__(self, arg):
+        """
+        TESTS::
+
+           sage: t = 1+x+x^2
+           sage: t.op[1:]
+           [x, 1]
+        """
+        cdef int ind, nops
+        cdef int bind, eind, step
+        cdef GEx cur_ex
+        if isinstance(arg, slice):
+            nops = self._expr._gobj.nops()
+
+            slice_err_msg = "slice indices must be integers or None or have an __index__ method"
+            if arg.start:
+                bind = normalize_index(arg.start, nops, slice_err_msg)
+            else:
+                bind = 0
+            if arg.stop:
+                eind = normalize_index(arg.stop, nops, slice_err_msg)
+            else:
+                eind = nops
+            if arg.step:
+                step = arg.step
+                if step != arg.step:
+                    raise ValueError, "step value must be an integer"
+            else:
+                step = 1
+            return [new_Expression_from_GEx(self._expr._parent,
+                self._expr._gobj.op(ind)) for ind in xrange(bind, eind, step)]
+
+
+        ind_err_msg = "index should either be a slice object, an integer or a list of integers"
+        if isinstance(arg, (list, tuple)):
+            # handle nested index
+            if len(arg) == 0: # or not all(lambda x: x in ZZ for t in args):
+                raise TypeError, ind_err_msg
+            GEx_construct_ex(&cur_ex, self._expr._gobj)
+            for x in arg:
+                nops = cur_ex.nops()
+                if nops == 0:
+                    raise TypeError, "expressions containing only a numeric coefficient, constant or symbol have no operands"
+                ind = normalize_index(x, nops, ind_err_msg)
+                cur_ex = cur_ex.op(ind)
+            return new_Expression_from_GEx(self._expr._parent, cur_ex)
+
+        ind = normalize_index(arg, self._expr._gobj.nops(), ind_err_msg)
+        return new_Expression_from_GEx(self._expr._parent,
+                self._expr._gobj.op(ind))
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: (x^2).op
+            Operands of x^2
+        """
+        return "Operands of %s"%(self._expr)
+
+    def _latex_(self):
+        r"""
+        TESTS::
+
+            sage: latex((x^2).op)
+            \text{Operands wrapper for expression }x^{2}
+        """
+        return r"\text{Operands wrapper for expression }%s"%(self._expr._latex_())
+
+    def __reduce__(self):
+        """
+        TESTS::
+
+            sage: (x^2).op.__reduce__()
+            (<built-in function restore_op_wrapper>, (x^2,))
+            sage: loads(dumps((x^2).op))
+            Operands of x^2
+        """
+        return restore_op_wrapper, (self._expr,)
+
+def restore_op_wrapper(expr):
+    """
+    TESTS::
+
+        sage: from sage.symbolic.getitem import restore_op_wrapper
+        sage: restore_op_wrapper(x^2)
+        Operands of x^2
+    """
+    return expr.op