def test_lu_raw_returns_expected_shapes(self, arrays):
m_sb, m_bb, m_bs = arrays
wide, big, tall = [arr.shape for arr in arrays]
hy.assume(hn.wide(m_sb))
# with self.subTest(msg="square"):
self.assertArrayShapesAre(gfl.lu_rawm(m_bb), (big, big[:-1]))
# with self.subTest(msg="wide"):
self.assertArrayShapesAre(gfl.lu_rawm(m_sb),
(utn.trnsp(wide), wide[:-1]))
# with self.subTest(msg="tall"):
self.assertArrayShapesAre(gfl.lu_rawn(m_bs),
(utn.trnsp(tall), utn.drop(tall)))
def test_lnarray_shape_methods(self, arrays):
m_bs, m_ss = view_as(*arrays)
tall, smol = m_bs.shape, m_ss.shape
hy.assume(hn.tall(m_bs))
hy.assume(np.max(np.abs(m_bs.imag)) > .01)
hy.assume(np.max(np.abs(m_bs.real)) / np.max(np.abs(m_bs.imag)) < 1e3)
expect = utn.trnsp(tall)
self.assertArrayShape(m_bs.t, expect)
self.assertArrayShape(m_bs.h, expect)
self.assertArrayNotAllClose(m_bs.t, m_bs.h)
self.assertArrayShape(m_ss.c, smol + (1, ))
self.assertArrayShape(m_bs.c.uc, tall)
expect = insert(smol)
self.assertArrayShape(m_ss.r, expect)
self.assertArrayShape(m_bs.r.ur, tall)
self.assertArrayShape(m_ss.s, smol + (1, 1))
self.assertArrayShape(m_bs.s.us, tall)
# expect = smol[:1] + (1,) + smol[1:2] + (1,) + smol[2:]
expect = insert(insert(smol, 2), 1)
self.assertArrayShape(m_ss.expand_dims((1, 3)), expect)
expect = tall[:1] + (np.prod(tall[1:4]), ) + tall[4:]
self.assertArrayShape(m_bs.flattish(1, 4), expect)
with self.assertRaisesRegex(ValueError, "repeated axis"):
m_bs.expand_dims((m_bs.ndim - 1, -3))
half = (m_bs.ndim + 2) // 2 + 1
with self.assertRaises(ValueError):
(m_bs.s).flattish(half, -half)
def test_lu(self, arrays):
m_ss, m_sb, m_bs = arrays
smol, wide, tall = [arr.shape for arr in arrays]
hy.assume(hn.wide(m_sb))
# with self.subTest("separate"):
self.assertArrayShapesAre(la.lu(m_ss, 'separate'),
(smol, smol, smol[:-1]))
self.assertArrayShapesAre(la.lu(m_bs, 'separate'),
(tall, utn.chop(tall), utn.drop(tall)))
self.assertArrayShapesAre(la.lu(m_sb, 'separate'),
(utn.chop(wide), wide, wide[:-1]))
# with self.subTest("raw"):
self.assertArrayShapesAre(la.lu(m_ss, 'raw'), (smol, smol[:-1]))
self.assertArrayShapesAre(la.lu(m_bs, 'raw'),
(utn.trnsp(tall), utn.drop(tall)))
self.assertArrayShapesAre(la.lu(m_sb, 'raw'),
(utn.trnsp(wide), wide[:-1]))
def test_rlstsq_qr_flexible_signature_with_vectors_vm(self, arrays, fun):
m_sb, m_bs = arrays[:-2]
v_s, v_b = hn.core_only(*arrays[-2:], dims=1)
wide, tall = [arr.shape for arr in arrays[:-2]]
hy.assume(hn.wide(m_sb))
hy.assume(hn.all_well_behaved(m_sb, m_bs))
off_b, y_one = utn.make_off_by_one(m_sb, m_bs)
tau = m_sb.shape[:-2] + tau_len(m_sb, fun)
self.assertArrayShapesAre(fun(v_b, m_sb),
(wide[:-1], utn.trnsp(wide), tau))
tau = m_bs.shape[:-2] + tau_len(m_bs, fun)
self.assertArrayShapesAre(fun(v_s, m_bs),
(tall[:-1], utn.trnsp(tall), tau))
with self.assertRaisesRegex(*utn.core_dim_err):
fun(v_b, m_bs)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as vM:
fun(m_bs[y_one], m_sb[off_b])
def test_lq_returns_expected_shapes(self, arrays):
m_sb, m_bs = arrays
wide, tall = [arr.shape for arr in arrays]
hy.assume(hn.wide(m_sb))
# with self.subTest(msg='wide'):
self.assertArrayShapesAre(gfl.lq_m(m_sb), (utn.chop(wide), wide))
self.assertArrayShape(gfl.lq_lm(m_sb), utn.chop(wide))
# with self.subTest(msg='tall'):
self.assertArrayShapesAre(gfl.lq_n(m_bs), (tall, utn.chop(tall)))
self.assertArrayShape(gfl.lq_ln(m_bs), tall)
with self.assertRaisesRegex(*utn.invalid_err):
gfl.lq_m(m_bs)
# with self.subTest(msg='complete'):
self.assertArrayShapesAre(gfl.lq_n(m_sb), (wide, utn.grow(wide)))
# with self.subTest(msg='raw'):
self.assertArrayShapesAre(gfl.lq_rawm(m_sb),
(utn.trnsp(wide), wide[:-1]))
self.assertArrayShapesAre(gfl.lq_rawn(m_bs),
(utn.trnsp(tall), utn.drop(tall)))
def test_pinvarray_shape_methods(self, array):
m_bs = array.view(la.lnarray)
hy.assume(hn.nonsquare(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
m_bs_p = m_bs.pinv
expect = utn.trnsp(m_bs.shape)
self.assertEqual(m_bs_p.ndim, len(expect))
self.assertEqual(m_bs_p.shape, expect)
self.assertEqual(m_bs_p.size, np.prod(expect))
self.assertArrayShape(m_bs_p(), expect)
with self.assertRaises(ValueError):
m_bs.inv # pylint: disable=pointless-statement
m_bs_p = m_bs.c.pinv
expect = insert(m_bs.shape)
now_expect = expect[1::-1] + expect[2:]
self.assertArrayShape(m_bs_p.swapaxes(0, 1), now_expect)
now_expect = expect[2::-1] + expect[3:]
self.assertArrayShape(m_bs_p.swapaxes(0, 2), now_expect)
now_expect = utn.trnsp(expect)
self.assertArrayShape(m_bs_p.swapaxes(-1, -2), now_expect)
def test_lq(self, arrays):
m_sb, m_bs = arrays
wide, tall = [arr.shape for arr in arrays]
hy.assume(hn.wide(m_sb))
# with self.subTest("reduced"):
self.assertArrayShapesAre(la.lq(m_bs, 'reduced'),
(tall, utn.chop(tall)))
self.assertArrayShapesAre(la.lq(m_sb, 'reduced'),
(utn.chop(wide), wide))
# with self.subTest("complete"):
self.assertArrayShapesAre(la.lq(m_bs, 'complete'),
(tall, utn.chop(tall)))
self.assertArrayShapesAre(la.lq(m_sb, 'complete'),
(wide, utn.grow(wide)))
# with self.subTest("l/raw"):
self.assertArrayShape(la.lq(m_bs, 'l'), tall)
self.assertArrayShape(la.lq(m_sb, 'l'), utn.chop(wide))
self.assertArrayShapesAre(la.lq(m_bs, 'raw'),
(utn.trnsp(tall), utn.drop(tall)))
self.assertArrayShapesAre(la.lq(m_sb, 'raw'),
(utn.trnsp(wide), wide[:-1]))
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)))
def test_lstsq_qr_returns_expected_shape_tall(self, arrays, fun):
m_sb, m_bb, m_bs = arrays
hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
tall = m_bs.shape
expect = utn.array_return_shape('(m,n),(m,p)->(n,p),(n,m)', m_bs, m_bb)
tau = expect[1][:-2] + tau_len(m_bs, fun)
result = fun(m_bs, m_bb)
self.assertArrayShapesAre(result, expect + (tau, ))
self.assertArrayShapesAre(unbroadcast_factors(m_bs, *result[1:]),
(utn.trnsp(tall), tall[:-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_bs, m_bb))
def test_pinv_returns_expected_shapes(self, arrays):
m_sb, m_bs = arrays
wide, tall = [arr.shape for arr in arrays]
hy.assume(hn.wide(m_sb))
hy.assume(hn.all_well_behaved(m_bs, m_sb))
# with self.subTest(msg='wide'):
self.assertArrayShape(gfl.pinv(m_sb), utn.trnsp(wide))
# with self.subTest(msg='tall'):
self.assertArrayShape(gfl.pinv(m_bs), utn.trnsp(tall))
# with self.subTest(msg='wide,+qr'):
self.assertArrayShapesAre(
gfl.pinv_qrm(m_sb), (utn.trnsp(wide), utn.trnsp(wide), wide[:-1]))
# with self.subTest(msg='tall,+qr'):
self.assertArrayShapesAre(
gfl.pinv_qrn(m_bs),
(utn.trnsp(tall), utn.trnsp(tall), utn.drop(tall)))
# with self.subTest(msg='wide,-qr'):
_, m_sb_f, m_sb_tau = gfl.pinv_qrm(m_sb)
self.assertArrayShape(gfl.qr_pinv(m_sb_f, m_sb_tau), utn.trnsp(wide))
# with self.subTest(msg='tall,-qr'):
_, m_bs_f, m_bs_tau = gfl.pinv_qrn(m_bs)
self.assertArrayShape(gfl.qr_pinv(m_bs_f, m_bs_tau), utn.trnsp(tall))
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))
