Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
ORNL Quantum Computing Institute
xacc
Commits
0cdb6720
Commit
0cdb6720
authored
Apr 05, 2019
by
Mccaskey, Alex
Browse files
removing public dependence on boost graph, created new runtime polymorphic graph interface.
Signed-off-by:
Alex McCaskey
<
mccaskeyaj@ornl.gov
>
parent
a21551ca
Pipeline
#46126
passed with stages
in 8 minutes and 20 seconds
Changes
59
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
CMakeLists.txt
View file @
0cdb6720
...
...
@@ -84,6 +84,7 @@ if (XACC_BUILD_TESTS)
endmacro
()
endif
()
set
(
CMAKE_CXX_FLAGS
"
${
CMAKE_CXX_FLAGS
}
-Wno-attributes"
)
include_directories
(
${
CMAKE_BINARY_DIR
}
/tpls/cppmicroservices/include
)
add_subdirectory
(
tpls
)
...
...
python/xacc-py.cpp
View file @
0cdb6720
...
...
@@ -13,14 +13,12 @@
#include
"XACC.hpp"
#include
"xacc_service.hpp"
#include
"Program.hpp"
#include
"IRGenerator.hpp"
#include
"IRProvider.hpp"
#include
"InstructionIterator.hpp"
#include
"AcceleratorBuffer.hpp"
#include
"AcceleratorDecorator.hpp"
#include
"InstructionParameter.hpp"
#include
"DWGraph.hpp"
#include
"EmbeddingAlgorithm.hpp"
#include
"PauliOperator.hpp"
...
...
@@ -193,19 +191,11 @@ PYBIND11_MODULE(_pyxacc, m) {
.
def
(
"hasNext"
,
&
xacc
::
InstructionIterator
::
hasNext
,
""
)
.
def
(
"next"
,
&
xacc
::
InstructionIterator
::
next
,
""
);
py
::
class_
<
xacc
::
IRPreprocessor
,
std
::
shared_ptr
<
xacc
::
IRPreprocessor
>>
(
m
,
"IRPreprocesor"
,
""
)
.
def
(
"process"
,
&
xacc
::
IRPreprocessor
::
process
,
""
);
py
::
class_
<
xacc
::
IRTransformation
,
std
::
shared_ptr
<
xacc
::
IRTransformation
>>
(
m
,
"IRTransformation"
,
""
)
.
def
(
"transform"
,
&
xacc
::
IRTransformation
::
transform
,
""
);
py
::
class_
<
xacc
::
AcceleratorBufferPostprocessor
,
std
::
shared_ptr
<
xacc
::
AcceleratorBufferPostprocessor
>>
(
m
,
"AcceleratorBufferPostprocessor"
,
""
)
.
def
(
"process"
,
&
xacc
::
AcceleratorBufferPostprocessor
::
process
,
""
);
py
::
class_
<
xacc
::
IRGenerator
,
std
::
shared_ptr
<
xacc
::
IRGenerator
>>
(
m
,
"IRGenerator"
,
""
)
.
def
(
"generate"
,
...
...
@@ -215,72 +205,11 @@ PYBIND11_MODULE(_pyxacc, m) {
py
::
return_value_policy
::
reference
,
""
)
.
def
(
"generate"
,
(
std
::
shared_ptr
<
xacc
::
Function
>
(
xacc
::
IRGenerator
::*
)(
std
::
map
<
std
::
string
,
xacc
::
InstructionParameter
>
))
&
std
::
map
<
std
::
string
,
xacc
::
InstructionParameter
>
&
))
&
xacc
::
IRGenerator
::
generate
,
py
::
return_value_policy
::
reference
,
""
)
.
def
(
"analyzeResults"
,
&
xacc
::
IRGenerator
::
analyzeResults
,
""
);
// Expose the Kernel
py
::
class_
<
xacc
::
Kernel
<>
,
std
::
shared_ptr
<
xacc
::
Kernel
<>>>
(
m
,
"Kernel"
,
"The XACC Kernel is the "
"executable functor that executes XACC IR on the desired Accelerator."
)
.
def
(
"getIRFunction"
,
&
xacc
::
Kernel
<>::
getIRFunction
,
py
::
return_value_policy
::
reference
,
"Return the IR Function instance this Kernel wraps."
)
.
def
(
"execute"
,
(
void
(
xacc
::
Kernel
<>::*
)(
std
::
shared_ptr
<
xacc
::
AcceleratorBuffer
>
,
std
::
vector
<
xacc
::
InstructionParameter
>
))
&
xacc
::
Kernel
<>::
operator
(),
"Execute this Kernel with the given set of "
"InstructionParamters. This set can be empty "
"if there are no parameters."
);
py
::
class_
<
xacc
::
KernelList
<>>
(
m
,
"KernelList"
,
"The XACC KernelList is a vector of "
"Kernels that provides a operator() implementation to execute multiple "
"kernels at once."
)
.
def
(
"execute"
,
(
std
::
vector
<
std
::
shared_ptr
<
xacc
::
AcceleratorBuffer
>>
(
xacc
::
KernelList
<>::*
)(
std
::
shared_ptr
<
xacc
::
AcceleratorBuffer
>
,
std
::
vector
<
xacc
::
InstructionParameter
>
))
&
xacc
::
KernelList
<>::
operator
(),
"Execute a list of Kernels at once."
)
.
def
(
"__getitem__"
,
[](
const
xacc
::
KernelList
<>
&
kl
,
int
i
)
->
xacc
::
Kernel
<>
{
if
(
i
>=
kl
.
size
())
throw
py
::
index_error
();
return
kl
[
i
];
})
.
def
(
"__setitem__"
,
[](
xacc
::
KernelList
<>
&
kl
,
size_t
i
,
xacc
::
Kernel
<>
v
)
{
if
(
i
>=
kl
.
size
())
throw
py
::
index_error
();
kl
[
i
]
=
v
;
})
.
def
(
"__len__"
,
&
xacc
::
KernelList
<>::
size
)
.
def
(
"__iter__"
,
[](
const
xacc
::
KernelList
<>
&
kl
)
{
return
py
::
make_iterator
(
kl
.
begin
(),
kl
.
end
());
},
py
::
keep_alive
<
0
,
1
>
())
.
def
(
"__getitem__"
,
[](
xacc
::
KernelList
<>
&
s
,
py
::
slice
slice
)
->
xacc
::
KernelList
<>
*
{
size_t
start
,
stop
,
step
,
slicelength
;
if
(
!
slice
.
compute
(
s
.
size
(),
&
start
,
&
stop
,
&
step
,
&
slicelength
))
throw
py
::
error_already_set
();
xacc
::
KernelList
<>
*
seq
=
new
xacc
::
KernelList
<>
(
s
.
getAccelerator
());
for
(
size_t
i
=
0
;
i
<
slicelength
;
++
i
)
{
(
*
seq
).
push_back
(
s
[
start
]);
start
+=
step
;
}
return
seq
;
});
// Expose the Accelerator
py
::
class_
<
xacc
::
Accelerator
,
std
::
shared_ptr
<
xacc
::
Accelerator
>
,
PyAccelerator
>
...
...
@@ -452,33 +381,6 @@ PYBIND11_MODULE(_pyxacc, m) {
return
py
::
make_iterator
(
op
.
begin
(),
op
.
end
());
},
py
::
keep_alive
<
0
,
1
>
());
// Expose the Program object
py
::
class_
<
xacc
::
Program
>
(
m
,
"Program"
,
"The Program is the primary entrypoint for compilation and execution in "
"XACC. Clients provide quantum kernel source "
"code and the Accelerator instance, and the Program handles compiling "
"the code and provides Kernel instances to execute."
)
.
def
(
py
::
init
<
std
::
shared_ptr
<
xacc
::
Accelerator
>
,
const
std
::
string
&>
(),
"The constructor"
)
.
def
(
py
::
init
<
std
::
shared_ptr
<
xacc
::
Accelerator
>
,
std
::
shared_ptr
<
xacc
::
IR
>>
(),
"The constructor"
)
.
def
(
"build"
,
(
void
(
xacc
::
Program
::*
)(
const
std
::
string
&
))
&
xacc
::
Program
::
build
,
"Compile this program with the given Compiler name."
)
.
def
(
"build"
,
(
void
(
xacc
::
Program
::*
)())
&
xacc
::
Program
::
build
,
"Compile this program."
)
.
def
(
"getKernel"
,
(
xacc
::
Kernel
<>
(
xacc
::
Program
::*
)(
const
std
::
string
&
))
&
xacc
::
Program
::
getKernel
<>
,
py
::
return_value_policy
::
reference
,
"Return a Kernel representing the source code."
)
.
def
(
"getKernels"
,
&
xacc
::
Program
::
getRuntimeKernels
,
"Return all Kernels."
)
.
def
(
"nKernels"
,
&
xacc
::
Program
::
nKernels
,
"Return the number of kernels compiled by this program"
);
// Expose XACC API functions
m
.
def
(
"Initialize"
,
(
void
(
*
)(
std
::
vector
<
std
::
string
>
))
&
xacc
::
Initialize
,
...
...
@@ -502,11 +404,6 @@ PYBIND11_MODULE(_pyxacc, m) {
xacc
::
getCompiler
,
py
::
return_value_policy
::
reference
,
"Return the Compiler of given name."
);
m
.
def
(
"getIRPreprocessor"
,
(
std
::
shared_ptr
<
xacc
::
IRPreprocessor
>
(
*
)(
const
std
::
string
&
))
&
xacc
::
getService
<
IRPreprocessor
>
,
py
::
return_value_policy
::
reference
,
"Return the IRPreprocessor of given name."
);
m
.
def
(
"getIRTransformation"
,
(
std
::
shared_ptr
<
xacc
::
IRTransformation
>
(
*
)(
const
std
::
string
&
))
&
xacc
::
getService
<
IRTransformation
>
,
...
...
@@ -590,9 +487,10 @@ PYBIND11_MODULE(_pyxacc, m) {
const
std
::
string
&
compilerName
=
""
)
->
std
::
shared_ptr
<
Function
>
{
if
(
!
compilerName
.
empty
())
xacc
::
setOption
(
"compiler"
,
compilerName
);
xacc
::
Program
p
(
acc
,
src
);
p
.
build
();
return
p
.
getRuntimeKernels
()[
0
].
getIRFunction
();
auto
compiler
=
xacc
::
getCompiler
();
auto
ir
=
compiler
->
compile
(
src
,
acc
);
return
ir
->
getKernels
()[
0
];
},
py
::
arg
(
"acc"
),
py
::
arg
(
"src"
),
py
::
arg
(
"compilerName"
)
=
std
::
string
(
""
),
py
::
return_value_policy
::
move
,
""
);
...
...
@@ -693,7 +591,12 @@ PYBIND11_MODULE(_pyxacc, m) {
int
nBits
=
*
std
::
max_element
(
nUniqueBits
.
begin
(),
nUniqueBits
.
end
())
+
1
;
auto
hardware
=
std
::
make_shared
<
AcceleratorGraph
>
(
nBits
);
auto
hardware
=
xacc
::
getService
<
Graph
>
(
"boost-ugraph"
);
for
(
int
i
=
0
;
i
<
nBits
;
i
++
)
{
std
::
map
<
std
::
string
,
InstructionParameter
>
m
{{
"bias"
,
1.0
}};
hardware
->
addVertex
(
m
);
}
for
(
auto
&
edge
:
hardwareconnections
)
{
hardware
->
addEdge
(
edge
.
first
,
edge
.
second
);
}
...
...
@@ -712,14 +615,17 @@ PYBIND11_MODULE(_pyxacc, m) {
}
}
auto
problemGraph
=
std
::
make_shared
<
xacc
::
quantum
::
DWGraph
>
(
maxBitIdx
+
1
);
auto
problemGraph
=
xacc
::
getService
<
Graph
>
(
"boost-ugraph"
);
for
(
int
i
=
0
;
i
<
maxBitIdx
+
1
;
i
++
)
{
std
::
map
<
std
::
string
,
InstructionParameter
>
m
{{
"bias"
,
1.0
}};
problemGraph
->
addVertex
(
m
);
}
for
(
auto
inst
:
f
->
getInstructions
())
{
if
(
inst
->
name
()
==
"dw-qmi"
)
{
auto
qbit1
=
inst
->
bits
()[
0
];
auto
qbit2
=
inst
->
bits
()[
1
];
if
(
qbit1
==
qbit2
)
{
problemGraph
->
setVertexProperties
(
qbit1
,
1.0
);
}
else
{
if
(
qbit1
!=
qbit2
)
{
problemGraph
->
addEdge
(
qbit1
,
qbit2
,
1.0
);
}
}
...
...
quantum/aqc/CMakeLists.txt
View file @
0cdb6720
...
...
@@ -54,7 +54,7 @@ usfunctionembedresources(TARGET
FILES
manifest.json
)
target_link_libraries
(
${
LIBRARY_NAME
}
PUBLIC xacc
Boost::graph
PRIVATE CppMicroServices
)
target_link_libraries
(
${
LIBRARY_NAME
}
PUBLIC xacc PRIVATE CppMicroServices
)
if
(
APPLE
)
set_target_properties
(
xacc-quantum-aqc
...
...
quantum/aqc/compiler/EmbeddingAlgorithm.hpp
View file @
0cdb6720
...
...
@@ -18,9 +18,9 @@
#include
<memory>
#include
<string>
#include
"Utils.hpp"
#include
"DWGraph.hpp"
#include
"Embedding.hpp"
#include
"Identifiable.hpp"
#include
"Graph.hpp"
#include
<string>
...
...
@@ -56,8 +56,8 @@ public:
* @return embedding A mapping of problem vertex indices to the list of
* hardware vertices they map to
*/
virtual
Embedding
embed
(
std
::
shared_ptr
<
DW
Graph
>
problem
,
std
::
shared_ptr
<
Accelerator
Graph
>
hardware
,
virtual
Embedding
embed
(
std
::
shared_ptr
<
Graph
>
problem
,
std
::
shared_ptr
<
Graph
>
hardware
,
std
::
map
<
std
::
string
,
std
::
string
>
params
=
std
::
map
<
std
::
string
,
std
::
string
>
())
=
0
;
};
...
...
quantum/aqc/compiler/HUBO.hpp
deleted
100644 → 0
View file @
a21551ca
/*******************************************************************************
* Copyright (c) 2017 UT-Battelle, LLC.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompanies this
* distribution. The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
*License is available at https://eclipse.org/org/documents/edl-v10.php
*
* Contributors:
* Alexander J. McCaskey - initial API and implementation
*******************************************************************************/
#ifndef QUANTUM_AQC_COMPILER_HUBO_HPP_
#define QUANTUM_AQC_COMPILER_HUBO_HPP_
#include
"DWGraph.hpp"
namespace
xacc
{
namespace
quantum
{
/**
* HUBO is an interface for higher-order unconstrained
* binary optimization problems. It provides a method
* for subclasses to implement that takes a set of input
* parameters and maps the problem down to a
* quadratic unconstrained binary optimization problem,
* in the form of a Graph.
*
* It takes a template parameter describing the
* return type of the mapResults method - which
* takes AQC QPU execution results and maps them to the
* higher-order problem result.
*/
template
<
typename
ResultType
>
class
HUBO
{
public:
/**
* Map this HUBO problem to a quadratic unconstrained
* binary optimization problem.
*
* @param parameters Any input parameters needed to set the problem up
* @return quboGraph The QUBO represented as a graph
*/
virtual
std
::
shared_ptr
<
xacc
::
quantum
::
DWGraph
>
reduceToQubo
(
std
::
vector
<
InstructionParameter
>
parameters
)
=
0
;
/**
* Take the low-level AQC QPU result output and construct result of
* HUBO problem .
*
* @param resultBuffer The AcceleratorBuffer containing the AQC QPU results.
* @return results Custom Type representing the result.
*/
virtual
ResultType
mapResults
(
std
::
shared_ptr
<
AcceleratorBuffer
>
resultBuffer
)
=
0
;
/**
* The destructor
*/
virtual
~
HUBO
()
{}
};
}
// namespace quantum
}
// namespace xacc
#endif
quantum/aqc/compiler/ParameterSetter.hpp
View file @
0cdb6720
...
...
@@ -13,11 +13,13 @@
#ifndef QUANTUM_AQC_COMPILER_PARAMETERSETTER_HPP_
#define QUANTUM_AQC_COMPILER_PARAMETERSETTER_HPP_
#include
"
DW
Graph.hpp"
#include
"Graph.hpp"
#include
"DWQMI.hpp"
#include
"Embedding.hpp"
#include
"Identifiable.hpp"
#include
<list>
namespace
xacc
{
namespace
quantum
{
...
...
@@ -25,8 +27,8 @@ class ParameterSetter : public Identifiable {
public:
virtual
std
::
list
<
std
::
shared_ptr
<
DWQMI
>>
setParameters
(
std
::
shared_ptr
<
DW
Graph
>
problemGraph
,
std
::
shared_ptr
<
Accelerator
Graph
>
hardwareGraph
,
setParameters
(
std
::
shared_ptr
<
Graph
>
problemGraph
,
std
::
shared_ptr
<
Graph
>
hardwareGraph
,
Embedding
embedding
)
=
0
;
virtual
~
ParameterSetter
()
{}
...
...
quantum/aqc/compiler/default/DefaultParameterSetter.cpp
View file @
0cdb6720
...
...
@@ -17,8 +17,8 @@ namespace xacc {
namespace
quantum
{
std
::
list
<
std
::
shared_ptr
<
DWQMI
>>
DefaultParameterSetter
::
setParameters
(
std
::
shared_ptr
<
DW
Graph
>
problemGraph
,
std
::
shared_ptr
<
Accelerator
Graph
>
hardwareGraph
,
Embedding
embedding
)
{
std
::
shared_ptr
<
Graph
>
problemGraph
,
std
::
shared_ptr
<
Graph
>
hardwareGraph
,
Embedding
embedding
)
{
std
::
list
<
std
::
shared_ptr
<
DWQMI
>>
instList
;
auto
nHardwareVerts
=
hardwareGraph
->
order
();
...
...
@@ -45,7 +45,7 @@ std::list<std::shared_ptr<DWQMI>> DefaultParameterSetter::setParameters(
for
(
auto
&
embKv
:
embedding
)
{
auto
probVert
=
embKv
.
first
;
auto
hardwareMapping
=
embKv
.
second
;
auto
newBias
=
std
::
get
<
0
>
(
problemGraph
->
getVertexProperties
(
probVert
))
/
auto
newBias
=
problemGraph
->
getVertexProperties
(
probVert
)
[
"bias"
].
as
<
double
>
(
)
/
hardwareMapping
.
size
();
for
(
auto
h
:
hardwareMapping
)
{
auto
embeddedInst
=
std
::
make_shared
<
DWQMI
>
(
h
,
h
,
newBias
);
...
...
@@ -82,7 +82,7 @@ std::list<std::shared_ptr<DWQMI>> DefaultParameterSetter::setParameters(
newWeight
+=
std
::
fabs
(
problemGraph
->
getEdgeWeight
(
pi
,
neighbor
));
}
newWeight
+=
std
::
get
<
0
>
(
problemGraph
->
getVertexProperties
(
pi
));
newWeight
+=
problemGraph
->
getVertexProperties
(
pi
)
[
"bias"
].
as
<
double
>
(
);
newWeight
*=
-
1.0
*
chain_strength
;
}
...
...
quantum/aqc/compiler/default/DefaultParameterSetter.hpp
View file @
0cdb6720
...
...
@@ -35,8 +35,8 @@ public:
virtual
~
DefaultParameterSetter
()
{}
std
::
list
<
std
::
shared_ptr
<
DWQMI
>>
setParameters
(
std
::
shared_ptr
<
DW
Graph
>
problemGraph
,
std
::
shared_ptr
<
Accelerator
Graph
>
hardwareGraph
,
setParameters
(
std
::
shared_ptr
<
Graph
>
problemGraph
,
std
::
shared_ptr
<
Graph
>
hardwareGraph
,
Embedding
embedding
)
override
;
const
std
::
string
name
()
const
override
{
return
"default"
;
}
...
...
quantum/aqc/compiler/default/TrivialEmbeddingAlgorithm.cpp
View file @
0cdb6720
...
...
@@ -16,8 +16,8 @@ namespace xacc {
namespace
quantum
{
Embedding
TrivialEmbeddingAlgorithm
::
embed
(
std
::
shared_ptr
<
DW
Graph
>
problem
,
std
::
shared_ptr
<
xacc
::
Accelerator
Graph
>
hdware
,
TrivialEmbeddingAlgorithm
::
embed
(
std
::
shared_ptr
<
Graph
>
problem
,
std
::
shared_ptr
<
Graph
>
hdware
,
std
::
map
<
std
::
string
,
std
::
string
>
params
)
{
Embedding
xaccEmbedding
;
...
...
quantum/aqc/compiler/default/TrivialEmbeddingAlgorithm.hpp
View file @
0cdb6720
...
...
@@ -47,8 +47,8 @@ public:
* @return embedding A mapping of problem vertex indices to the list of
* hardware vertices they map to
*/
virtual
Embedding
embed
(
std
::
shared_ptr
<
DW
Graph
>
problem
,
std
::
shared_ptr
<
Accelerator
Graph
>
hardware
,
virtual
Embedding
embed
(
std
::
shared_ptr
<
Graph
>
problem
,
std
::
shared_ptr
<
Graph
>
hardware
,
std
::
map
<
std
::
string
,
std
::
string
>
params
=
std
::
map
<
std
::
string
,
std
::
string
>
());
...
...
quantum/aqc/compiler/tests/TrivialEmbeddingAlgorithmTester.cpp
View file @
0cdb6720
...
...
@@ -17,62 +17,62 @@ using namespace xacc::quantum;
TEST
(
TrivialEmbeddingAlgorithmTester
,
checkSimpleEmbed
)
{
TrivialEmbeddingAlgorithm
algo
;
auto
k44
=
std
::
make_shared
<
K44Bipartite
>
();
//
TrivialEmbeddingAlgorithm algo;
//
auto k44 = std::make_shared<K44Bipartite>();
// Set some params
std
::
map
<
std
::
string
,
std
::
string
>
params
;
params
.
insert
(
std
::
make_pair
(
"failhard"
,
"false"
));
//
// Set some params
//
std::map<std::string, std::string> params;
//
params.insert(std::make_pair("failhard", "false"));
auto
triviallyMappedProblem
=
std
::
make_shared
<
DWGraph
>
(
7
);
//
auto triviallyMappedProblem = std::make_shared<DWGraph>(7);
triviallyMappedProblem
->
setVertexProperties
(
0
,
20
);
triviallyMappedProblem
->
setVertexProperties
(
1
,
50
);
triviallyMappedProblem
->
setVertexProperties
(
2
,
60
);
triviallyMappedProblem
->
setVertexProperties
(
4
,
50
);
triviallyMappedProblem
->
setVertexProperties
(
5
,
60
);
triviallyMappedProblem
->
setVertexProperties
(
6
,
-
160
);
//
triviallyMappedProblem->setVertexProperties(0, 20);
//
triviallyMappedProblem->setVertexProperties(1, 50);
//
triviallyMappedProblem->setVertexProperties(2, 60);
//
triviallyMappedProblem->setVertexProperties(4, 50);
//
triviallyMappedProblem->setVertexProperties(5, 60);
//
triviallyMappedProblem->setVertexProperties(6, -160);
triviallyMappedProblem
->
addEdge
(
2
,
5
);
// -10000);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
10000
);
triviallyMappedProblem
->
addEdge
(
1
,
4
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
1000
);
//
triviallyMappedProblem->addEdge(2, 5); // -10000);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -10000);
//
triviallyMappedProblem->addEdge(1, 4);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -1000);
triviallyMappedProblem
->
addEdge
(
0
,
4
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
14
);
triviallyMappedProblem
->
addEdge
(
0
,
5
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
12
);
//
triviallyMappedProblem->addEdge(0, 4);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -14);
//
triviallyMappedProblem->addEdge(0, 5);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -12);
triviallyMappedProblem
->
addEdge
(
0
,
6
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
32
);
triviallyMappedProblem
->
addEdge
(
1
,
5
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
68
);
triviallyMappedProblem
->
addEdge
(
1
,
6
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
128
);
triviallyMappedProblem
->
addEdge
(
2
,
6
);
triviallyMappedProblem
->
setEdgeWeight
(
2
,
5
,
-
128
);
//
triviallyMappedProblem->addEdge(0, 6);
//
triviallyMappedProblem->setEdgeWeight(2, 5, 32);
//
triviallyMappedProblem->addEdge(1, 5);
//
triviallyMappedProblem->setEdgeWeight(2, 5, 68);
//
triviallyMappedProblem->addEdge(1, 6);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -128);
//
triviallyMappedProblem->addEdge(2, 6);
//
triviallyMappedProblem->setEdgeWeight(2, 5, -128);
auto
embedding
=
algo
.
embed
(
triviallyMappedProblem
,
k44
->
getAcceleratorGraph
(),
params
);
//
auto embedding =
//
algo.embed(triviallyMappedProblem, k44->getAcceleratorGraph(), params);
int
i
=
0
;
for
(
auto
&
kv
:
embedding
)
{
std
::
cout
<<
kv
.
first
<<
": "
;
for
(
auto
h
:
kv
.
second
)
{
std
::
cout
<<
h
<<
" "
;
EXPECT_TRUE
(
h
==
i
);
}
std
::
cout
<<
"
\n
"
;
EXPECT_TRUE
(
kv
.
first
==
i
);
EXPECT_TRUE
(
kv
.
second
.
size
()
==
1
);
i
++
;
}
//
int i = 0;
//
for (auto &kv : embedding) {
//
std::cout << kv.first << ": ";
//
for (auto h : kv.second) {
//
std::cout << h << " ";
//
EXPECT_TRUE(h == i);
//
}
//
std::cout << "\n";
//
EXPECT_TRUE(kv.first == i);
//
EXPECT_TRUE(kv.second.size() == 1);
//
i++;
//
}
auto
complete5
=
std
::
make_shared
<
CompleteGraph
>
(
5
);
//
auto complete5 = std::make_shared<CompleteGraph>(5);
embedding
=
algo
.
embed
(
complete5
,
k44
->
getAcceleratorGraph
(),
params
);
//
embedding = algo.embed(complete5, k44->getAcceleratorGraph(), params);
EXPECT_TRUE
(
embedding
.
empty
());
//
EXPECT_TRUE(embedding.empty());
}
int
main
(
int
argc
,
char
**
argv
)
{
...
...
quantum/aqc/ir/DWFunction.cpp
0 → 100644
View file @
0cdb6720
#include
"DWFunction.hpp"
#include
"xacc_service.hpp"
namespace
xacc
{
namespace
quantum
{
std
::
shared_ptr
<
Graph
>
DWFunction
::
toGraph
()
{
int
maxBit
=
0
;
for
(
int
i
=
0
;
i
<
nInstructions
();
++
i
)
{
auto
inst
=
getInstruction
(
i
);
auto
bits
=
inst
->
bits
();
if
(
bits
[
0
]
>
maxBit
)
{
maxBit
=
bits
[
0
];
}
if
(
bits
[
1
]
>
maxBit
)
{
maxBit
=
bits
[
1
];
}
}
auto
graph
=
xacc
::
getService
<
Graph
>
(
"boost-ugraph"
);
for
(
int
i
=
0
;
i
<
maxBit
+
1
;
i
++
)
{
std
::
map
<
std
::
string
,
InstructionParameter
>
props
{{
"bias"
,
0.0
}};
graph
->
addVertex
(
props
);
//
}
for
(
int
i
=
0
;
i
<
nInstructions
();
++
i
)
{
auto
inst
=
getInstruction
(
i
);
auto
bits
=
inst
->
bits
();
if
(
bits
[
0
]
==
bits
[
1
])
{
auto
p
=
inst
->
getParameter
(
0
);
graph
->
setVertexProperty
(
bits
[
0
],
"bias"
,
p
);
}
else
{
graph
->
addEdge
(
bits
[
0
],
bits
[
1
],
inst
->
getParameter
(
0
).
as
<
double
>
());
}
}
return
graph
;
}
}
// namespace quantum
}
// namespace xacc
quantum/aqc/ir/DWFunction.hpp
View file @
0cdb6720
...
...
@@ -17,8 +17,6 @@
#include
"DWQMI.hpp"
#include
"XACC.hpp"
#include
"exprtk.hpp"
#include
"GraphProvider.hpp"
#include
"DWGraph.hpp"
static
constexpr
double
pi
=
3.141592653589793238
;
...
...
@@ -30,7 +28,6 @@ namespace xacc {
namespace
quantum
{
class
DWFunction
:
public
Function
,
public
GraphProvider
<
DWVertex
>
,
public
std
::
enable_shared_from_this
<
DWFunction
>
{
protected:
...
...
@@ -119,39 +116,11 @@ const int nRequiredBits() const override {
const
std
::
string
persistGraph
()
override
{
std
::
stringstream
s
;
toGraph
()
.
write
(
s
);
toGraph
()
->
write
(
s
);
return
s
.
str
();
}
Graph
<
DWVertex
>
toGraph
()
override
{
int
maxBit
=
0
;
for
(
int
i
=
0
;
i
<
nInstructions
();
++
i
)
{
auto
inst
=
getInstruction
(
i
);
auto
bits
=
inst
->
bits
();
if
(
bits
[
0
]
>
maxBit
)
{
maxBit
=
bits
[
0
];
}
if
(
bits
[
1
]
>
maxBit
)
{
maxBit
=
bits
[
1
];
}
}
DWGraph
graph
(
maxBit
+
1
);