コード例 #1
0
    def test_lu(self, arrays):
        m_ss, m_sb, m_bs = arrays
        box = np.s_[..., :m_sb.shape[-2], :]
        hy.assume(hn.wide(m_sb))

        # with self.subTest("square"):
        cond = np.linalg.cond(m_ss).max()
        lower, upper, piv = la.lu(m_ss, 'separate')
        luf, piv = la.lu(m_ss, 'raw')
        luf = la.transpose(luf)
        self.assertArrayAllClose(lower @ upper, gf.pivot(m_ss, piv), cond=cond)
        self.assertArrayAllClose(tril(lower), tril(luf), cond=cond)
        self.assertArrayAllClose(upper, np.triu(luf), cond=cond)
        # with self.subTest("wide"):
        cond = np.linalg.cond(m_bs).max()
        lower, upper, piv = la.lu(m_bs, 'separate')
        luf, piv = la.lu(m_bs, 'raw')
        luf = la.transpose(luf)
        self.assertArrayAllClose(tril(lower), tril(luf), cond=cond)
        self.assertArrayAllClose(upper, np.triu(luf)[box], cond=cond)
        # with self.subTest("wide"):
        cond = np.linalg.cond(m_sb).max()
        lower, upper, piv = la.lu(m_sb, 'separate')
        luf, piv = la.lu(m_sb, 'raw')
        luf = la.transpose(luf)
        self.assertArrayAllClose(tril(lower), tril(luf)[box[:-1]], cond=cond)
        self.assertArrayAllClose(upper, np.triu(luf), cond=cond)
コード例 #2
0
    def test_lqr(self, arrays):
        m_sb, m_bs = arrays
        hy.assume(hn.wide(m_sb))
        hy.assume(hn.all_well_behaved(m_sb, m_bs))
        box = np.s_[..., :m_sb.shape[-2], :]
        cond_sb = np.linalg.cond(m_sb).max()
        cond_bs = np.linalg.cond(m_bs).max()

        # with self.subTest("reduced"):
        unitary, right = la.lqr(m_bs, 'reduced')
        self.assertArrayAllClose(unitary @ right, m_bs, cond=cond_bs)
        left, unitary = la.lqr(m_sb, 'reduced')
        self.assertArrayAllClose(left @ unitary, m_sb, cond=cond_sb)
        # with self.subTest("complete"):
        unitary, right = la.lqr(m_bs, 'complete')
        self.assertArrayAllClose(unitary @ right, m_bs, cond=cond_bs)
        left, unitary = la.lqr(m_sb, 'complete')
        self.assertArrayAllClose(left @ unitary, m_sb, cond=cond_sb)
        # with self.subTest("r/l/raw"):
        right = la.lqr(m_bs, 'r')
        hhold, _ = la.lqr(m_bs, 'raw')
        self.assertArrayAllClose(right,
                                 np.triu(la.transpose(hhold))[box],
                                 cond=cond_bs)
        left = la.lqr(m_sb, 'r')
        hhold, _ = la.lqr(m_sb, 'raw')
        self.assertArrayAllClose(left,
                                 np.tril(la.transpose(hhold))[box[:-1]],
                                 cond=cond_sb)
コード例 #3
0
    def test_rlstsq_returns_expected_shape(self, arrays):
        m_ss, m_sb, m_bb, m_bs = arrays
        hy.assume(hn.wide(m_sb))

        # with self.subTest('underconstrained'):
        expect = utn.array_return_shape('(m,n),(p,n)->(m,p)', m_ss, m_bs)
        self.assertArrayShape(gfl.rlstsq(m_ss, m_bs), expect)
        with self.assertRaisesRegex(*utn.core_dim_err):
            gfl.rlstsq(m_sb, m_bs)
        with self.assertRaisesRegex(*utn.broadcast_err):
            gfl.rlstsq(*utn.make_bad_broadcast(m_ss, la.transpose(m_sb)))
        # with self.subTest('overconstrained'):
        expect = utn.array_return_shape('(m,n),(p,n)->(m,p)', m_bb, m_sb)
        self.assertArrayShape(gfl.rlstsq(m_bb, m_sb), expect)
        with self.assertRaisesRegex(*utn.core_dim_err):
            gfl.rlstsq(m_bs, m_sb)
        with self.assertRaisesRegex(*utn.broadcast_err):
            gfl.rlstsq(*utn.make_bad_broadcast(m_bb, la.transpose(m_bs)))
コード例 #4
0
 def test_lu_raw_returns_expected_values_square(self, m_bb):
     sq_l, sq_u, sq_ip0 = gfl.lu_m(m_bb)
     sq_f, sq_ip = gfl.lu_rawm(m_bb)
     sq_f = la.transpose(sq_f)
     linds = (..., ) + np.tril_indices(m_bb.shape[-1], -1)
     uinds = (..., ) + np.triu_indices(m_bb.shape[-1], 0)
     # with self.subTest(msg="square"):
     cond = np.linalg.cond(m_bb).max()
     self.assertArrayAllClose(sq_f[linds], sq_l[linds], cond=cond)
     self.assertArrayAllClose(sq_f[uinds], sq_u[uinds], cond=cond)
     self.assertEqual(sq_ip, sq_ip0)
