def test_map_numpy_types(self):
self.assertEqual(
map_tuples(np.array([1, 2, 3], dtype=np.int32)),
[1, 2, 3]
)
self.assertEqual(
map_tuples(np.array([1., 2., 3.], dtype=np.single)),
[1., 2., 3.]
)
def test_map_ndarray(self):
self.assertEqual(map_tuples(np.array([1, 2, 3])), [1, 2, 3])
tuples = [(0, 'Zero'), (1, 'One')]
tuples_array = np.empty(len(tuples), dtype=object)
tuples_array[:] = tuples
self.assertEqual(map_tuples(tuples_array), [{
'@type': 'tuple',
'Item1': 0,
'Item2': 'Zero'
}, {
'@type': 'tuple',
'Item1': 1,
'Item2': 'One'
}])
def test_map_deep_tuple(self):
actual = {
'foo': [1, 3.14, (42, 'baz')],
'bar': {
'a': ('a', 'a'),
'b': ()
}
}
expected = {
'foo': [1, 3.14, {
'@type': 'tuple',
'item1': 42,
'item2': 'baz'
}],
'bar': {
'a': {
'@type': 'tuple',
'item1': 'a',
'item2': 'a'
},
'b': {
'@type': 'tuple'
}
}
}
self.assertEqual(map_tuples(actual), expected)
def add_terms(self, fermion_terms : Iterable[Tuple[List[int], float]]) -> None:
"""
Adds terms to the fermion Hamiltonian.
"""
logger.info(f"Adding {len(fermion_terms)} terms to fermion Hamiltonian.")
args = { 'hamiltonian': self.__dict__, 'fermion_terms': fermion_terms }
args_json = json.dumps(map_tuples(args))
result = qsharp.client._execute(f'%chemistry.fh.add_terms {args_json}', raise_on_stderr=True)
self.__dict__ = result
def encode(hamiltonian : FermionHamiltonian, input_state : InputState) -> Tuple:
"""
Encodes the given Hamiltonian and input state using the Jordan Wigner encoding
that can be used to run chemistry simulations using Q#'s chemistry library.
"""
logger.info(f"Doing jw encoding.")
args = { 'hamiltonian': hamiltonian.__dict__, 'input_state': input_state.__dict__ }
args_json = json.dumps(map_tuples(args))
data = qsharp.client._execute(f'%chemistry.encode {args_json}', raise_on_stderr=True)
return data
def load_fermion_hamiltonian(self, index_convention : IndexConvention = IndexConvention.UpDown) -> FermionHamiltonian:
"""
Loads the fermion Hamiltonian associated with this electronic structure problem.
`index_convention` can be 'UpDown' or 'HalfUp'
"""
logger.info(f"Loading fermion Hamiltonian from problem description using index_convention '{index_convention.name}'.")
args = { 'problem_description': self.__dict__, 'index_convention': index_convention.name }
args_json = json.dumps(map_tuples(args))
data = qsharp.client._execute(f'%chemistry.fh.load {args_json}', raise_on_stderr=True)
return FermionHamiltonian(data)
def load_fermion_hamiltonian(file_name: str, index_convention : IndexConvention = IndexConvention.UpDown) -> FermionHamiltonian:
"""
Loads the fermion Hamiltonian from the given file that contains broombridge data.
`index_convention` can be 'UpDown' or 'HalfUp'
"""
logger.info(f"Loading fermion Hamiltonian from '{file_name}' using index_convention '{index_convention.name}'.")
args = { 'file_name': file_name, 'index_convention': index_convention.name }
args_json = json.dumps(map_tuples(args))
data = qsharp.client._execute(f'%chemistry.fh.load {args_json}', raise_on_stderr=True)
return FermionHamiltonian(data)
def test_roundtrip_very_deep_tuple(self):
actual = {
'a': {
'b': ({
'c': ('d', ['e', ('f', 'g', 12, False)])
}, ['h', {
'g': ('i', 'j')
}])
}
}
self.assertEqual(unmap_tuples(map_tuples(actual)), actual)
def load_input_state(file_name: str, wavefunction_label : str = None, index_convention : IndexConvention = IndexConvention.UpDown) -> FermionHamiltonian:
"""
Loads the input state associated with the given labe from the given file that contains broombridge data..
If `wavefunction_label` is not specified, it loads the greedy (Hartree–Fock) state.
`index_convention` can be 'UpDown' or 'HalfUp'
"""
logger.info(f"Loading input state '{wavefunction_label}' from '{file_name}' using index_convention '{index_convention.name}'.")
args = { 'file_name': file_name, 'wavefunction_label': wavefunction_label, 'index_convention': index_convention.name }
args_json = json.dumps(map_tuples(args))
data = qsharp.client._execute(f'%chemistry.inputstate.load {args_json}', raise_on_stderr=True)
return InputState(data)
def load_input_state(self, wavefunction_label ='', index_convention : IndexConvention = IndexConvention.UpDown) -> FermionHamiltonian:
"""
Loads the input state associated from this electronic structure problem with the corresponding label.
If `wavefunction_label` is not specified, it loads the greedy (Hartree-Fock) state.
`index_convention` can be 'UpDown' or 'HalfUp'
"""
logger.info(f"Loading input state '{wavefunction_label}' from problem description using index_convention '{index_convention.name}'.")
args = { 'problem_description': self.__dict__, 'wavefunction_label': wavefunction_label, 'index_convention': index_convention.name }
args_json = json.dumps(map_tuples(args))
data = qsharp.client._execute(f'%chemistry.inputstate.load {args_json}', raise_on_stderr=True)
return InputState(data)
def test_roundtrip_deep_tuple(self):
actual = ('a', ('b', 'c'))
self.assertEqual(unmap_tuples(map_tuples(actual)), actual)
def test_roundtrip_dict(self):
actual = {'a': 'b', 'c': ('d', 'e')}
self.assertEqual(unmap_tuples(map_tuples(actual)), actual)
def test_roundtrip_shallow_tuple(self):
actual = ('a', 3.14, False)
self.assertEqual(unmap_tuples(map_tuples(actual)), actual)
def test_map_shallow_tuple(self):
self.assertEqual(map_tuples((42, 'foo')), {
'@type': 'tuple',
'item1': 42,
'item2': 'foo'
})
