def dense_graph_calculate_hamiltonian(W, dtype = None) :
""" Calculate hamiltonian from given QUBO.
Args:
numpy.ndarray W : QUBO, W should be a upper/lower triangular or symmetric matrix.
numpy.dtype dtype : Numerical precision, numpy.float32 or numpy.float64.
Returns:
tuple: tuple containing Hamiltonian.
h(vector as numpy.array), J(2-D symmetric matrix as numpy.array), c(scalar value)
"""
checkers.dense_graph.qubo(W)
W = symmetrize(W)
N = W.shape[0]
h = np.ndarray((N), dtype=np.float64)
W4 = - 0.25 * W
for i in range(N) :
h[i] = - 0.5 * np.sum(W[i])
c = np.sum(W4) + np.sum(W4.diagonal())
J = W4
for i in range(0, N) :
J[i][i] = 0
return h, J, c
def dense_graph_calculate_E_from_spin(cext, cobj, h, J, c, q, dtype):
h, J = common.fix_type([h, J], dtype)
J = common.symmetrize(J)
q = common.fix_type(q, np.int8)
checkers.dense_graph.hJc(h, J, c)
checkers.dense_graph.q(J, q)
E = np.ndarray((1), dtype)
cext.dense_graph_calculate_E_from_spin(cobj, E, h, J, c, q, dtype)
return E[0]
def dense_graph_batch_calculate_E_from_spin(cext, cobj, h, J, c, q, dtype):
h, J = common.fix_type([h, J], dtype)
J = common.symmetrize(J)
if len(q.shape) == 1:
q = q.reshape(1, -1)
checkers.dense_graph.hJc(h, J, c)
checkers.dense_graph.qbatch(J, q)
E = np.empty([q.shape[0]], dtype)
cext.dense_graph_batch_calculate_E_from_spin(cobj, E, h, J, c, q, dtype)
return E
def dense_graph_calculate_hamiltonian(cext, cobj, W, dtype):
W = common.fix_type(W, dtype)
W = common.symmetrize(W)
checkers.dense_graph.qubo(W)
N = W.shape[0]
h = np.empty((N), dtype)
J = np.empty((N, N), dtype)
c = np.empty((1), dtype)
cext.dense_graph_calculate_hamiltonian(cobj, h, J, c, W, dtype)
return h, J, c[0]
def dense_graph_calculate_E(cext, cobj, W, x, dtype):
W = common.fix_type(W, dtype)
W = common.symmetrize(W)
x = common.fix_type(x, np.int8)
checkers.dense_graph.qubo(W)
checkers.dense_graph.x(W, x)
E = np.ndarray((1), dtype)
cext.dense_graph_calculate_E(cobj, E, W, x, dtype)
return E[0]
def dense_graph_batch_calculate_E(cext, cobj, W, x, dtype):
W = common.fix_type(W, dtype)
W = common.symmetrize(W)
x = common.fix_type(x, np.int8)
if len(x.shape) == 1:
x = x.reshape(1, -1)
checkers.dense_graph.qubo(W)
checkers.dense_graph.xbatch(W, x)
E = np.empty((x.shape[0]), dtype)
cext.dense_graph_batch_calculate_E(cobj, E, W, x, dtype)
return E
def set_qubo(self, W, optimize = sqaod.minimize) :
""" set QUBO.
Args:
numpy.ndarray W :
QUBO matrix. W should be a sqaure matrix.
Upper/Lower triangular matrices or symmetric matrices are accepted.
optimize : optimize direction, `sqaod.maximize, sqaod.minimize <preference.html#sqaod-maximize-sqaod-minimize>` """
checkers.dense_graph.qubo(W)
W = symmetrize(W)
N = W.shape[0]
self._W = optimize.sign(W)
self._N = N
self._x = []
self._optimize = optimize
def dense_graph_calculate_E_from_spin(h, J, c, q, dtype = None) :
""" Calculate desne graph QUBO energy from spins.
Args:
(numpy.ndarray) h, J, c : Hamiltonian h(1-D vector), W(sqauare matrix), c(scalar).
W must be a upper/lower triangular or symmetric matrix.
q (numpy.ndarray) : array of spin {-1, 1}.
numpy.dtype dtype : Numerical precision, numpy.float32 or numpy.float64
Returns:
floating point number : QUBO energy
"""
checkers.dense_graph.hJc(h, J, c)
checkers.dense_graph.q(J, q)
J = symmetrize(J)
return - c - np.dot(h, q) - np.dot(q, np.matmul(J, q.T))
def set_hamiltonian(self, h, J, c):
""" set Hamiltonian.
Args:
numpy.ndarray : h(vector), J(matrix)
floating point number : c
Shapes for h, J must be (N), (N, N) where N is problem size.
J must be a upper/lower triangular or symmetric matrix.
"""
checkers.dense_graph.hJc(h, J, c)
J = symmetrize(J)
self._optimize = sqaod.minimize
self._h, self._J, self._c = h, J, c
self._N = J.shape[0]
self._m = self._N // 2
def set_qubo(self, W, optimize=sqaod.minimize):
""" set QUBO.
Args:
numpy.ndarray W :
QUBO matrix. W should be a sqaure matrix.
Upper/Lower triangular matrices or symmetric matrices are accepted.
optimize : optimize direction, `sqaod.maximize, sqaod.minimize <preference.html#sqaod-maximize-sqaod-minimize>` """
checkers.dense_graph.qubo(W)
W = symmetrize(W)
h, J, c = formulas.dense_graph_calculate_hamiltonian(W)
self._optimize = optimize
self._h, self._J, self._c = optimize.sign(h), optimize.sign(
J), optimize.sign(c)
self._N = W.shape[0]
self._m = self._N // 2
def dense_graph_batch_calculate_E_from_spin(h, J, c, q, dtype = None) :
""" Batched version of the function to calculate dense graph QUBO energy from spins.
Args:
numpy.ndarray h, J, c : Hamiltonian h(1-D vector), W(sqauare matrix), c(scalar).
W must be a upper/lower triangular or symmetric matrix.
numpy.ndarray q :
bit arrays repsesented as 2-D matrix(n_trotters x n_bits).
numpy.dtype dtype : Numerical precision, numpy.float32 or numpy.float64.
Returns:
QUBO energy
"""
checkers.dense_graph.hJc(h, J, c)
checkers.dense_graph.qbatch(J, q)
J = symmetrize(J)
if len(q.shape) == 1:
q = q.reshape(1, -1)
return - c - np.matmul(h, q.T) - np.sum(q.T * np.matmul(J, q.T), 0)
def dense_graph_batch_calculate_E(W, x, dtype = None) :
""" Batched version of the function to calculate dense graph QUBO energy from bits.
Args:
numpy.ndarray W: QUBO, W should be a upper/lower triangular or symmetric matrix.
numpy.ndarray x:
bit arrays repsesented as 2-D matrix(n_trotters x n_bits).
numpy.dtype dtype : Numerical precision, numpy.float32 or numpy.float64
Returns:
QUBO energy
"""
checkers.dense_graph.qubo(W)
checkers.dense_graph.xbatch(W, x)
W = symmetrize(W)
if len(x.shape) == 1:
x = x.reshape(1, -1)
return np.sum(x * np.matmul(W, x.T).T, 1)
def dense_graph_calculate_E(W, x, dtype = None) :
""" Calculate desne graph QUBO energy from bits.
Args:
numpy.array W: QUBO, W should be a upper/lower triangular or symmetric matrix.
numpy.ndarray x : array of bit {0, 1}.
numpy.dtype dtype : Numerical precision, numpy.float32 or numpy.float64.
Returns:
QUBO energy
"""
checkers.dense_graph.qubo(W)
checkers.dense_graph.x(W, x)
W = symmetrize(W)
if len(x.shape) != 1 :
if x.shape[0] != 1 :
raise Exception('Wrong dimention of x')
x = x.reshape(-1)
return np.dot(x, np.matmul(W, x.T))