libqasm 0.5.2__cp38-cp38-win_amd64.whl → 0.6.1__cp38-cp38-win_amd64.whl

cqasm/v1x/error_model.py

@@ -1,41 +0,0 @@
-import cqasm.v1x.types
-
-class ErrorModel:
-    def __init__(self, name, types=None):
-        super().__init__()
-        self._name = str(name)
-        if types is None:
-            self._types = ()
-        else:
-            for typ in types:
-                if not isinstance(typ, cqasm.v1x.types.Node):
-                    raise TypeError('types must be an iterable of cqasm.v1x.types.Node if specified')
-            self._types = tuple(types)
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def types(self):
-        return self._types
-
-    def __str__(self):
-        return '{}({})'.format(self._name, ', '.join(map(str, self._types)))
-
-
-class ErrorModelRef(object):
-    def __init__(self, *args, **kwargs):
-        if not args and not kwargs:
-            self._data = None
-        elif len(args) == 1 and not kwargs and (isinstance(args[0], ErrorModel) or args[0] is None):
-            self._data = args[0]
-        else:
-            self._data = ErrorModel(*args, **kwargs)
-
-    @property
-    def data(self):
-        return self._data
-
-    def __str__(self):
-        return 'unresolved' if self._data is None else str(self._data)

cqasm/v1x/instruction.py

@@ -1,70 +0,0 @@
-import cqasm.v1x.types
-
-
-class Instruction(object):
-    def __init__(
-        self,
-        name,
-        types=None,
-        allow_conditional=True,
-        allow_parallel=True,
-        allow_reused_qubits=False,
-        allow_different_index_sizes=False
-    ):
-        super().__init__()
-        self._name = str(name)
-        if types is None:
-            self._types = ()
-        else:
-            for typ in types:
-                if not isinstance(typ, cqasm.v1x.types.Node):
-                    raise TypeError('types must be an iterable of cqasm.v1x.types.Node if specified')
-            self._types = tuple(types)
-        self._allow_conditional = bool(allow_conditional)
-        self._allow_parallel = bool(allow_parallel)
-        self._allow_reused_qubits = bool(allow_reused_qubits)
-        self._allow_different_index_sizes = bool(allow_different_index_sizes)
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def types(self):
-        return self._types
-
-    @property
-    def allow_conditional(self):
-        return self._allow_conditional
-
-    @property
-    def allow_parallel(self):
-        return self._allow_parallel
-
-    @property
-    def allow_reused_qubits(self):
-        return self._allow_reused_qubits
-
-    @property
-    def allow_different_index_sizes(self):
-        return self._allow_different_index_sizes
-
-    def __str__(self):
-        return '{}({})'.format(self._name, ', '.join(map(str, self._types)))
-
-
-class InstructionRef(object):
-    def __init__(self, *args, **kwargs):
-        if not args and not kwargs:
-            self._data = None
-        elif len(args) == 1 and not kwargs and (isinstance(args[0], Instruction) or args[0] is None):
-            self._data = args[0]
-        else:
-            self._data = Instruction(*args, **kwargs)
-
-    @property
-    def data(self):
-        return self._data
-
-    def __str__(self):
-        return 'unresolved' if self._data is None else str(self._data)

cqasm/v1x/primitives.py

