def test_setproblem_singular_values_problem_1(self):
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=1)
U, S, VT = sp.svd(problem.A)
# Zhang & Du - Example 1
#Sigmaorig = 10.0 + 2.0*np.random.rand(10)
assert_array_less(S, 12 * np.ones((10, )))
assert_array_less(10 * np.ones((10, )), S)
def test_setproblem_known_solution_problem_1(self):
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=1)
#Xsol = np.eye(n,p)
#Xsol = np.random.permutation(Xsol)
# Generate B
#B = np.dot(A, np.dot(Xsol, C))
assert_allclose(problem.B, np.dot(problem.A, \
np.dot(problem.Xsol, problem.C)))
def test_setproblem_singular_values_problem_2(self):
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=2)
U, S, VT = sp.svd(problem.A)
S = np.sort(S)
# Zhang & Du - Example 3
Sigmaorig = np.zeros(min(10, 10))
for i in range(0, min(10, 10)):
Sigmaorig[i] = 1.0 + (99.0 * float(i - 1)) / (float(10) - 1.0)
Sigmaorig = np.sort(np.abs(Sigmaorig))
assert_allclose(Sigmaorig, S, rtol=2.0)
def test_gpi_solver_known_solution_small(self):
A = np.eye(10, 10)
C = np.eye(2, 2)
B = np.ones((10, 2))
problem = skp.ProcrustesProblem((10, 10, 2, 2), matrices=(A, B, C))
mysolver = skp.GPISolver()
result = mysolver.solve(problem)
assert_allclose(result.fun, 13.055728090000844)
assert_equal(result.nbiter, 2)
assert_equal(result.nfev, 3)
def test_eb_solver_known_solution_small(self):
A = np.eye(10, 10)
C = np.eye(2, 2)
B = np.ones((10, 2))
problem = skp.ProcrustesProblem((10, 10, 2, 2), matrices=(A, B, C))
mysolver = skp.EBSolver()
result = mysolver.solve(problem)
assert_allclose(result.fun, 3.6132711066291225)
assert_equal(result.nbiter, 1)
assert_equal(result.nfev, 2)
def test_spectral_solver_known_solution_spg_small(self):
A = np.eye(10, 10)
C = np.eye(2, 2)
B = np.ones((10, 2))
problem = skp.ProcrustesProblem((10, 10, 2, 2), matrices=(A, B, C))
mysolver = skp.SPGSolver()
result = mysolver.solve(problem)
assert_allclose(result.fun, 13.055728090000844)
assert_allclose(result.normgrad, 2.0330196556284077e-14)
assert_equal(result.nbiter, 1)
assert_equal(result.nfev, 2)
def test_spectral_solver_known_solution_gkb_small(self):
A = np.eye(10, 10)
C = np.eye(2, 2)
B = np.ones((10, 2))
problem = skp.ProcrustesProblem((10, 10, 2, 2), matrices=(A, B, C))
mysolver = skp.GKBSolver()
result = mysolver.solve(problem)
assert_allclose(result.fun, 13.055728090000844) # local minimizer
assert_allclose(result.normgrad, 3.8845908793929472e-15)
assert_equal(result.blocksteps, 1)
assert_allclose(result.nbiter, 0.8)
assert_allclose(result.nfev, 1.2)
def test_setproblem_singular_values_problem_3(self):
problem = skp.ProcrustesProblem((50, 50, 5, 5), problemnumber=3)
U, S, VT = sp.svd(problem.A)
S = np.sort(S)
# Zhang & Du - Example 4
n1, n2, n3, n4 = (15, 15, 12, 8)
vaux = np.zeros((50, ))
vaux[0:n1] = 10.0
vaux[n1:n1 + n2] = 5.0
vaux[n1 + n2:n1 + n2 + n3] = 2.0
vaux[n1 + n2 + n3:] = 0
Sigma = np.sort(vaux)
assert_allclose(Sigma, S, rtol=1.0)
def test_setproblem_dimensions(self):
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=1)
assert_equal(problem.A.shape[0], 10)
assert_equal(problem.A.shape[1], 10)
assert_equal(problem.B.shape[0], 10)
assert_equal(problem.B.shape[1], 2)
assert_equal(problem.C.shape[0], 2)
assert_equal(problem.C.shape[1], 2)
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=2)
assert_equal(problem.A.shape[0], 10)
assert_equal(problem.A.shape[1], 10)
assert_equal(problem.B.shape[0], 10)
assert_equal(problem.B.shape[1], 2)
assert_equal(problem.C.shape[0], 2)
assert_equal(problem.C.shape[1], 2)
problem = skp.ProcrustesProblem((50, 50, 5, 5), problemnumber=3)
assert_equal(problem.A.shape[0], 50)
assert_equal(problem.A.shape[1], 50)
assert_equal(problem.B.shape[0], 50)
assert_equal(problem.B.shape[1], 5)
assert_equal(problem.C.shape[0], 5)
assert_equal(problem.C.shape[1], 5)
def test_gpi_solver_known_solution_problem_2(self):
A = np.asarray([[7.256898668268666697e+00, -2.573732000807788012e+01,\
6.009589673994661929e+00, -2.416566316285056715e+01],
[-1.050865070883216568e+01, 8.728310568335615471e+00,\
-2.396564993299465485e+00, 6.567064275964866304e+00],\
[-2.563405505463448009e+01, -1.522485768408047591e+01,\
1.057260685036533232e+01, 9.924230068539865002e+00],\
[6.125480264795922558e+00, -1.513009768260202392e+01,\
-5.846843858482707823e+00, 6.273222470266802731e+01]])
B = np.asarray([[7.256898668268666697e+00, 6.009589673994661929e+00],
[-1.050865070883216568e+01, -2.396564993299465485e+00],
[-2.563405505463448009e+01, 1.057260685036533232e+01],
[6.125480264795922558e+00, -5.846843858482707823e+00]])
C = np.eye(2, 2)
problem = skp.ProcrustesProblem((4, 4, 2, 2), matrices=(A, B, C))
mysolver = skp.GPISolver()
result = mysolver.solve(problem)
assert_allclose(result.nfev, 80)
assert_allclose(result.fun, 4.320064300629071e-06)
def test_gpi_solver_known_solution_problem_1(self):
A = np.asarray([[5.520962350152090359e+00, -6.793095607530246660e+00, \
-2.968126930397382957e+00, 5.215698321012116168e+00],
[-6.775745407471069015e+00, 1.822680160805416616e+00,\
-4.224183825647802593e+00, 7.178797488759216527e+00],
[6.355695000758535329e+00, 8.514938821664049584e+00,\
4.926367379292874715e-01, 3.889893914905437455e+00],
[-6.186446461568055888e-01, -8.111306483700752024e-01,\
9.932080492258702265e+00, 4.599731376522814053e+00]])
B = np.asarray([[-6.793095607530246660e+00, 5.215698321012116168e+00],
[1.822680160805416616e+00, 7.178797488759216527e+00],
[8.514938821664049584e+00, 3.889893914905437455e+00],
[-8.111306483700752024e-01, 4.599731376522814053e+00]])
C = np.eye(2, 2)
problem = skp.ProcrustesProblem((4, 4, 2, 2), matrices=(A, B, C))
mysolver = skp.GPISolver()
result = mysolver.solve(problem)
assert_allclose(result.nfev, 7)
assert_allclose(result.fun, 5.868725008379679e-07)
def test_blockbidiag(self):
# m = 3
# n = 3
# q = 3
# nsteps = 1
# partial = 0
# A = np.array([[0,2,1],[1,1,2],[0,0,3]])
# B = np.copy(A)
# Qtrue = np.array([[0,1,0],[1,0,0],[0,0,1]])
# Rtrue = np.array([[1,1,2],[0,2,1],[0,0,3]])
m, n, p, q = (6, 6, 2, 2)
nsteps = 0
partial = 0
Qtrue = np.array([[1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0]])
Rtrue = np.array([[1, 2, 3, 4, 5, 6], [0, 1, 2, 3, 4, 5],
[0, 0, 1, 2, 3, 4], [0, 0, 0, 1, 2, 3],
[0, 0, 0, 0, 1, 2], [0, 0, 0, 0, 0, 1]])
A = np.dot(Qtrue, Rtrue)
B = np.dot(A, np.ones((n, p)))
C = np.eye(p, q)
U = np.zeros((m, m))
V = np.zeros((n, n))
T = np.zeros((m, n + q))
problem = skp.ProcrustesProblem((m, n, p, q), matrices=(A, B, C))
U, V, T, B1, reorth = skp.blockbidiag(problem, U, V, T, nsteps,
partial)
# print("\nT = {}\n".format(T[0:largedim, 0:smalldim]))
# print("U = {}\n".format(U[0:m, 0:largedim]))
# print("V = {}\n".format(V[0:n, 0:smalldim]))
# print("T - UT*A*V = {}\n".format(T[0:largedim, 0:smalldim] - np.dot(U[0:m, 0:largedim].T, np.dot(A, V[0:n, 0:smalldim]))))
maxerror = np.max(T[:, 0:n] - np.dot(U.T, np.dot(A, V)))
assert_allclose(maxerror, 3.081431772960419e-15)
def test_spectral_solver_known_solution_gkb_problem_2(self):
A = np.asarray([[-4.955319052527563883e+00, 9.490698890235075069e+00, \
3.871013427009882690e+01, -2.407812454150707637e+01],
[1.459652616043183571e+01, 5.183996942308650269e+00, \
1.750998867584864627e+01, -3.465157159361613992e+01],
[-3.176193070766883864e+01, -1.488163256103923615e+01,\
-1.834308690911770512e+01, -3.493231059965589580e+00],
[1.386947318465110079e+01, -3.622322069989070137e+00, \
2.796986231299064318e+00, -3.324889768560630898e+01]])
B = np.asarray([[3.871013427009882690e+01, 9.490698890235075069e+00],
[1.750998867584864627e+01, 5.183996942308650269e+00],
[-1.834308690911770512e+01, -1.488163256103923615e+01],
[2.796986231299064318e+00, -3.622322069989070137e+00]])
C = np.eye(2, 2)
problem = skp.ProcrustesProblem((4, 4, 2, 2), matrices=(A, B, C))
mysolver = skp.GKBSolver()
result = mysolver.solve(problem)
assert_allclose(result.nbiter, 28)
assert_allclose(result.nfev, 46)
assert_allclose(result.fun, 1.940760937201845e-13)
assert_allclose(result.normgrad, 0.00010351602115043701)
def test_spectral_solver_known_solution_gkb_problem_1(self):
problem = skp.ProcrustesProblem((100, 100, 10, 10), problemnumber=1)
mysolver = skp.GKBSolver()
result = mysolver.solve(problem)
assert_array_less(result.blocksteps, 7)
def test_spectral_solver_known_solution_spg_problem_1(self):
problem = skp.ProcrustesProblem((100, 100, 10, 10), problemnumber=1)
mysolver = skp.SPGSolver()
result = mysolver.solve(problem)
assert_array_less(result.nbiter, 8)
def setUp(self):
self.problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=1)
def test_setproblem_known_solution_problem_2(self):
problem = skp.ProcrustesProblem((10, 10, 2, 2), problemnumber=2)
assert_allclose(problem.B, np.dot(problem.A, \
np.dot(problem.Xsol, problem.C)))
def test_setproblem_known_solution_problem_3(self):
problem = skp.ProcrustesProblem((50, 50, 5, 5), problemnumber=3)
assert_allclose(problem.B, np.dot(problem.A, \
np.dot(problem.Xsol, problem.C)))
