Exemplo n.º 1
0
 def setUp(self):
     self.m = Matrix(5)
     # Pull the matrix out of the docstring for the class. I'm lazy.
     rows = [x.strip() for x in self.__doc__.split('\n')]
     rows = [x for x in rows if x[0] == '|']
     rows = [[float(x) for x in y.strip('|').split()] for y in rows]
     for i in xrange(len(rows)):
         self.m.set_row(i, rows[i])
Exemplo n.º 2
0
 def __init__(self, a_link_matrix, unreachable_distance=None):
     self._matrix = Matrix(len(a_link_matrix))
     if unreachable_distance is None:
         unreachable_distance = len(a_link_matrix)
     self._unreachable = unreachable_distance
     logging.log(ULTRADEBUG, "Getting C versions of the matrices.")
     transposed = a_link_matrix.transpose()
     transposed_c = transposed.as_binary_c_matrix()
     c_link_matrix = a_link_matrix.as_binary_c_matrix()
     to_fill_in = self._matrix.as_binary_c_matrix()
     logging.log(ULTRADEBUG, "Going into C to perform the search.")
     DISTLIB.fill_distance_matrix(byref(to_fill_in), byref(c_link_matrix),
                                  byref(transposed_c), len(a_link_matrix),
                                  self._unreachable)
     logging.log(ULTRADEBUG, "Back from C. Filling the matrix in.")
     self._matrix.fill_from_c_matrix(to_fill_in)
     self._converted_distance = None
Exemplo n.º 3
0
 def setUp(self):
     self.m=Matrix(5)
     # Pull the matrix out of the docstring for the class. I'm lazy.
     rows=[x.strip() for x in self.__doc__.split('\n')]
     rows=[x for x in rows if x[0]=='|']
     rows=[[float(x) for x in y.strip('|').split()] for y in rows]
     for i in xrange(len(rows)):
         self.m.set_row(i, rows[i])
Exemplo n.º 4
0
 def __init__(self, a_link_matrix, unreachable_distance=None):
     self._matrix=Matrix(len(a_link_matrix))
     if unreachable_distance is None:
         unreachable_distance=len(a_link_matrix)
     self._unreachable=unreachable_distance
     logging.log(ULTRADEBUG, "Getting C versions of the matrices.")
     transposed=a_link_matrix.transpose()
     transposed_c=transposed.as_binary_c_matrix()
     c_link_matrix=a_link_matrix.as_binary_c_matrix()
     to_fill_in=self._matrix.as_binary_c_matrix()
     logging.log(ULTRADEBUG, "Going into C to perform the search.")
     DISTLIB.fill_distance_matrix(byref(to_fill_in), byref(c_link_matrix), 
                                  byref(transposed_c), len(a_link_matrix),
                                  self._unreachable)
     logging.log(ULTRADEBUG, "Back from C. Filling the matrix in.")
     self._matrix.fill_from_c_matrix(to_fill_in)
     self._converted_distance=None
