Пример #1
0
    def testAddRows(self):

        #Test case when k = rank
        Utilde, Stilde, Vtilde = SVDUpdate.addRows(self.U, self.s, self.V,
                                                   self.C)

        nptst.assert_array_almost_equal(Utilde.T.dot(Utilde),
                                        numpy.eye(Utilde.shape[1]))
        nptst.assert_array_almost_equal(Vtilde.T.dot(Vtilde),
                                        numpy.eye(Vtilde.shape[1]))

        self.assertEquals(Stilde.shape[0], self.k)

        #Check we get the original solution with full SVD
        U, s, V = numpy.linalg.svd(self.A)
        inds = numpy.flipud(numpy.argsort(s))
        U, s, V = Util.indSvd(U, s, V, inds)

        Utilde, Stilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
        D = numpy.r_[self.A, self.C]

        nptst.assert_array_almost_equal(D, (Utilde * Stilde).dot(Vtilde.T), 4)

        #Check solution for partial rank SVD
        k = 20
        U, s, V = numpy.linalg.svd(self.A)
        inds = numpy.flipud(numpy.argsort(s))[0:k]
        U, s, V = Util.indSvd(U, s, V, inds)

        Utilde, Stilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
        D = numpy.r_[(U * s).dot(V.T), self.C]
        U, s, V = numpy.linalg.svd(D)
        inds = numpy.flipud(numpy.argsort(s))[0:k]
        U, s, V = Util.indSvd(U, s, V, inds)

        nptst.assert_array_almost_equal((U * s).dot(V.T),
                                        (Utilde * Stilde).dot(Vtilde.T), 4)

        #Test if same as add cols
        U, s, V = numpy.linalg.svd(self.A)
        inds = numpy.flipud(numpy.argsort(s))[0:k]
        U, s, V = Util.indSvd(U, s, V, inds)
        Utilde, sTilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
        Vtilde2, sTilde2, Utilde2 = SVDUpdate.addCols(V, s, U, self.C.T)

        nptst.assert_array_almost_equal((Utilde * sTilde).dot(Vtilde.T),
                                        (Utilde2 * sTilde2).dot(Vtilde2.T))
Пример #2
0
 def testAddRows(self): 
     
     #Test case when k = rank 
     Utilde, Stilde, Vtilde = SVDUpdate.addRows(self.U, self.s, self.V, self.C)
     
     nptst.assert_array_almost_equal(Utilde.T.dot(Utilde), numpy.eye(Utilde.shape[1]))
     nptst.assert_array_almost_equal(Vtilde.T.dot(Vtilde), numpy.eye(Vtilde.shape[1]))
     
     self.assertEquals(Stilde.shape[0], self.k)
     
     #Check we get the original solution with full SVD 
     U, s, V = numpy.linalg.svd(self.A)
     inds = numpy.flipud(numpy.argsort(s))
     U, s, V = Util.indSvd(U, s, V, inds)
     
     Utilde, Stilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
     D = numpy.r_[self.A, self.C]
     
     nptst.assert_array_almost_equal(D, (Utilde*Stilde).dot(Vtilde.T), 4)
     
     #Check solution for partial rank SVD 
     k = 20 
     U, s, V = numpy.linalg.svd(self.A)
     inds = numpy.flipud(numpy.argsort(s))[0:k]
     U, s, V = Util.indSvd(U, s, V, inds)
     
     Utilde, Stilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
     D = numpy.r_[(U*s).dot(V.T), self.C]
     U, s, V = numpy.linalg.svd(D)
     inds = numpy.flipud(numpy.argsort(s))[0:k]
     U, s, V = Util.indSvd(U, s, V, inds)
     
     nptst.assert_array_almost_equal((U*s).dot(V.T), (Utilde*Stilde).dot(Vtilde.T), 4)
     
     #Test if same as add cols 
     U, s, V = numpy.linalg.svd(self.A)
     inds = numpy.flipud(numpy.argsort(s))[0:k]
     U, s, V = Util.indSvd(U, s, V, inds)
     Utilde, sTilde, Vtilde = SVDUpdate.addRows(U, s, V, self.C)
     Vtilde2, sTilde2, Utilde2 = SVDUpdate.addCols(V, s, U, self.C.T)
     
     nptst.assert_array_almost_equal((Utilde*sTilde).dot(Vtilde.T),  (Utilde2*sTilde2).dot(Vtilde2.T))