@@ -1,177 +0,0 @@
-from enum import Enum
-import numpy as np
-
-import cqasm.v1x.error_model
-import cqasm.v1x.instruction
-import cqasm.v1x.types
-
-Str = str
-Bool = bool
-Int = int
-Real = float
-Complex = complex
-
-
-class Axis(Enum):
-    X = 0
-    Y = 1
-    Z = 2
-
-
-class _Matrix(object):
-    """Matrix adapter."""
-
-    def __init__(self, data):
-        super().__init__()
-        self._data = data
-        if len(self._data.shape) == 1:
-            self._ncols = self._data.shape[0]
-            self._nrows = 1
-        elif len(self._data.shape) == 2:
-            self._ncols = self._data.shape[0]
-            self._nrows = self._data.shape[1]
-        else:
-            raise TypeError('expecting a real-valued vector or matrix, got ' + repr(data))
-
-    def size_rows(self):
-        return self._nrows
-
-    def size_cols(self):
-        return self._ncols
-
-    def as_raw_data(self):
-        return self._data.reshape([self._nrows * self._ncols])
-
-    def as_numpy(self):
-        return self._data
-
-
-class RMatrix(_Matrix):
-    """Real-valued matrix adapter."""
-
-    def __init__(self, data):
-        super().__init__(np.array(data, float))
-
-
-class CMatrix(_Matrix):
-    """Complex-valued matrix adapter."""
-
-    def __init__(self, data):
-        super().__init__(np.array(data, complex))
-
-
-class Version(tuple):
-    """cQASM file version number."""
-
-    def __new__(cls, elements):
-        if isinstance(elements, str):
-            elements = elements.split('.')
-        return super(Version, cls).__new__(cls, tuple(map(int, elements)))
-
-
-def serialize(typ, val):
-    if isinstance(typ, str):
-        return None
-    elif typ is Str:
-        return {'x': val}
-    elif typ is Bool:
-        return {'x': val}
-    elif typ is Int:
-        return {'x': val}
-    elif typ is Real:
-        return {'x': val}
-    elif typ is Complex:
-        return {'r': val.real, 'i': val.imag}
-    elif typ is Axis:
-        if val == Axis.X:
-            return {'x': 0}
-        elif val == Axis.Y:
-            return {'x': 1}
-        elif val == Axis.Z:
-            return {'x': 2}
-        else:
-            assert False
-    elif typ is RMatrix:
-        return {'c': val.size_cols(), 'd': list(val.as_raw_data())}
-    elif typ is CMatrix:
-        data = []
-        for c in val.as_raw_data():
-            data.append(c.real)
-            data.append(c.imag)
-        return {'c': val.size_cols(), 'd': data}
-    elif typ is Version:
-        return {'x': list(val)}
-    elif typ is cqasm.v1x.error_model.ErrorModelRef:
-        if val.data is None:
-            return {}
-        else:
-            return {
-                'n': val.data.name,
-                't': [x.serialize() for x in val.data.types]
-            }
-    elif typ is cqasm.v1x.instruction.InstructionRef:
-        if val.data is None:
-            return {}
-        else:
-            return {
-                'n': val.data.name,
-                'c': val.data.allow_conditional,
-                'p': val.data.allow_parallel,
-                'r': val.data.allow_reused_qubits,
-                'd': val.data.allow_different_index_sizes,
-                't': [x.serialize() for x in val.data.types]
-            }
-    else:
-        assert False
-
-
-def deserialize(typ, val):
-    if isinstance(typ, str):
-        return None
-    elif typ is Str:
-        return Str(val['x'])
-    elif typ is Bool:
-        return Bool(val['x'])
-    elif typ is Int:
-        return Int(val['x'])
-    elif typ is Real:
-        return Real(val['x'])
-    elif typ is Complex:
-        return Complex(val['r'], val['i'])
-    elif typ is Axis:
-        if val['x'] == 0:
-            return Axis.X
-        elif val['x'] == 1:
-            return Axis.Y
-        elif val['x'] == 2:
-            return Axis.Z
-        else:
-            assert False
-    elif typ is RMatrix:
-        return RMatrix(np.array(val['d'], dtype=float).reshape([val['c'], len(val['d']) // val['c']]))
-    elif typ is CMatrix:
-        return CMatrix(np.array(val['d'], dtype=complex).reshape([val['c'], len(val['d']) // val['c']]))
-    elif typ is Version:
-        return Version(val['x'])
-    elif typ is cqasm.v1x.error_model.ErrorModelRef:
-        if 'n' in val:
-            return cqasm.v1x.error_model.ErrorModelRef(
-                val['n'],
-                [cqasm.v1x.types.Node.deserialize(x) for x in val['t']]
-            )
-        else:
-            return cqasm.v1x.error_model.ErrorModelRef()
-    elif typ is cqasm.v1x.instruction.InstructionRef:
-        if 'n' in val:
-            return cqasm.v1x.instruction.InstructionRef(
-                val['n'],
-                [cqasm.v1x.types.Node.deserialize(x) for x in val['t']],
-                val['c'],
-                val['p'],
-                val['r'],
-                val['d']
-            )
-        else:
-            return cqasm.v1x.instruction.InstructionRef()
-    else:
-        assert False