Exemplo n.º 5
0
class DistanceMatrix(object):
    """Represents a distance matrix, in which each C[i, j] encodes the 
    distance from i to j in a graph.
    Pass the value you plan on using as an unreachable distance to the 
    constructor. If you omit it, it will default to the link matrix's size
    (reasonable in most cases).
    
    The distance matrix is meant to compute stats on, so it's immutable by
    design.
    """
    def __init__(self, a_link_matrix, unreachable_distance=None):
        self._matrix = Matrix(len(a_link_matrix))
        if unreachable_distance is None:
            unreachable_distance = len(a_link_matrix)
        self._unreachable = unreachable_distance
        logging.log(ULTRADEBUG, "Getting C versions of the matrices.")
        transposed = a_link_matrix.transpose()
        transposed_c = transposed.as_binary_c_matrix()
        c_link_matrix = a_link_matrix.as_binary_c_matrix()
        to_fill_in = self._matrix.as_binary_c_matrix()
        logging.log(ULTRADEBUG, "Going into C to perform the search.")
        DISTLIB.fill_distance_matrix(byref(to_fill_in), byref(c_link_matrix),
                                     byref(transposed_c), len(a_link_matrix),
                                     self._unreachable)
        logging.log(ULTRADEBUG, "Back from C. Filling the matrix in.")
        self._matrix.fill_from_c_matrix(to_fill_in)
        self._converted_distance = None

    def __getitem__(self, key):
        return self._matrix[key]

    def __len__(self):
        return len(self._matrix)

    def out_distance(self, i):
        """The out-distance of a term i."""
        return self._matrix.rowsum(i)

    def in_distance(self, j):
        """The in-distance of a term j."""
        return self._matrix.colsum(j)

    def compute_converted_distance(self):
        """Calculate the converted distance, for the internal use of other 
        functions."""
        total = 0.0
        for i in xrange(len(self)):
            total += self.out_distance(i)
        self._converted_distance = total

    def relative_out_centrality(self, i):
        """Computes relative out centrality."""
        if self._converted_distance is None:
            self.compute_converted_distance()
        return self._converted_distance / float(self.out_distance(i))

    def relative_in_centrality(self, j):
        """Computes relative in centrality."""
        if self._converted_distance is None:
            self.compute_converted_distance()
        return self._converted_distance / float(self.in_distance(j))

    def max_centrality_norm_factor(self):
        """The normalization factor corresponding to the maximal centrality. 
        Used in the compactness calculation"""
        return float(len(self)**2 - len(self)) * self._unreachable

    def min_centrality_norm_factor(self):
        """The normalization factor corresponding to the minimal centrality. 
        Used in the compactness calculation"""
        return float(len(self)**2 - len(self))

    def compactness(self):
        "Measures how connected the graph is"
        if self._converted_distance is None:
            self.compute_converted_distance()
        return (self.max_centrality_norm_factor()-self._converted_distance) \
                /(self.max_centrality_norm_factor()-
                    self.min_centrality_norm_factor())

    def stratum(self):
        "Measures the linearity of the graph"
        lap=(len(self)**3)/4.0 if len(self)%2==0 \
                               else (len(self)**3-len(self))/4.0
        total = 0.0
        for i in xrange(len(self)):
            # We can't use the regular implementations, because we must
            # invalidate the unconnected nodes.
            status = 0.0
            contrastatus = 0.0
            for j in xrange(len(self)):
                rowval = self._matrix[i, j]
                colval = self._matrix[j, i]
                status += 0.0 if rowval == self._unreachable else rowval
                contrastatus += 0.0 if colval == self._unreachable else colval
            total += abs(status - contrastatus)
        return total / lap
Exemplo n.º 6
0
 def transpose(self):
     # Needs a special transpose operation because it must return a
     # LinkMatrix
     return Matrix.transpose(self, LinkMatrix)
Exemplo n.º 7
0
 def __init__(self, matrix_size):
     Matrix.__init__(self, matrix_size)
