mjo/cone/doubly_nonnegative.py: fix tests with PYTHONPATH="."

diff --git a/mjo/cone/doubly_nonnegative.py b/mjo/cone/doubly_nonnegative.py
index 56a655e52c5cd60cbf1073c351e65833e5f54500..7d39061d21dae6e2f9795cc63ccffe91c220cd0a 100644 (file)
--- a/mjo/cone/doubly_nonnegative.py
+++ b/mjo/cone/doubly_nonnegative.py
@@ -36,6 +36,10 @@ def is_doubly_nonnegative(A):
     Either ``True`` if ``A`` is doubly-nonnegative, or ``False``
     otherwise.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import is_doubly_nonnegative
+
     EXAMPLES:
 
     Every completely positive matrix is doubly-nonnegative::
@@ -85,6 +89,10 @@ def is_admissible_extreme_rank(r, n):
     the doubly-nonnegative cone in `$\mathbb{R}^{n}$`, or ``False``
     otherwise.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import is_admissible_extreme_rank
+
     EXAMPLES:
 
     For dimension 5, only ranks zero, one, and three are admissible::
@@ -150,6 +158,10 @@ def has_admissible_extreme_rank(A):
     26 (1996), no. 4, 1371--1383. doi:10.1216/rmjm/1181071993.
     http://projecteuclid.org/euclid.rmjm/1181071993.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import has_admissible_extreme_rank
+
     EXAMPLES:
 
     The zero matrix has rank zero, which is admissible::
@@ -196,7 +208,7 @@ def has_admissible_extreme_rank(A):
     return is_admissible_extreme_rank(r,n)
 
 
-def E(matrix_space, i,j):
+def stdE(matrix_space, i,j):
     """
     Return the ``i``,``j``th element of the standard basis in
     ``matrix_space``.
@@ -215,26 +227,30 @@ def E(matrix_space, i,j):
     A basis element of ``matrix_space``. It has a single \"1\" in the
     ``i``,``j`` row,column and zeros elsewhere.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import stdE
+
     EXAMPLES::
 
         sage: M = MatrixSpace(ZZ, 2, 2)
-        sage: E(M,0,0)
+        sage: stdE(M,0,0)
         [1 0]
         [0 0]
-        sage: E(M,0,1)
+        sage: stdE(M,0,1)
         [0 1]
         [0 0]
-        sage: E(M,1,0)
+        sage: stdE(M,1,0)
         [0 0]
         [1 0]
-        sage: E(M,1,1)
+        sage: stdE(M,1,1)
         [0 0]
         [0 1]
-        sage: E(M,2,1)
+        sage: stdE(M,2,1)
         Traceback (most recent call last):
         ...
         IndexError: Index `i` is out of bounds.
-        sage: E(M,1,2)
+        sage: stdE(M,1,2)
         Traceback (most recent call last):
         ...
         IndexError: Index `j` is out of bounds.
@@ -253,7 +269,7 @@ def E(matrix_space, i,j):
     # would be computed as offset 3 into a four-element list and we
     # would succeed incorrectly.
     idx = matrix_space.ncols()*i + j
-    return matrix_space.basis()[idx]
+    return list(matrix_space.basis())[idx]
 
 
 
@@ -272,6 +288,10 @@ def is_extreme_doubly_nonnegative(A):
     2. Berman, Abraham and Shaked-Monderer, Naomi. Completely Positive
        Matrices. World Scientific, 2003.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import is_extreme_doubly_nonnegative
+
     EXAMPLES:
 
     The zero matrix is an extreme matrix::
@@ -359,7 +379,7 @@ def is_extreme_doubly_nonnegative(A):
         for i in range(0,j):
             if A[i,j] == 0:
                 M = A.matrix_space()
-                S = X.transpose() * (E(M,i,j) + E(M,j,i)) * X
+                S = X.transpose() * (stdE(M,i,j) + stdE(M,j,i)) * X
                 spanning_set.append(S)
 
     # The spanning set that we have at this point is of matrices.  We
@@ -405,6 +425,11 @@ def random_doubly_nonnegative(V, accept_zero=True, rank=None):
     A random doubly nonnegative matrix, i.e. a linear transformation
     from ``V`` to itself.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import (is_doubly_nonnegative,
+        ....:                                          random_doubly_nonnegative)
+
     EXAMPLES:
 
     Well, it doesn't crash at least::
@@ -475,6 +500,11 @@ def random_extreme_doubly_nonnegative(V, accept_zero=True, rank=None):
     A random extreme doubly nonnegative matrix, i.e. a linear
     transformation from ``V`` to itself.
 
+    SETUP::
+
+        sage: from mjo.cone.doubly_nonnegative import (is_extreme_doubly_nonnegative,
+        ....:                                          random_extreme_doubly_nonnegative)
+
     EXAMPLES:
 
     Well, it doesn't crash at least::