def test_functions_lstsq(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays[:-1]
v_b = hn.core_only(arrays[-1], dims=1)
hy.assume(hn.wide(m_sb))
cond_sb = np.linalg.cond(m_sb).max()
cond_bs = np.linalg.cond(m_bs).max()
# with self.subTest('lstsq'):
self.assertArrayAllClose(la.lstsq(m_bs, m_bb),
gf.lstsq(m_bs, m_bb),
cond=cond_bs)
self.assertArrayAllClose(la.lstsq(m_sb, m_ss),
gf.lstsq(m_sb, m_ss),
cond=cond_sb)
lsq_sh = utn.array_return_shape('(a,b),(a,c)->(b,c)', m_bs, m_bb)
lsq_out = np.empty(lsq_sh, m_bs.dtype)
lsq_r = la.lstsq(m_bs, m_bb, out=lsq_out)
self.assertArrayAllClose(lsq_out, lsq_r)
# with self.subTest('rlstsq'):
self.assertArrayAllClose(la.rlstsq(m_ss, m_bs),
gf.rlstsq(m_ss, m_bs),
cond=cond_bs)
self.assertArrayAllClose(la.rlstsq(v_b, m_sb),
gf.rlstsq(v_b, m_sb),
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_rmatmul_flexible_signature_with_vectors(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays[:-2]
v_s, v_b = hn.core_only(*arrays[-2:], dims=1)
smol, wide, big, tall = [arr.shape for arr in arrays[:-2]]
hy.assume(hn.nonsquare(m_sb))
off_b, y_one = utn.make_off_by_one(m_sb, m_sb)
# with self.subTest('matrix-vector'):
self.assertArrayShape(self.gfm.rmatmul(v_s, m_bs), tall[:-1])
self.assertArrayShape(self.gfm.rmatmul(v_b, m_sb), wide[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
self.gfm.rmatmul(v_b, m_bs)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as Mv:
self.gfm.rmatmul(m_sb[y_one], m_sb[off_b])
# w\ith self.subTest('vector-matrix'):
self.assertArrayShape(self.gfm.rmatmul(m_ss, v_s), smol[:-1])
self.assertArrayShape(self.gfm.rmatmul(m_bb, v_b), big[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
self.gfm.rmatmul(m_bs, v_s)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as vM:
self.gfm.rmatmul(m_sb[off_b], m_sb[y_one])
# with self.subTest('vector-vector'):
self.assertArrayShape(self.gfm.rmatmul(v_b, v_b), ())
with self.assertRaisesRegex(*utn.core_dim_err):
self.gfm.rmatmul(v_b, v_s)
def test_rlstsq_flexible_signature_with_vectors_mv(self, arrays):
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))
self.assertArrayShape(gfl.rlstsq(m_sb, v_b), wide[:-1])
self.assertArrayShape(gfl.rlstsq(m_bs, v_s), tall[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rlstsq(m_bs, v_b)
def test_lstsq_flexible_signature_with_vectors_vm(self, arrays):
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.nonsquare(m_sb))
self.assertArrayShape(gfl.lstsq(v_s, m_sb), utn.drop(wide))
self.assertArrayShape(gfl.lstsq(v_b, m_bs), utn.drop(tall))
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.lstsq(v_s, m_bs)
def test_rlstsq_qr_flexible_signature_with_vectors_mv(self, arrays, fun):
m_sb, m_bs = arrays[:-1]
wide = m_sb.shape
v_b = hn.core_only(arrays[-1], dims=1)
hy.assume(hn.wide(m_sb))
hy.assume(la.norm(v_b) > 0.)
tau = m_sb.shape[:-2] + tau_len_vec(v_b, fun)
self.assertArrayShapesAre(fun(m_sb, v_b),
(wide[:-1], utn.drop(wide), tau))
with self.assertRaisesRegex(*utn.core_dim_err):
fun(m_bs, v_b)
def test_rqr_lstsq_flexible_signature_with_vectors_mv(self, arrays, fun):
m_sb, m_bs = hn.core_only(*arrays[:-1])
v_s = hn.core_only(arrays[-1], dims=1)
wide, tall = [arr.shape[-2:] for arr in arrays[:-1]]
hy.assume(hn.wide(m_sb))
hy.assume(la.norm(v_s) > 0.)
_, x_f, tau = fun(m_bs, v_s)
expect = utn.array_return_shape('(m,n),(n,p)->(m,p)', m_bs, m_sb)[:-1]
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, m_sb), expect)
self.assertArrayShape(gfl.rqr_lstsq(m_bs, x_f, tau), tall[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.qr_lstsq(x_f, tau, m_bs)
self.assertArrayShape(gfl.rqr_lstsq(v_s, x_f, tau), tall[:-2])
m_sb, m_bs = arrays[:-1]
wide, tall = [arr.shape for arr in arrays[:-1]]
_, x_f, tau = fun(m_bs, v_s)
x_f, tau = unbroadcast_factors(v_s, x_f, tau)
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, m_sb), utn.drop(wide))
self.assertArrayShape(gfl.rqr_lstsq(m_bs, x_f, tau), tall[:-1])
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_rlstsq_flexible_signature_with_vectors_vm(self, arrays):
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))
off_b, y_one = utn.make_off_by_one(m_sb, m_bs)
self.assertArrayShape(gfl.rlstsq(v_b, m_sb), wide[:-1])
self.assertArrayShape(gfl.rlstsq(v_s, m_bs), tall[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rlstsq(v_b, m_bs)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as vM:
gfl.rlstsq(m_bs[y_one], m_sb[off_b])
def test_lnarray_operations_return_expected_values(self, arrays):
m_bs, m_ss, vec = view_as(*arrays)
m_bs_m = hn.core_only(m_bs)
vec = hn.core_only(vec, dims=1)
hy.assume(hn.tall(m_bs))
hy.assume(m_ss.ndim != 3) # causes np..solve's broadcasting issue
hy.assume(hn.all_well_behaved(m_ss, m_bs_m))
expect = utn.array_return_shape('(a,b),(b,c)->(a,c)', m_bs, m_ss)
ts_o = np.empty(expect, m_ss.dtype)
ts_r = la.matmul(m_bs, m_ss, ts_o)
self.assertArrayAllClose(ts_r, ts_o)
self.assertArrayAllClose(m_bs @ m_ss, np.matmul(m_bs, m_ss))
self.assertArrayAllClose(m_bs @ m_ss, np.matmul(m_bs, m_ss))
self.assertArrayAllClose(m_bs @ vec, np.matmul(m_bs, vec))
cond = np.linalg.cond(m_ss).max()
self.assertArrayAllClose(gf.solve(m_ss, vec),
nl.solve(m_ss, vec.c).uc,
cond=cond)
cond = np.linalg.cond(m_bs_m).max()
self.assertArrayAllClose(gf.lstsq(m_bs_m.t, vec),
nl.lstsq(m_bs_m.t, vec, rcond=None)[0],
cond=cond)
self.assertArrayAllClose(gf.rmatmul(m_ss, m_bs), np.matmul(m_bs, m_ss))
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_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_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_functions_matmul(self, arrays):
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]]
# with self.subTest('matmul'):
expect = gf.return_shape('(a,b),(b,c)->(a,c)', tall, wide)
self.assertArrayShape(la.matmul(m_bs, m_sb), expect)
self.assertArrayShape(la.matmul(m_bs, v_s), tall[:-1])
self.assertArrayShape(la.matmul(v_b, m_bs), utn.drop(tall))
self.assertArrayShape(la.matmul(v_s, v_s), ())
# with self.subTest('rmatmul'):
expect = gf.return_shape('(a,b),(b,c)->(a,c)', wide, tall)
self.assertArrayShape(gf.rmatmul(m_bs, m_sb), expect)
self.assertArrayShape(gf.rmatmul(m_sb, v_s), utn.drop(wide))
self.assertArrayShape(gf.rmatmul(v_b, m_sb), wide[:-1])
self.assertArrayShape(gf.rmatmul(v_b, v_b), ())
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_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_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_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_lstsq(self, arrays):
m_ss, m_sb, m_bb, m_bs = arrays[:-2]
v_s, v_b = hn.core_only(*arrays[-2:], dims=1)
smol, wide, big, tall = [arr.shape for arr in arrays[:-2]]
# with self.subTest('lstsq'):
expect = gf.return_shape('(a,b),(a,c)->(b,c)', tall, big)
self.assertArrayShape(la.lstsq(m_bs, m_bb), expect)
expect = gf.return_shape('(a,b),(a,c)->(b,c)', wide, smol)
self.assertArrayShape(la.lstsq(m_sb, m_ss), expect)
self.assertArrayShape(la.lstsq(m_sb, v_s), utn.drop(wide))
self.assertArrayShape(la.lstsq(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.rlstsq(m_ss, m_bs), expect)
expect = gf.return_shape('(a,b),(c,b)->(a,c)', big, wide)
self.assertArrayShape(la.rlstsq(m_bb, m_sb), expect)
self.assertArrayShape(la.rlstsq(v_b, m_sb), wide[:-1])
self.assertArrayShape(la.rlstsq(m_ss, v_s), smol[:-1])
self.assertArrayShape(la.rlstsq(v_s, m_bs), tall[:-1])
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)
def test_rqr_lstsq_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_bs, m_sb))
off_b, y_one = utn.make_off_by_one(m_sb, m_bs)
_, x_f, tau = fun(v_s, m_bs)
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, v_b), utn.drop(tall))
self.assertArrayShape(gfl.rqr_lstsq(v_s, x_f, tau), tall[:-1])
_, x_f, tau = fun(v_b, m_sb)
self.assertArrayShape(gfl.qr_lstsq(x_f, tau, v_s), utn.drop(wide))
self.assertArrayShape(gfl.rqr_lstsq(v_b, x_f, tau), wide[:-1])
with self.assertRaisesRegex(*utn.core_dim_err):
gfl.rqr_lstsq(v_s, x_f, tau)
with self.assertRaisesRegex(*utn.core_dim_err):
# This would succeed/broadcast error if interpreted as Mv:
gfl.rqr_lstsq(m_bs[y_one], x_f[off_b], tau[off_b])
