示例#1
0
    def test_pinv_linop(self):
        p = 2.3

        pinvE = upin.pinv_1mE_brute(self.A,
                                    self.B,
                                    self.x,
                                    self.y,
                                    p=p,
                                    pseudo=True)
        pinvELOPR = upin.pinv_1mE_brute_LOP(self.A,
                                            self.B,
                                            self.x,
                                            self.y,
                                            p=p,
                                            pseudo=True,
                                            left=False)
        pinvELOPL = upin.pinv_1mE_brute_LOP(self.A,
                                            self.B,
                                            self.x,
                                            self.y,
                                            p=p,
                                            pseudo=True,
                                            left=True)

        self.assertTrue(sp.allclose(pinvE, pinvELOPR, rtol=1E-15, atol=1E-15))
        self.assertTrue(sp.allclose(pinvE, pinvELOPL, rtol=1E-15, atol=1E-15))

        pinvE = upin.pinv_1mE_brute(self.A,
                                    self.B,
                                    self.x,
                                    self.y,
                                    p=p,
                                    pseudo=False)
        pinvELOPR = upin.pinv_1mE_brute_LOP(self.A,
                                            self.B,
                                            self.x,
                                            self.y,
                                            p=p,
                                            pseudo=False,
                                            left=False)
        pinvELOPL = upin.pinv_1mE_brute_LOP(self.A,
                                            self.B,
                                            self.x,
                                            self.y,
                                            p=p,
                                            pseudo=False,
                                            left=True)

        self.assertTrue(sp.allclose(pinvE, pinvELOPR, rtol=1E-15, atol=1E-15))
        self.assertTrue(sp.allclose(pinvE, pinvELOPL, rtol=1E-15, atol=1E-15))
 def test_pinv_AA_right_p0(self):
     res = upin.pinv_1mE(self.x, self.A, self.A, self.Al, self.Ar, p=0, left=False, pseudo=True, tol=self.solver_tol)
     
     pinvE = upin.pinv_1mE_brute(self.A, self.A, self.Al, self.Ar, p=0, pseudo=True)
     res_brute = pinvE.dot(self.x.ravel()).reshape(self.D, self.D)
     
     self.assertLess(la.norm(res_brute - res), self.solver_tol * la.norm(res_brute))
 def test_pinv_linop(self):
     p = 2.3
     
     pinvE = upin.pinv_1mE_brute(self.A, self.B, self.x, self.y, p=p, pseudo=True)
     pinvELOPR = upin.pinv_1mE_brute_LOP(self.A, self.B, self.x, self.y, p=p, pseudo=True, left=False)
     pinvELOPL = upin.pinv_1mE_brute_LOP(self.A, self.B, self.x, self.y, p=p, pseudo=True, left=True)
     
     self.assertTrue(sp.allclose(pinvE, pinvELOPR, rtol=1E-15, atol=1E-15))
     self.assertTrue(sp.allclose(pinvE, pinvELOPL, rtol=1E-15, atol=1E-15))
     
     pinvE = upin.pinv_1mE_brute(self.A, self.B, self.x, self.y, p=p, pseudo=False)
     pinvELOPR = upin.pinv_1mE_brute_LOP(self.A, self.B, self.x, self.y, p=p, pseudo=False, left=False)
     pinvELOPL = upin.pinv_1mE_brute_LOP(self.A, self.B, self.x, self.y, p=p, pseudo=False, left=True)
     
     self.assertTrue(sp.allclose(pinvE, pinvELOPR, rtol=1E-15, atol=1E-15))
     self.assertTrue(sp.allclose(pinvE, pinvELOPL, rtol=1E-15, atol=1E-15))
 def test_inv_AB_left_p2(self):
     res = upin.pinv_1mE(self.x, self.A, self.B, None, None, p=2, left=True, pseudo=False, tol=self.solver_tol)
     
     pinvE = upin.pinv_1mE_brute(self.A, self.B, None, None, p=2, pseudo=False)
     res_brute = pinvE.conj().T.dot(self.x.ravel()).reshape(self.D, self.D)
     
     self.assertLess(la.norm(res_brute - res), self.solver_tol * la.norm(res_brute))
 def test_pinv_AA_right_p0_rank_def(self):
     A = sp.zeros((self.d, self.D + 2, self.D + 2), dtype=self.A.dtype)
     A[:, :self.D, :self.D] = self.A
     Al = sp.zeros((self.D + 2, self.D + 2), dtype=self.A.dtype)
     Al[:self.D, :self.D] = self.Al
     Ar = sp.zeros((self.D + 2, self.D + 2), dtype=self.A.dtype)
     Ar[:self.D, :self.D] = self.Ar
     
     x = sp.zeros((self.D + 2, self.D + 2), dtype=self.A.dtype)
     x[:self.D, :self.D] = self.x
     
     res = upin.pinv_1mE(x, A, A, Al, Ar, p=0, left=False, pseudo=True, tol=self.solver_tol)
     
     pinvE = upin.pinv_1mE_brute(A, A, Al, Ar, p=0, pseudo=True)
     res_brute = pinvE.dot(x.ravel()).reshape(self.D + 2, self.D + 2)
     
     self.assertLess(la.norm(res_brute - res), self.solver_tol * la.norm(res_brute))