cone/nonnegative_orthant.py: add "lattice" argument.

[sage.d.git] / mjo / cone / doubly_nonnegative.py

diff --git a/mjo/cone/doubly_nonnegative.py b/mjo/cone/doubly_nonnegative.py
index 56a655e52c5cd60cbf1073c351e65833e5f54500..92184d15c4133e33f04e877352787378ae3739df 100644 (file)
--- a/mjo/cone/doubly_nonnegative.py
+++ b/mjo/cone/doubly_nonnegative.py
@@ -13,12 +13,6 @@ It is represented typically by either `\mathcal{D}^{n}` or
 
 from sage.all import *
 
-# Sage doesn't load ~/.sage/init.sage during testing (sage -t), so we
-# have to explicitly mangle our sitedir here so that our module names
-# resolve.
-from os.path import abspath
-from site import addsitedir
-addsitedir(abspath('../../'))
 from mjo.cone.symmetric_psd import factor_psd, is_symmetric_psd, random_psd
 from mjo.matrix_vector import isomorphism
 
@@ -36,6 +30,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::
@@ -58,7 +56,7 @@ def is_doubly_nonnegative(A):
         raise ValueError.new(msg)
 
     # Check that all of the entries of ``A`` are nonnegative.
-    if not all([ a >= 0 for a in A.list() ]):
+    if not all( a >= 0 for a in A.list() ):
         return False
 
     # It's nonnegative, so all we need to do is check that it's
@@ -85,6 +83,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 +152,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 +202,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 +221,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 +263,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 +282,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::
@@ -355,11 +369,11 @@ def is_extreme_doubly_nonnegative(A):
     # whenever we come across an index pair `$(i,j)$` with
     # `$A_{ij} = 0$`.
     spanning_set = []
-    for j in range(0, A.ncols()):
-        for i in range(0,j):
+    for j in xrange(A.ncols()):
+        for i in xrange(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 +419,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::
@@ -441,7 +460,7 @@ def random_doubly_nonnegative(V, accept_zero=True, rank=None):
     # one of them is nonnegative, then return that.
     A = random_psd(V, accept_zero, rank)
 
-    while not all([ x >= 0 for x in A.list() ]):
+    while not all( x >= 0 for x in A.list() ):
         A = random_psd(V, accept_zero, rank)
 
     return A
@@ -475,6 +494,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::