def test_pinvarray_in_functions(self, arrays):
m_sb, high, m_bs = view_as(*arrays)
# hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
cond = np.linalg.cond(m_bs).max()
self.assertArrayAllClose(gf.matmul(m_bs.pinv, high),
gf.lstsq(m_bs, high),
cond=cond)
self.assertArrayAllClose(gf.matmul(m_sb, m_bs.pinv.t),
gf.rlstsq(m_sb, m_bs.t),
cond=cond)
xpout = la.pinvarray(np.empty_like(m_bs))
m_bs_p = np.multiply(m_bs.pinv, 2, out=xpout)
self.assertArrayAllClose(m_bs_p.pinv, xpout.pinv)
self.assertArrayAllClose(m_bs_p.pinv, m_bs / 2)
with self.assertRaises(TypeError):
gf.matmul(m_bs.pinv, m_sb.pinv)
self.assertArrayAllClose(gf.lstsq(m_sb.pinv, high),
gf.matmul(m_sb, high))
with self.assertRaises(TypeError):
gf.lstsq(high, m_sb.pinv)
self.assertArrayAllClose(gf.rlstsq(high.t, m_sb.t.pinv),
gf.matmul(high.t, m_sb.t))
with self.assertRaises(TypeError):
gf.rlstsq(m_sb.t.pinv, high.t)
with self.assertRaises(TypeError):
gf.rmatmul(m_sb.pinv, m_bs.pinv)
with self.assertRaises(TypeError):
gf.solve(m_sb.pinv, high)
with self.assertRaises(TypeError):
gf.rsolve(m_sb, m_bs.pinv)
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)
def test_return_array_types(self, arrays):
m_sb_n, m_bs_n = arrays[:2]
m_sb, m_bs, m_ss, m_bb = view_as(*arrays)
m_bs_m, m_ss_m, m_bb_m = hn.core_only(m_bs, m_ss, m_bb)
hy.assume(hn.all_well_behaved(m_ss, m_bb))
hy.assume(m_sb.ndim != m_ss.ndim - 1) # np..solve's broadcasting issue
self.assertIsInstance(m_sb @ m_bs, la.lnarray)
self.assertIsInstance(m_sb_n @ m_bs, la.lnarray)
expect = utn.array_return_shape('(a,b),(b,c)->(a,c)', m_bs, m_sb)
tw_o = np.empty(expect, m_bs.dtype)
tw_r = la.matmul(m_bs, m_sb_n, tw_o)
self.assertIsInstance(tw_r, np.ndarray)
self.assertIsInstance(tw_o, np.ndarray)
self.assertIsInstance(np.matmul(m_bs, m_sb_n), np.ndarray)
self.assertIsInstance(la.solve(m_ss, m_sb_n), la.lnarray)
self.assertIsInstance(nl.solve(m_ss, m_sb_n), np.ndarray)
self.assertIsInstance(la.lstsq(m_bs, m_bb), la.lnarray)
self.assertIsInstance(
nl.lstsq(m_bs_m, m_bb_m, rcond=None)[0], np.ndarray)
self.assertIsInstance(la.lu(m_ss)[0], la.lnarray)
self.assertIsInstance(la.lu(m_bs_n)[0], np.ndarray)
self.assertIsInstance(la.qr(m_ss)[0], la.lnarray)
self.assertIsInstance(la.qr(m_bs_n)[0], np.ndarray)
self.assertIsInstance(la.lq(m_ss)[0], la.lnarray)
self.assertIsInstance(la.lq(m_bs_n)[0], np.ndarray)
self.assertIsInstance(la.lqr(m_ss)[0], la.lnarray)
self.assertIsInstance(la.lqr(m_bs_n)[0], np.ndarray)
self.assertIsInstance(nl.qr(m_ss_m)[0], np.ndarray)
def test_good_p_invarray_combos_in_lstsq(self, arrays):
m_ss, m_bs, m_sb, mini = view_as(*arrays)
# hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_ss, mini, m_bs, m_sb))
self.assertArrayAllClose(la.lstsq(mini.inv, m_sb),
la.matmul(mini, m_sb))
self.assertArrayAllClose(la.rlstsq(m_bs, mini.inv),
la.matmul(m_bs, mini))
cond = np.linalg.cond(m_bs).max()
self.assertArrayAllClose(la.lstsq(mini.inv, m_bs.pinv),
la.rlstsq(mini, m_bs),
cond=cond)
cond = np.linalg.cond(mini).max()
self.assertArrayAllClose(la.rlstsq(mini.inv, m_sb.pinv),
la.solve(mini, m_sb),
cond=cond)
cond = np.linalg.cond(m_ss).max()
self.assertArrayAllClose(la.lstsq(mini.inv, m_ss.inv),
la.rsolve(mini, m_ss),
cond=cond)
cond = np.linalg.cond(mini).max()
self.assertArrayAllClose(la.rlstsq(mini.inv, m_ss.inv),
la.solve(mini, m_ss),
cond=cond)
cond = np.linalg.cond(m_ss).max()
self.assertArrayAllClose(la.lstsq(m_bs.pinv, m_ss.inv),
la.rsolve(m_bs, m_ss),
cond=cond)
cond = np.linalg.cond(m_sb).max()
self.assertArrayAllClose(la.rlstsq(m_sb.pinv, m_ss.inv),
la.lstsq(m_sb, m_ss),
cond=cond)
def test_pinvarray_attribute_types(self, arrays):
m_ss, m_bs = view_as(*arrays)
hy.assume(hn.all_well_behaved(m_ss))
self.assertIsInstance(m_ss.pinv, la.pinvarray)
self.assertIsInstance(m_ss.inv, la.invarray)
self.assertIs(m_ss.pinv.dtype, m_bs.dtype)
self.assertIsInstance(m_ss.pinv.pinv, la.lnarray)
self.assertIsInstance(m_ss.inv.inv, la.lnarray)
self.assertIsInstance(m_ss.pinv(), la.lnarray)
self.assertIsInstance(m_ss.inv(), la.lnarray)
m_bs_p = la.pinvarray(m_bs)
self.assertIsInstance(m_bs_p, la.pinvarray)
self.assertIsInstance(m_bs_p.pinv, la.lnarray)
self.assertIsInstance(2 * m_bs_p, la.pinvarray)
self.assertIsInstance((2 * m_bs_p).pinv, la.lnarray)
pout = la.pinvarray(np.empty_like(m_bs))
np.multiply(2, m_bs_p, pout)
self.assertIsInstance(pout, la.pinvarray)
self.assertIsInstance(pout.pinv, la.lnarray)
with self.assertRaises(AttributeError):
m_bs_p.inv # pylint: disable=no-member,pointless-statement
with self.assertRaises(TypeError):
m_ss.inv.pinv # pylint: disable=pointless-statement
def test_inv_returns_expected_shapes(self, m_bb):
big = m_bb.shape
hy.assume(hn.all_well_behaved(m_bb))
# with self.subTest(msg='inv'):
self.assertArrayShape(gfl.inv(m_bb), big)
# with self.subTest(msg='inv,+lu'):
_, square_f, square_ip = gfl.inv_lu(m_bb)
self.assertArrayShapesAre(gfl.inv_lu(m_bb), (big, big, big[:-1]))
# with self.subTest(msg='inv,-lu'):
self.assertArrayShape(gfl.lu_inv(square_f, square_ip), big)
def test_solve_returns_expected_values(self, arrays):
m_ss, m_sb, m_bs = arrays
hy.assume(hn.all_well_behaved(m_ss))
cond = np.linalg.cond(m_ss).max()
x_sb = gfl.solve(m_ss, m_sb)
# with self.subTest(msg='solve'):
self.assertArrayAllClose(m_ss @ x_sb, m_sb, cond=cond)
x_bs = gfl.rsolve(m_bs, m_ss)
# with self.subTest(msg='rsolve'):
self.assertArrayAllClose(x_bs @ m_ss, m_bs, cond=cond)
def test_qr_returns_expected_values_with_tall(self, m_bs):
hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
cond = np.linalg.cond(m_bs).max()
unitary, right = gfl.qr_n(m_bs)
tall = unitary @ right
eye = la.dagger(unitary) @ unitary
id_s = np.identity(m_bs.shape[-1], m_bs.dtype)
# with self.subTest(msg='qr'):
self.assertArrayAllClose(tall, m_bs, cond=cond)
# with self.subTest(msg='Q^T Q'):
self.assertArrayAllClose(id_s, eye, cond=cond)
def test_lq_returns_expected_values_with_wide(self, m_sb):
hy.assume(hn.wide(m_sb))
hy.assume(hn.all_well_behaved(m_sb))
cond = np.linalg.cond(m_sb).max()
left, unitary = gfl.lq_m(m_sb)
wide = left @ unitary
eye = unitary @ la.dagger(unitary)
id_s = np.identity(m_sb.shape[-2], m_sb.dtype)
# with self.subTest(msg='lq'):
self.assertArrayAllClose(wide, m_sb, cond=cond)
# with self.subTest(msg='Q Q^T'):
self.assertArrayAllClose(id_s, eye, cond=cond)
def test_rsolve_returns_expected_shapes(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays
hy.assume(hn.nonsquare(m_sb))
hy.assume(hn.all_well_behaved(m_bb))
expect = utn.array_return_shape('(a,b),(b,b)->(a,b)', m_sb, m_bb)
self.assertArrayShape(gfl.rsolve(m_sb, m_bb), expect)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve(m_bs, m_bb)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve(m_bs, m_sb)
with self.assertRaisesRegex(*utn.broadcast_err):
gfl.rsolve(*utn.make_bad_broadcast(m_bs, m_ss))
def test_functions_solve(self, arrays):
m_ss, m_sb, m_bs = arrays[:-1]
v_s = hn.core_only(arrays[-1], dims=1)
smol, wide, tall = [arr.shape for arr in arrays[:-1]]
hy.assume(hn.all_well_behaved(m_ss))
# with self.subTest('solve'):
expect = gf.return_shape('(a,b),(b,c)->(a,c)', smol, wide)
self.assertArrayShape(la.solve(m_ss, m_sb), expect)
self.assertArrayShape(la.solve(m_ss, v_s), smol[:-1])
# with self.subTest('rsolve'):
expect = gf.return_shape('(a,b),(b,c)->(a,c)', tall, smol)
self.assertArrayShape(la.rsolve(m_bs, m_ss), expect)
self.assertArrayShape(la.rsolve(v_s, m_ss), smol[:-1])
def test_lq_l_returns_expected_values(self, arrays):
m_sb, m_bs = arrays
hy.assume(hn.all_well_behaved(m_bs, m_sb))
hy.assume(hn.wide(m_sb))
# with self.subTest(msg='l_m'):
cond = np.linalg.cond(m_sb).max()
left = gfl.lq_lm(m_sb)
llo = gfl.lq_m(m_sb)[0]
self.assertArrayAllClose(left, llo, cond=cond)
# with self.subTest(msg='l_n'):
cond = np.linalg.cond(m_bs).max()
left = gfl.lq_ln(m_bs)
llo = gfl.lq_n(m_bs)[0]
self.assertArrayAllClose(left, llo, cond=cond)
def test_qr_r_returns_expected_values(self, arrays):
m_sb, m_bs = arrays
hy.assume(hn.all_well_behaved(m_sb, m_bs))
hy.assume(hn.wide(m_sb))
# with self.subTest(msg='r_m'):
cond = np.linalg.cond(m_sb).max()
right = gfl.qr_rm(m_sb)
rrr = gfl.qr_m(m_sb)[1]
self.assertArrayAllClose(right, rrr, cond=cond)
# with self.subTest(msg='r_n'):
cond = np.linalg.cond(m_bs).max()
right = gfl.qr_rn(m_bs)
rrr = gfl.qr_n(m_bs)[1]
self.assertArrayAllClose(right, rrr, cond=cond)
def test_lu_solve_flexible_signature_with_vectors(self, arrays):
m_ss = arrays[0]
v_s, v_b = hn.core_only(*arrays[1:], dims=1)
hy.assume(len(v_s) != len(v_b))
hy.assume(hn.all_well_behaved(m_ss))
# with self.subTest('lu_solve'):
_, x_f, i_p = gfl.solve_lu(m_ss, v_s)
self.assertArrayShape(gfl.lu_solve(x_f, i_p, v_s), m_ss.shape[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.lu_solve(x_f, i_p, v_b)
# with self.subTest('rlu_solve'):
self.assertArrayShape(gfl.rlu_solve(v_s, x_f, i_p), m_ss.shape[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rlu_solve(v_b, x_f, i_p)
def test_rsolve_lu_returns_expected_values(self, arrays):
m_ss, m_sb, m_bs = arrays
hy.assume(hn.all_well_behaved(m_ss))
cond = np.linalg.cond(m_ss).max()
x0_bs = gfl.rsolve(m_bs, m_ss)
x_bs, x_f, i_p = gfl.rsolve_lu(m_bs, m_ss)
# with self.subTest('rsolve0'):
self.assertArrayAllClose(x_bs, x0_bs, cond=cond)
xx_bs = gfl.rlu_solve(m_bs, x_f, i_p)
# with self.subTest('rsolve(rlu)'):
self.assertArrayAllClose(xx_bs, x0_bs, cond=cond)
x_sb = gfl.lu_solve(x_f, i_p, m_sb)
# with self.subTest('solve(rlu)'):
self.assertArrayAllClose(m_ss @ x_sb, m_sb, cond=cond)
def test_solve_flexible_signature_with_vectors(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays[:-1]
v_s = hn.core_only(arrays[-1], dims=1)
hy.assume(hn.nonsquare(m_sb))
hy.assume(hn.all_well_behaved(m_ss))
off_b, y_one = utn.make_off_by_one(m_bb, m_sb)
# with self.subTest('solve'):
self.assertArrayShape(gfl.solve(m_ss, v_s), m_ss.shape[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.solve(m_bb, v_s)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.solve(m_bs, v_s)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as Mv:
gfl.solve(m_bb[off_b], m_sb[y_one])
def test_lq_returns_expected_values_with_tall(self, m_bs):
hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
cond = np.linalg.cond(m_bs).max()
left, unitary = gfl.lq_n(m_bs)
tall = left @ unitary
eye = unitary @ la.dagger(unitary)
eyet = la.dagger(unitary) @ unitary
id_s = np.identity(m_bs.shape[-1], m_bs.dtype)
# with self.subTest(msg='lq'):
self.assertArrayAllClose(tall, m_bs, cond=cond)
# with self.subTest(msg='Q Q^T'):
self.assertArrayAllClose(id_s, eye, cond=cond)
# with self.subTest(msg='Q^T Q'):
self.assertArrayAllClose(id_s, eyet, cond=cond)
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_rsolve_lu_flexible_signature_with_vectors(self, arrays):
m_ss, m_sb, m_bb = arrays[:-1]
v_s = hn.core_only(arrays[-1], dims=1)
hy.assume(hn.nonsquare(m_sb))
hy.assume(hn.all_well_behaved(m_ss))
# with self.subTest('rsolve_lu'):
self.assertArrayShapesAre(gfl.rsolve_lu(
v_s, m_ss), (m_ss.shape[:-1], m_ss.shape, m_ss.shape[:-1]))
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve_lu(v_s, m_bb)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve_lu(v_s, m_sb)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as vM:
gfl.rsolve_lu(m_sb, m_ss)
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_rsolve_lu_returns_expected_shapes(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays
hy.assume(hn.nonsquare(m_sb))
hy.assume(hn.all_well_behaved(m_bb))
expect = utn.array_return_shape('(a,b),(b,b)->(a,b)', m_sb, m_bb)
expect_f = expect[:-2] + m_bb.shape[-2:]
result = gfl.rsolve_lu(m_sb, m_bb)
self.assertArrayShapesAre(result, (expect, expect_f, expect_f[:-1]))
self.assertArrayShapesAre(unbroadcast_factors(m_bb, *result[1:]),
(m_bb.shape, m_bb.shape[:-1]))
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve_lu(m_bs, m_bb)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rsolve_lu(m_bs, m_sb)
with self.assertRaisesRegex(*utn.broadcast_err):
gfl.rsolve_lu(*utn.make_bad_broadcast(m_bs, m_ss))
def test_functions_solve(self, arrays):
m_ss, m_sb, m_bs = arrays
hy.assume(hn.all_well_behaved(m_ss))
cond = np.linalg.cond(m_ss).max()
# with self.subTest('solve'):
self.assertArrayAllClose(la.solve(m_ss, m_sb),
gf.solve(m_ss, m_sb),
cond=cond)
slv_sh = utn.array_return_shape('(a,a),(a,b)->(a,b)', m_ss, m_sb)
slv_out = np.empty(slv_sh, m_ss.dtype)
slv_r = la.solve(m_ss, m_sb, out=slv_out)
self.assertArrayAllClose(slv_out, slv_r)
# with self.subTest('rsolve'):
self.assertArrayAllClose(la.rsolve(m_bs, m_ss),
gf.rsolve(m_bs, m_ss),
cond=cond)
def test_functions_matrdiv(self, arrays):
m_ss, m_sb, m_bs = arrays[:-2]
v_s, v_b = hn.core_only(*arrays[-2:], dims=1)
smol, wide, tall = [arr.shape for arr in arrays[:-2]]
hy.assume(hn.all_well_behaved(m_ss))
hy.assume(hn.wide(m_sb))
# with self.subTest('rsolve'):
expect = gf.return_shape('(a,b),(c,b)->(a,c)', tall, smol)
self.assertArrayShape(la.matrdiv(m_bs, m_ss), expect)
self.assertArrayShape(la.matrdiv(v_s, m_ss), smol[:-1])
# with self.subTest('rlstsq'):
expect = gf.return_shape('(a,b),(c,b)->(a,c)', smol, tall)
self.assertArrayShape(la.matrdiv(m_ss, m_bs), expect)
self.assertArrayShape(la.matrdiv(v_b, m_sb), wide[:-1])
self.assertArrayShape(la.matrdiv(m_ss, v_s), smol[:-1])
self.assertArrayShape(la.matrdiv(v_s, m_bs), tall[:-1])
def test_rlu_solve_flexible_signature_with_vectors(self, arrays):
m_ss, m_sb = arrays[:-2]
v_s, v_b = hn.core_only(*arrays[-2:], dims=1)
hy.assume(hn.nonsquare(m_sb))
hy.assume(hn.all_well_behaved(m_ss))
off_b, y_one = utn.make_off_by_one(m_ss, m_sb)
# with self.subTest('rlu_solve'):
_, x_f, i_p = gfl.rsolve_lu(v_s, m_ss)
self.assertArrayShape(gfl.rlu_solve(v_s, x_f, i_p), m_ss.shape[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rlu_solve(v_b, x_f, i_p)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as vM:
gfl.rlu_solve(m_sb[y_one], x_f[off_b], i_p[off_b])
self.assertArrayShape(gfl.lu_solve(x_f, i_p, v_s), m_ss.shape[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.lu_solve(x_f, i_p, v_b)
def test_inv_returns_expected_values(self, m_bb):
hy.assume(hn.all_well_behaved(m_bb))
cond = np.linalg.cond(m_bb).max()
# with self.subTest(msg='inv'):
id_b = np.identity(m_bb.shape[-1], m_bb.dtype)
square_i = gfl.inv(m_bb)
self.assertArrayAllClose(m_bb @ square_i, id_b, cond=cond)
self.assertArrayAllClose(square_i @ m_bb, id_b, cond=cond)
# with self.subTest(msg='inv,+lu'):
square_if, square_f, square_ip = gfl.inv_lu(m_bb)
luf, ipr = gfl.lu_rawn(m_bb)
self.assertArrayAllClose(square_if, square_i, cond=cond)
self.assertArrayAllClose(square_f, luf)
self.assertEqual(square_ip, ipr)
# with self.subTest(msg='inv,-lu'):
square_fi = gfl.lu_inv(square_f, square_ip)
self.assertArrayAllClose(square_fi, square_i, cond=cond)
def test_functions_matldiv(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays[:-1]
v_s = hn.core_only(arrays[-1], dims=1)
smol, wide, big, tall = [arr.shape for arr in arrays[:-1]]
hy.assume(hn.all_well_behaved(m_ss))
hy.assume(hn.wide(m_sb))
# with self.subTest('solve'):
expect = gf.return_shape('(a,b),(a,c)->(b,c)', smol, wide)
self.assertArrayShape(la.matldiv(m_ss, m_sb), expect)
self.assertArrayShape(la.matldiv(m_ss, v_s), smol[:-1])
# with self.subTest('lstsq'):
expect = gf.return_shape('(a,b),(a,c)->(b,c)', tall, big)
self.assertArrayShape(la.matldiv(m_bs, m_bb), expect)
expect = gf.return_shape('(a,b),(a,c)->(b,c)', wide, smol)
self.assertArrayShape(la.matldiv(m_sb, m_ss), expect)
self.assertArrayShape(la.matldiv(m_sb, v_s), utn.drop(wide))
self.assertArrayShape(la.matldiv(v_s, m_ss), smol[:-1])
def test_pinv_returns_expected_values_tall(self, m_bs):
hy.assume(hn.tall(m_bs))
hy.assume(hn.all_well_behaved(m_bs))
cond = np.linalg.cond(m_bs).max()
# with self.subTest(msg='tall'):
tall_p = gfl.pinv(m_bs)
id_s = np.identity(m_bs.shape[-1], m_bs.dtype)
self.assertArrayAllClose(tall_p @ m_bs, id_s, cond=cond)
# with self.subTest(msg='tall,+qr'):
tall_pq, tall_f, tall_tau = gfl.pinv_qrn(m_bs)
qrf, tau = gfl.qr_rawn(m_bs)
self.assertArrayAllClose(tall_pq, tall_p, cond=cond)
self.assertArrayAllClose(tall_f, qrf, cond=cond)
self.assertArrayAllClose(tall_tau, tau, cond=cond)
# with self.subTest(msg='tall,-qr'):
tall_qp = gfl.qr_pinv(tall_f, tall_tau)
self.assertArrayAllClose(tall_qp, tall_p, cond=cond)
def test_rqr_lstsq_returns_expected_shape_wide(self, arrays, fun):
m_ss, m_sb, m_bb, m_bs = arrays
hy.assume(hn.wide(m_sb))
hy.assume(hn.all_well_behaved(m_sb))
_, x_f, tau = fun(m_bb, m_sb)
expect = utn.array_return_shape('(n,m),(m,p)->(n,p)', x_f, m_ss)
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, m_ss), expect)
expect = utn.array_return_shape('(m,n),(n,p)->(m,p)', m_bb, x_f)
self.assertArrayShape(gfl.rqr_lstsq(m_bb, x_f, tau), expect)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.qr_lstsq(x_f, tau, m_bs)
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rqr_lstsq(m_bs, x_f, tau)
with self.assertRaisesRegex(*utn.broadcast_err):
gfl.qr_lstsq(x_f, *utn.make_bad_broadcast(tau, m_ss, (1, 2)))
x_f, tau = unbroadcast_factors(m_sb, x_f, tau)
expect = utn.array_return_shape('(m,n),(m,p)->(n,p)', m_sb, m_ss)
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, m_ss), expect)
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_functions_matrdiv(self, arrays):
m_ss, m_sb, m_bs = arrays[:-1]
v_b = hn.core_only(arrays[-1], dims=1)
hy.assume(hn.all_well_behaved(m_ss))
hy.assume(hn.wide(m_sb))
# with self.subTest('rsolve'):
cond = np.linalg.cond(m_ss).max()
self.assertArrayAllClose(la.matrdiv(m_bs, m_ss),
gf.rsolve(m_bs, m_ss),
cond=cond)
# with self.subTest('rlstsq'):
cond = np.linalg.cond(m_bs).max()
self.assertArrayAllClose(la.matrdiv(m_ss, m_bs),
gf.rlstsq(m_ss, m_bs),
cond=cond)
cond = np.linalg.cond(m_sb).max()
self.assertArrayAllClose(la.matrdiv(v_b, m_sb),
gf.rlstsq(v_b, m_sb),
cond=cond)