Exemplo n.º 8
0
class test_base_matrix(unittest.TestCase):
    """The default matrix is a 5x5 matrix with the following setup:
    |  1.0  0.0  1.0 -1.0  2.5 |
    |  0.0  3.1  0.1  0.0 -7.9 |
    | -9.8  1.1  6.7  2.2 -4.0 |
    | 19.3  1.1  1.1  4.5 -9.9 |
    |  2.7  0.1  0.1 -3.0  1.0 |"""
    def setUp(self):
        self.m=Matrix(5)
        # Pull the matrix out of the docstring for the class. I'm lazy.
        rows=[x.strip() for x in self.__doc__.split('\n')]
        rows=[x for x in rows if x[0]=='|']
        rows=[[float(x) for x in y.strip('|').split()] for y in rows]
        for i in xrange(len(rows)):
            self.m.set_row(i, rows[i])
    def testConstruction(self):
        self.assert_(isinstance(self.m, Matrix))
        self.assertEquals(self.m[1, 1], 3.1)
        self.assertEquals(self.m[4, 1], 0.1)
        self.assertEquals(self.m[3, 0], 19.3)
        self.assertEquals(self.m[4, 3], -3.0)
    def testIndexError(self):
        self.assertRaises(IndexError, self.m.__getitem__, (7, 8))
    def testRowSum(self):
        self.assertAlmostEquals(self.m.rowsum(0), 3.5)
        self.assertAlmostEquals(self.m.rowsum(2), -3.8)
    def testColSum(self):
        self.assertAlmostEquals(self.m.colsum(3), 2.7)
    def testMax(self):
        self.assertAlmostEquals(self.m.max(), 19.3)
    def testSize(self):
        self.assertEquals(len(self.m), 5)
    def testRowNonZero(self):
        self.assertEquals(self.m.row_nonzero(2), 5)
        self.assertEquals(self.m.row_nonzero(1), 3)
    def testColNonZero(self):
        self.assertEquals(self.m.col_nonzero(0), 4)
        self.assertEquals(self.m.row_nonzero(4), 5)
    def testTranspose(self):
        t=self.m.transpose()
        for j in xrange(len(self.m)):
            for i in xrange(len(self.m)):
                self.assertEquals(self.m[i, j], t[j, i])
    def testEquals(self):
        t=self.m.transpose()
        tt=t.transpose()
        self.assertEquals(self.m, tt)
    def testNormalize(self):
        norm=self.m.normalize()
        self.assertAlmostEquals(norm[3, 0], 1.0)
        self.assertAlmostEquals(norm[3, 2], 0.05699481865285)
Exemplo n.º 9
0
class test_base_matrix(unittest.TestCase):
    """The default matrix is a 5x5 matrix with the following setup:
    |  1.0  0.0  1.0 -1.0  2.5 |
    |  0.0  3.1  0.1  0.0 -7.9 |
    | -9.8  1.1  6.7  2.2 -4.0 |
    | 19.3  1.1  1.1  4.5 -9.9 |
    |  2.7  0.1  0.1 -3.0  1.0 |"""
    def setUp(self):
        self.m = Matrix(5)
        # Pull the matrix out of the docstring for the class. I'm lazy.
        rows = [x.strip() for x in self.__doc__.split('\n')]
        rows = [x for x in rows if x[0] == '|']
        rows = [[float(x) for x in y.strip('|').split()] for y in rows]
        for i in xrange(len(rows)):
            self.m.set_row(i, rows[i])

    def testConstruction(self):
        self.assert_(isinstance(self.m, Matrix))
        self.assertEquals(self.m[1, 1], 3.1)
        self.assertEquals(self.m[4, 1], 0.1)
        self.assertEquals(self.m[3, 0], 19.3)
        self.assertEquals(self.m[4, 3], -3.0)

    def testIndexError(self):
        self.assertRaises(IndexError, self.m.__getitem__, (7, 8))

    def testRowSum(self):
        self.assertAlmostEquals(self.m.rowsum(0), 3.5)
        self.assertAlmostEquals(self.m.rowsum(2), -3.8)

    def testColSum(self):
        self.assertAlmostEquals(self.m.colsum(3), 2.7)

    def testMax(self):
        self.assertAlmostEquals(self.m.max(), 19.3)

    def testSize(self):
        self.assertEquals(len(self.m), 5)

    def testRowNonZero(self):
        self.assertEquals(self.m.row_nonzero(2), 5)
        self.assertEquals(self.m.row_nonzero(1), 3)

    def testColNonZero(self):
        self.assertEquals(self.m.col_nonzero(0), 4)
        self.assertEquals(self.m.row_nonzero(4), 5)

    def testTranspose(self):
        t = self.m.transpose()
        for j in xrange(len(self.m)):
            for i in xrange(len(self.m)):
                self.assertEquals(self.m[i, j], t[j, i])

    def testEquals(self):
        t = self.m.transpose()
        tt = t.transpose()
        self.assertEquals(self.m, tt)

    def testNormalize(self):
        norm = self.m.normalize()
        self.assertAlmostEquals(norm[3, 0], 1.0)
        self.assertAlmostEquals(norm[3, 2], 0.05699481865285)