コード例 #5
0
    def test_lu_raw_returns_expected_values_tall(self, m_bs):
        tall = m_bs.shape
        hy.assume(hn.tall(m_bs))
        cond = np.linalg.cond(m_bs).max()

        tl_l, tl_u, tl_ip0 = gfl.lu_n(m_bs)
        tl_f, tl_ip = gfl.lu_rawn(m_bs)
        tl_f = la.transpose(tl_f)
        linds = (..., ) + np.tril_indices(tall[-2], -1, tall[-1])
        uinds = (..., ) + np.triu_indices(tall[-2], 0, tall[-1])
        # with self.subTest(msg="tall"):
        self.assertArrayAllClose(tl_f[linds], tl_l[linds], cond=cond)
        self.assertArrayAllClose(tl_f[uinds], tl_u[uinds], cond=cond)
        self.assertEqual(tl_ip, tl_ip0)
コード例 #6
0
    def test_lu_raw_returns_expected_values_wide(self, m_sb):
        wide = m_sb.shape
        hy.assume(hn.wide(m_sb))
        cond = np.linalg.cond(m_sb).max()

        wd_l, wd_u, wd_ip0 = gfl.lu_m(m_sb)
        wd_f, wd_ip = gfl.lu_rawm(m_sb)
        wd_f = la.transpose(wd_f)
        linds = (..., ) + np.tril_indices(wide[-2], -1, wide[-1])
        uinds = (..., ) + np.triu_indices(wide[-2], 0, wide[-1])
        # with self.subTest(msg="wide"):
        self.assertArrayAllClose(wd_f[linds], wd_l[linds], cond=cond)
        self.assertArrayAllClose(wd_f[uinds], wd_u[uinds], cond=cond)
        self.assertEqual(wd_ip, wd_ip0)
コード例 #7
0
    def test_rlstsq_qr_returns_expected_shape_wide(self, arrays, fun):
        _, m_sb, m_bb, m_bs = arrays
        hy.assume(hn.wide(m_sb))
        hy.assume(hn.all_well_behaved(m_sb))
        wide = m_sb.shape

        expect = utn.array_return_shape('(m,n),(p,n)->(m,p),(n,p)', m_bb, m_sb)
        tau = expect[1][:-2] + tau_len(m_sb, fun)
        result = fun(m_bb, m_sb)
        self.assertArrayShapesAre(result, expect + (tau, ))
        self.assertArrayShapesAre(unbroadcast_factors(m_sb, *result[1:]),
                                  (utn.trnsp(wide), wide[:-2] + tau[-1:]))
        with self.assertRaisesRegex(*utn.core_dim_err):
            fun(m_bs, m_sb)
        with self.assertRaisesRegex(*utn.broadcast_err):
            fun(*utn.make_bad_broadcast(m_bb, la.transpose(m_bs)))
コード例 #8
0
    def test_qr_rawn_returns_expected_values(self, m_bs):
        hy.assume(hn.tall(m_bs))
        hy.assume(hn.all_well_behaved(m_bs))
        cond = np.linalg.cond(m_bs).max()

        rrr = gfl.qr_n(m_bs)[1]
        num = rrr.shape[-1]
        ht_bs, tau = gfl.qr_rawn(m_bs)
        h_bs = la.transpose(ht_bs)
        vecs = np.tril(h_bs, -1)
        vecs[(..., ) + np.diag_indices(num)] = 1
        vnorm = gfb.norm(la.row(tau) * vecs, axis=-2)**2
        right = np.triu(h_bs)
        # with self.subTest(msg='raw_n'):
        self.assertArrayAllClose(right[..., :num, :], rrr, cond=cond)
        self.assertArrayAllClose(vnorm, 2 * tau.real, cond=cond)
        for k in range(num):
            vvv = vecs[..., num - k - 1:num - k]
            ttt = la.scalar(tau[..., -k - 1])
            right -= ttt * vvv * (la.dagger(vvv) @ right)
        # with self.subTest(msg='h_n'):
        self.assertArrayAllClose(right, m_bs, cond=cond)
コード例 #9
0
    def test_lq_rawn_returns_expected_values(self, m_bs):
        hy.assume(hn.tall(m_bs))
        hy.assume(hn.all_well_behaved(m_bs))
        cond = np.linalg.cond(m_bs).max()

        llo = gfl.lq_n(m_bs)[0]
        num = llo.shape[-1]
        ht_bs, tau = gfl.lq_rawn(m_bs)
        h_bs = la.transpose(ht_bs)
        vecs = np.triu(h_bs, 1)
        vecs[(..., ) + np.diag_indices(num)] = 1
        vnorm = gfb.norm(la.col(tau) * vecs[..., :num, :], axis=-1)**2
        left = np.tril(h_bs)
        # with self.subTest(msg='raw_n'):
        self.assertArrayAllClose(left, llo, cond=cond)
        # with self.subTest(msg='tau_n'):
        self.assertArrayAllClose(vnorm, 2 * tau.real, cond=cond)
        for k in range(num):
            vvv = vecs[..., num - k - 1:num - k, :]
            ttt = la.scalar(tau[..., -k - 1])
            left -= ttt.conj() * (left @ la.dagger(vvv)) * vvv
        # with self.subTest(msg='h_n'):
        self.assertArrayAllClose(left, m_bs, cond=cond)
コード例 #10
0
 def test_functions_shape(self, array):
     shape = array.shape
     self.assertArrayShape(la.transpose(array), utn.trnsp(shape))
     self.assertArrayShape(la.row(array), shape[:-1] + (1, ) + shape[-1:])
     self.assertArrayShape(la.col(array), shape + (1, ))
     self.assertArrayShape(la.scalar(array), shape + (1, 1))