File coordinate_types.hpp#
-
namespace busclique
Typedefs
-
typedef size_t size_y#
-
typedef size_t size_x#
-
typedef size_t size_w#
-
typedef size_t size_z#
Functions
-
inline const size_t &coordinate_index(const size_t &c)#
-
inline const size_t &vert(const size_t &c)#
-
inline const size_t &horz(const size_t &c)#
-
constexpr uint64_t operator""_u64(unsigned long long int v)#
user-defined literal for uint64_t
-
constexpr uint32_t operator""_u32(unsigned long long int v)#
user-defined literal for uint32_t
-
constexpr uint16_t operator""_u16(unsigned long long int v)#
user-defined literal for uint16_t
-
constexpr uint8_t operator""_u8(unsigned long long int v)#
user-defined literal for uint8_t
-
class coordinate_converter
- #include <coordinate_types.hpp>
An arena to perform arithmetic that does not respect the unit system defined in coordinate_base<T>.
This class is not a friend of coordinate_base<T> so so that we can do all of our bounds-checking here, with full type-safety. The generic pattern is that bounds-checking is done inside a public method, respecting the unit systems, and then we explicitly convert coordinates and dimensions to size_t, to be combined in a private method with the _impl suffix.
Public Static Functions
-
static inline size_t cell_index(size_y y, size_x x, bool u, size_y dim_y, size_x dim_x)
This computes compute the index of A[u][y][x] in an array A of dimension [2][dim_y][dim_x]
-
static inline size_t cell_index(bool u, size_w w, size_z z, size_y dim_y, size_x dim_x)
This computes compute the index of A[u][y][x] in an array A of dimension [2][dim_y][dim_x]; where y and x are determined from w and z, depending on the orientation u.
-
template<typename shore_t>
static inline size_t chimera_linear(size_y y, size_x x, bool u, shore_t k, size_y dim_y, size_x dim_x, shore_t shore) given a chimera coordinate (y, x, u, k) with chimera dimensions (m, n, t) = (dim_y, dim_x, shore), compute the linear index.
-
template<typename shore_t>
static inline void linear_chimera(size_t q0, size_y &y, size_x &x, bool &u, shore_t &k, size_y dim_y, size_x dim_x, shore_t shore) given a linear index q0 in a chimera graph with dimensions (m, n, t) = (dim_y, dim_x, shore), compute the coordinate (y, x, u, k)
-
template<typename shore_t>
static inline size_t linemajor_linear(bool u, size_w w, shore_t k, size_z z, size_w dim_w, shore_t shore, size_z dim_z) Pegasus and Zephyr coordinates exist in relative coordinate systems.
We note that our implementation of Zephyr coordinates differs from the one used other places — we’ve merged the k and j indices into one. The name ‘linemajor’ indicates that the (u, w, k) parameters specify a line of colinear qubits. This function is used to pack a Zephyr or Pegasus coordinate address (u, w, k, z) into a linear index. The interpretation of dim_w, shore, and dim_z is determined by the relevant topology, and we expect callers to know what they’re doing. Specifically, for pegasus_graph(m), dim_w = 6*m, shore = 2, dim_z = m-1 and for zephyr_graph(m), dim_w = 2*m+1, shore=2*t, dim_z = m
-
template<typename shore_t>
static inline void linear_linemajor(size_t q0, bool &u, size_w &w, shore_t &k, size_z &z, size_w dim_w, shore_t shore, size_z dim_z) Pegasus and Zephyr coordinates exist in relative coordinate systems.
We note that our implementation of Zephyr coordinates differs from the one used other places — we’ve merged the k and j indices into one. The name ‘linemajor’ indicates that the (u, w, k) parameters specify a line of colinear qubits. This function is used to unpack a Zephyr or Pegasus linear index to a coordinate address (u, w, k, z). The interpretation of dim_w, shore, and dim_z is determined by the relevant topology, and we expect callers to know what they’re doing. Specifically, for pegasus_graph(m), dim_w = 6*m, shore = 2, dim_z = m-1 and for zephyr_graph(m), dim_w = 2*m+1, shore=2*t, dim_z = m
-
template<typename T, typename ...Args>
static inline size_t product(T t, Args... args) explicitly convert all arguments into a size_t and return the product of them all.
-
template<typename T, typename ...Args>
static inline size_t sum(T t, Args... args) explicitly convert all arguments into a size_t and return the product of them all.
-
template<typename S, typename T>
static inline size_t min(S s, T t) explicitly convert both arguments into a size_t and return the minimum
-
template<typename S, typename T>
static inline size_t max(S s, T t) explicitly convert both arguments into a size_t and return the maximum
-
static inline size_t grid_index(size_y y, size_x x, size_y dim_y, size_x dim_x)
Implements addressing into a 2-dimensional array T[dim_y][dim_x].
-
static inline size_t bundle_cache_index(bool u, size_w w, size_z z0, size_z z1, size_t stride_u, size_t stride_w)
This addressing scheme is wikkid complicated.
The majority of the logic is contained in bundle_cache.hpp. We store line masks (that is, sets of k-indices) corresponding to the line segment (u, w, z0, z1). That is, if the bit i is set in line_mask[bundle_cache_index(u, w, z0, z1)], then line of qubits [(u, w, i, z) for z in range(z0, z1+1)] and the necessary external couplers are present in the linemajor representation of the topology. We assume that the caller knows what it’s doing with stride_u and stride_w. We do belts-and-suspenders assertion testing in bundle_cache::compute_line_masks for added confidence that the caller actually knows what it’s doing.
Private Static Functions
-
static inline size_t cell_index_impl(size_t y, size_t x, size_t u, size_t dim_y, size_t dim_x)#
private implementation of cell_index
-
static inline size_t chimera_linear_impl(size_t y, size_t x, size_t u, size_t k, size_t dim_y, size_t dim_x, size_t shore)#
private implementation of chimera_linear
-
static inline size_t linemajor_linear_impl(size_t u, size_t w, size_t k, size_t z, size_t dim_w, size_t shore, size_t dim_z)#
private implementation of linemajor_linear
-
static inline size_t grid_index_impl(size_t y, size_t x, size_t dim_y, size_t dim_x)#
private implementation of grid_index
-
static inline size_t bundle_cache_index_impl(size_t u, size_t w, size_t z0, size_t z1, size_t stride_u, size_t stride_w)#
private implementation of bundle_cache_index
-
static inline size_t cell_index(size_y y, size_x x, bool u, size_y dim_y, size_x dim_x)
-
typedef size_t size_y#