Exemplo n.º 10
0
class DistanceMatrix(object):
    """Represents a distance matrix, in which each C[i, j] encodes the 
    distance from i to j in a graph.
    Pass the value you plan on using as an unreachable distance to the 
    constructor. If you omit it, it will default to the link matrix's size
    (reasonable in most cases).
    
    The distance matrix is meant to compute stats on, so it's immutable by
    design.
    """
    def __init__(self, a_link_matrix, unreachable_distance=None):
        self._matrix=Matrix(len(a_link_matrix))
        if unreachable_distance is None:
            unreachable_distance=len(a_link_matrix)
        self._unreachable=unreachable_distance
        logging.log(ULTRADEBUG, "Getting C versions of the matrices.")
        transposed=a_link_matrix.transpose()
        transposed_c=transposed.as_binary_c_matrix()
        c_link_matrix=a_link_matrix.as_binary_c_matrix()
        to_fill_in=self._matrix.as_binary_c_matrix()
        logging.log(ULTRADEBUG, "Going into C to perform the search.")
        DISTLIB.fill_distance_matrix(byref(to_fill_in), byref(c_link_matrix), 
                                     byref(transposed_c), len(a_link_matrix),
                                     self._unreachable)
        logging.log(ULTRADEBUG, "Back from C. Filling the matrix in.")
        self._matrix.fill_from_c_matrix(to_fill_in)
        self._converted_distance=None
    def __getitem__(self, key):
        return self._matrix[key]
    def __len__(self):
        return len(self._matrix)
    def out_distance(self, i):
        """The out-distance of a term i."""
        return self._matrix.rowsum(i)
    def in_distance(self, j):
        """The in-distance of a term j."""
        return self._matrix.colsum(j)
    def compute_converted_distance(self):
        """Calculate the converted distance, for the internal use of other 
        functions."""
        total=0.0
        for i in xrange(len(self)):
            total+=self.out_distance(i)
        self._converted_distance=total
    def relative_out_centrality(self, i):
        """Computes relative out centrality."""
        if self._converted_distance is None:
            self.compute_converted_distance()
        return self._converted_distance/float(self.out_distance(i))
    def relative_in_centrality(self, j):
        """Computes relative in centrality."""
        if self._converted_distance is None:
            self.compute_converted_distance()
        return self._converted_distance/float(self.in_distance(j))
    def max_centrality_norm_factor(self):
        """The normalization factor corresponding to the maximal centrality. 
        Used in the compactness calculation"""
        return float(len(self)**2 - len(self))*self._unreachable
    def min_centrality_norm_factor(self):
        """The normalization factor corresponding to the minimal centrality. 
        Used in the compactness calculation"""
        return float(len(self)**2 - len(self))
    def compactness(self):
        "Measures how connected the graph is"
        if self._converted_distance is None:
            self.compute_converted_distance()
        return (self.max_centrality_norm_factor()-self._converted_distance) \
                /(self.max_centrality_norm_factor()-
                    self.min_centrality_norm_factor())
    def stratum(self):
        "Measures the linearity of the graph"
        lap=(len(self)**3)/4.0 if len(self)%2==0 \
                               else (len(self)**3-len(self))/4.0
        total=0.0
        for i in xrange(len(self)):
            # We can't use the regular implementations, because we must
            # invalidate the unconnected nodes.
            status=0.0
            contrastatus=0.0
            for j in xrange(len(self)):
                rowval=self._matrix[i, j]
                colval=self._matrix[j, i]
                status+=0.0 if rowval==self._unreachable else rowval
                contrastatus+=0.0 if colval==self._unreachable else colval
            total+=abs(status-contrastatus)
        return total/lap
Exemplo n.º 11
0
 def transpose(self):
     # Needs a special transpose operation because it must return a 
     # LinkMatrix
     return Matrix.transpose(self, LinkMatrix)
Exemplo n.º 12
0
 def __init__(self, matrix_size):
     Matrix.__init__(self, matrix_size)