def test_isub(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
m = mat(testfunction, trialfunction, measure=measure)
mc = SparseMatrix(deepcopy(dict(m)), m.shape, m.scale)
m -= mc
assert np.linalg.norm(m.diags('csr').data) < 1e-10
m1 = SparseMatrix(deepcopy(dict(m)), m.shape)
m2 = SparseMatrix(deepcopy(dict(m)), m.shape)
m1 -= m2
assert m1.scale == 0.0
def test_sub(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
m = mat(testfunction, trialfunction, measure=measure)
mc = m - m
assert mc.scale == 0.0
m1 = SparseMatrix(copy(dict(m)), m.shape)
m2 = SparseMatrix(copy(dict(m)), m.shape)
mc = m1 - m2
assert mc.scale == 0.0
def test_eq():
m0 = SparseMatrix({0: 1, 2: 2}, (6, 6))
m1 = SparseMatrix({0: 1., 2: 2.}, (6, 6))
assert m0 == m1
assert m0 is not m1
m2 = SparseMatrix({0: 1., 2: 3.}, (6, 6))
assert m0 != m2
def test_solve(quad):
SD = Basis(N, 'C', bc=(0, 0), quad=quad, plan=True)
u = TrialFunction(SD)
v = TestFunction(SD)
A = inner(div(grad(u)), v)
b = np.ones(N)
u_hat = Function(SD)
u_hat = A.solve(b, u=u_hat)
w_hat = Function(SD)
B = SparseMatrix(dict(A), (N - 2, N - 2))
w_hat[:-2] = B.solve(b[:-2], w_hat[:-2])
assert np.all(abs(w_hat[:-2] - u_hat[:-2]) < 1e-8)
ww = w_hat[:-2].repeat(N - 2).reshape((N - 2, N - 2))
bb = b[:-2].repeat(N - 2).reshape((N - 2, N - 2))
ww = B.solve(bb, ww, axis=0)
assert np.all(
abs(ww - u_hat[:-2].repeat(N - 2).reshape((N - 2, N - 2))) < 1e-8)
bb = bb.transpose()
ww = B.solve(bb, ww, axis=1)
assert np.all(
abs(ww - u_hat[:-2].repeat(N - 2).reshape(
(N - 2, N - 2)).transpose()) < 1e-8)
def test_sub(key, mat, quad):
test = key[0]
trial = key[1]
m = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = m - m
assert mc.scale == 0.0
m1 = SparseMatrix(copy(dict(m)), m.shape)
m2 = SparseMatrix(copy(dict(m)), m.shape)
mc = m1 - m2
assert mc.scale == 0.0
def test_isub(key, mat, quad):
test = key[0]
trial = key[1]
m = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = copy(m)
m -= mc
assert m.scale == 0.0
m1 = SparseMatrix(copy(dict(m)), m.shape)
m2 = SparseMatrix(copy(dict(m)), m.shape)
m1 -= m2
assert m1.scale == 0.0
def test_mul2():
mat = SparseMatrix({0: 1}, (3, 3))
v = np.ones(3)
c = mat * v
assert np.allclose(c, 1)
mat = SparseMatrix({-2: 1, -1: 1, 0: 1, 1: 1, 2: 1}, (3, 3))
c = mat * v
assert np.allclose(c, 3)
SD = FunctionSpace(8, "L", bc=(0, 0), scaled=True)
u = shenfun.TrialFunction(SD)
v = shenfun.TestFunction(SD)
mat = inner(grad(u), grad(v))
z = Function(SD, val=1)
c = mat * z
assert np.allclose(c[:6], 1)
def test_add(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
m = mat(testfunction, trialfunction, measure=measure)
mc = m + m
assert mc.scale == 2.0 * m.scale
mat = SparseMatrix(copy(dict(m)), m.shape, m.scale)
mc = m + mat
for key, val in mc.items():
assert np.allclose(val * mc.scale, m[key] * 2 * m.scale)
def test_imul(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
mat = mat(testfunction, trialfunction, measure=measure)
mc = mat.scale
mat *= 2
assert mat.scale == 2.0 * mc
mat.scale = mc
mat = SparseMatrix(copy(dict(mat)), mat.shape)
mat *= 2
assert mat.scale == 2.0
def test_iadd(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
if trial[0] in lBasisLG + cBasisGC and quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
try:
m = mat(testfunction, trialfunction, measure=measure)
except AssertionError:
return
mc = SparseMatrix(deepcopy(dict(m)), m.shape, m.scale)
m += mc
assert np.linalg.norm((m - 2 * mc).diags('csr').data) < 1e-8
m -= 2 * mc
assert np.linalg.norm(m.diags('csr').data) < 1e-10
def test_div(key, mat, quad):
test = key[0]
trial = key[1]
measure = 1
if len(key) == 4:
domain = key[2]
measure = key[3]
if quad == 'GL':
return
if trial[0] in lBasisLG + cBasisGC and quad == 'GL':
return
t0 = test[0]
t1 = trial[0]
if len(key) == 4:
t0 = functools.partial(t0, domain=domain)
t1 = functools.partial(t1, domain=domain)
testfunction = (t0(N, quad=quad), test[1])
trialfunction = (t1(N, quad=quad), trial[1])
try:
m = mat(testfunction, trialfunction, measure=measure)
except AssertionError:
return
mc = m / 2.
assert mc.scale == 0.5 * m.scale
mat = SparseMatrix(copy(dict(m)), m.shape)
mc = mat / 2.
assert mc.scale == 0.5
def test_iadd(key, mat, quad):
test = key[0]
trial = key[1]
m = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = copy(m)
m += mc
assert m.scale == 2.0*mc.scale
m1 = SparseMatrix(copy(dict(mc)), mc.shape)
m += m1
assert m.scale == 1
assert m.__class__.__name__ == 'SparseMatrix' # downcast
m -= 2*mc
assert m == m1
m2 = SparseMatrix(copy(dict(m)), m.shape)
m1 += m2
assert m1.scale == 2.0
def test_rmul(key, mat, quad):
test = key[0]
trial = key[1]
m = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = m*2.
assert mc.scale == 2.0*m.scale
mat = SparseMatrix(copy(dict(m)), m.shape)
mc = mat*2.
assert mc.scale == 2.0
def test_add(key, mat, quad):
test = key[0]
trial = key[1]
m = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = m + m
assert mc.scale == 2.0*m.scale
mat = SparseMatrix(copy(dict(m)), m.shape, m.scale)
mc = m + mat
for key, val in mc.items():
assert np.allclose(val*mc.scale, m[key]*2*m.scale)
def test_imul(key, mat, quad):
test = key[0]
trial = key[1]
mat = mat((test[0](N, quad=quad), test[1]),
(trial[0](N, quad=quad), trial[1]))
mc = mat.scale
mat *= 2
assert mat.scale == 2.0*mc
mat.scale = mc
mat = SparseMatrix(copy(dict(mat)), mat.shape)
mat *= 2
assert mat.scale == 2.0
