# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
Graph State Stabilizer Simulator -- S. Anders
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_graphsim', [dirname(__file__)])
        except ImportError:
            import _graphsim
            return _graphsim
        if fp is not None:
            try:
                _mod = imp.load_module('_graphsim', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _graphsim = swig_import_helper()
    del swig_import_helper
else:
    import _graphsim
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class boolpc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, boolpc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, boolpc, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _graphsim.new_boolpc()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_boolpc
    __del__ = lambda self : None;
    def assign(self, *args): return _graphsim.boolpc_assign(self, *args)
    def value(self): return _graphsim.boolpc_value(self)
    def cast(self): return _graphsim.boolpc_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _graphsim.boolpc_frompointer
    if _newclass:frompointer = staticmethod(_graphsim.boolpc_frompointer)
boolpc_swigregister = _graphsim.boolpc_swigregister
boolpc_swigregister(boolpc)

def boolpc_frompointer(*args):
  return _graphsim.boolpc_frompointer(*args)
boolpc_frompointer = _graphsim.boolpc_frompointer

class RightPhase(_object):
    """Proxy of C++ RightPhase class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RightPhase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RightPhase, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ph"] = _graphsim.RightPhase_ph_set
    __swig_getmethods__["ph"] = _graphsim.RightPhase_ph_get
    if _newclass:ph = _swig_property(_graphsim.RightPhase_ph_get, _graphsim.RightPhase_ph_set)
    def __init__(self, *args): 
        """
        __init__(RightPhase self) -> RightPhase
        __init__(RightPhase self, unsigned short ph_) -> RightPhase
        """
        this = _graphsim.new_RightPhase(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_name(self):
        """get_name(RightPhase self) -> string"""
        return _graphsim.RightPhase_get_name(self)

    __swig_destroy__ = _graphsim.delete_RightPhase
    __del__ = lambda self : None;
RightPhase_swigregister = _graphsim.RightPhase_swigregister
RightPhase_swigregister(RightPhase)

class LocCliffOp(_object):
    """Proxy of C++ LocCliffOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocCliffOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocCliffOp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["op"] = _graphsim.LocCliffOp_op_set
    __swig_getmethods__["op"] = _graphsim.LocCliffOp_op_get
    if _newclass:op = _swig_property(_graphsim.LocCliffOp_op_get, _graphsim.LocCliffOp_op_set)
    def __init__(self, *args): 
        """
        __init__(LocCliffOp self, unsigned short op_) -> LocCliffOp
        __init__(LocCliffOp self, unsigned short signsymb, unsigned short permsymb) -> LocCliffOp
        """
        this = _graphsim.new_LocCliffOp(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_name(self):
        """get_name(LocCliffOp self) -> string"""
        return _graphsim.LocCliffOp_get_name(self)

    def conjugate(self, *args):
        """conjugate(LocCliffOp self, LocCliffOp trans) -> RightPhase"""
        return _graphsim.LocCliffOp_conjugate(self, *args)

    def herm_adjoint(self):
        """herm_adjoint(LocCliffOp self) -> LocCliffOp"""
        return _graphsim.LocCliffOp_herm_adjoint(self)

    def mult_phase(*args):
        """mult_phase(LocCliffOp op1, LocCliffOp op2) -> RightPhase"""
        return _graphsim.LocCliffOp_mult_phase(*args)

    if _newclass:mult_phase = staticmethod(mult_phase)
    __swig_getmethods__["mult_phase"] = lambda x: mult_phase
    def isXY(self):
        """isXY(LocCliffOp self) -> bool"""
        return _graphsim.LocCliffOp_isXY(self)

    def is_diagonal(self):
        """is_diagonal(LocCliffOp self) -> bool"""
        return _graphsim.LocCliffOp_is_diagonal(self)

    def get_matrix(self):
        """get_matrix(LocCliffOp self) -> RightMatrix"""
        return _graphsim.LocCliffOp_get_matrix(self)

    __swig_destroy__ = _graphsim.delete_LocCliffOp
    __del__ = lambda self : None;
LocCliffOp_swigregister = _graphsim.LocCliffOp_swigregister
LocCliffOp_swigregister(LocCliffOp)

def LocCliffOp_mult_phase(*args):
  """LocCliffOp_mult_phase(LocCliffOp op1, LocCliffOp op2) -> RightPhase"""
  return _graphsim.LocCliffOp_mult_phase(*args)

class Stabilizer(_object):
    """Proxy of C++ Stabilizer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Stabilizer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Stabilizer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["numQubits"] = _graphsim.Stabilizer_numQubits_set
    __swig_getmethods__["numQubits"] = _graphsim.Stabilizer_numQubits_get
    if _newclass:numQubits = _swig_property(_graphsim.Stabilizer_numQubits_get, _graphsim.Stabilizer_numQubits_set)
    __swig_setmethods__["paulis"] = _graphsim.Stabilizer_paulis_set
    __swig_getmethods__["paulis"] = _graphsim.Stabilizer_paulis_get
    if _newclass:paulis = _swig_property(_graphsim.Stabilizer_paulis_get, _graphsim.Stabilizer_paulis_set)
    __swig_setmethods__["rowsigns"] = _graphsim.Stabilizer_rowsigns_set
    __swig_getmethods__["rowsigns"] = _graphsim.Stabilizer_rowsigns_get
    if _newclass:rowsigns = _swig_property(_graphsim.Stabilizer_rowsigns_get, _graphsim.Stabilizer_rowsigns_set)
    __swig_setmethods__["vtxidx"] = _graphsim.Stabilizer_vtxidx_set
    __swig_getmethods__["vtxidx"] = _graphsim.Stabilizer_vtxidx_get
    if _newclass:vtxidx = _swig_property(_graphsim.Stabilizer_vtxidx_get, _graphsim.Stabilizer_vtxidx_set)
    def __init__(self, *args): 
        """
        __init__(Stabilizer self, VertexIndex const numQubits_) -> Stabilizer
        __init__(Stabilizer self, GraphRegister gr, hash_set< VertexIndex > const & qubits) -> Stabilizer
        __init__(Stabilizer self, QState * qs) -> Stabilizer
        """
        this = _graphsim.new_Stabilizer(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_row(self, *args):
        """add_row(Stabilizer self, unsigned int target, unsigned int addend)"""
        return _graphsim.Stabilizer_add_row(self, *args)

    def conjugate(self, *args):
        """conjugate(Stabilizer self, unsigned int row, unsigned int col, LocCliffOp trans)"""
        return _graphsim.Stabilizer_conjugate(self, *args)

    def conjugate_column(self, *args):
        """conjugate_column(Stabilizer self, unsigned int col, LocCliffOp trans)"""
        return _graphsim.Stabilizer_conjugate_column(self, *args)

    def print_tbl(self, *args):
        """
        print_tbl(Stabilizer self, ostream os=cout)
        print_tbl(Stabilizer self)
        """
        return _graphsim.Stabilizer_print_tbl(self, *args)

    def str(self):
        """str(Stabilizer self) -> std::string"""
        return _graphsim.Stabilizer_str(self)

    def compare(self, *args):
        """compare(Stabilizer self, Stabilizer diag) -> bool"""
        return _graphsim.Stabilizer_compare(self, *args)

    __swig_destroy__ = _graphsim.delete_Stabilizer
    __del__ = lambda self : None;
Stabilizer_swigregister = _graphsim.Stabilizer_swigregister
Stabilizer_swigregister(Stabilizer)
consts = _graphsim.consts
num_LocCliffOps = consts.num_LocCliffOps
lco_Id = consts.lco_Id
lco_X = consts.lco_X
lco_Y = consts.lco_Y
lco_Z = consts.lco_Z
lco_H = consts.lco_H
lco_spiZ = consts.lco_spiZ
lco_smiZ = consts.lco_smiZ
lco_spiY = consts.lco_spiY
lco_smiY = consts.lco_smiY
lco_spiX = consts.lco_spiX
lco_smiX = consts.lco_smiX
lco_S = consts.lco_S
lco_Sh = consts.lco_Sh
rp_p1 = consts.rp_p1
rp_pI = consts.rp_pI
rp_m1 = consts.rp_m1
rp_mI = consts.rp_mI

class ios_base(_object):
    """Proxy of C++ std::ios_base class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _graphsim.ios_base_erase_event
    imbue_event = _graphsim.ios_base_imbue_event
    copyfmt_event = _graphsim.ios_base_copyfmt_event
    def register_callback(self, *args):
        """register_callback(ios_base self, std::ios_base::event_callback __fn, int __index)"""
        return _graphsim.ios_base_register_callback(self, *args)

    def flags(self, *args):
        """
        flags(ios_base self) -> std::ios_base::fmtflags
        flags(ios_base self, std::ios_base::fmtflags __fmtfl) -> std::ios_base::fmtflags
        """
        return _graphsim.ios_base_flags(self, *args)

    def setf(self, *args):
        """
        setf(ios_base self, std::ios_base::fmtflags __fmtfl) -> std::ios_base::fmtflags
        setf(ios_base self, std::ios_base::fmtflags __fmtfl, std::ios_base::fmtflags __mask) -> std::ios_base::fmtflags
        """
        return _graphsim.ios_base_setf(self, *args)

    def unsetf(self, *args):
        """unsetf(ios_base self, std::ios_base::fmtflags __mask)"""
        return _graphsim.ios_base_unsetf(self, *args)

    def precision(self, *args):
        """
        precision(ios_base self) -> std::streamsize
        precision(ios_base self, std::streamsize __prec) -> std::streamsize
        """
        return _graphsim.ios_base_precision(self, *args)

    def width(self, *args):
        """
        width(ios_base self) -> std::streamsize
        width(ios_base self, std::streamsize __wide) -> std::streamsize
        """
        return _graphsim.ios_base_width(self, *args)

    def sync_with_stdio(__sync=True):
        """
        sync_with_stdio(bool __sync=True) -> bool
        sync_with_stdio() -> bool
        """
        return _graphsim.ios_base_sync_with_stdio(__sync)

    if _newclass:sync_with_stdio = staticmethod(sync_with_stdio)
    __swig_getmethods__["sync_with_stdio"] = lambda x: sync_with_stdio
    def imbue(self, *args):
        """imbue(ios_base self, std::locale const & __loc) -> std::locale"""
        return _graphsim.ios_base_imbue(self, *args)

    def getloc(self):
        """getloc(ios_base self) -> std::locale"""
        return _graphsim.ios_base_getloc(self)

    def xalloc():
        """xalloc() -> int"""
        return _graphsim.ios_base_xalloc()

    if _newclass:xalloc = staticmethod(xalloc)
    __swig_getmethods__["xalloc"] = lambda x: xalloc
    def iword(self, *args):
        """iword(ios_base self, int __ix) -> long &"""
        return _graphsim.ios_base_iword(self, *args)

    def pword(self, *args):
        """pword(ios_base self, int __ix) -> void *&"""
        return _graphsim.ios_base_pword(self, *args)

    __swig_destroy__ = _graphsim.delete_ios_base
    __del__ = lambda self : None;
ios_base_swigregister = _graphsim.ios_base_swigregister
ios_base_swigregister(ios_base)
ios_base.boolalpha = _graphsim.consts.ios_base_boolalpha
ios_base.dec = _graphsim.consts.ios_base_dec
ios_base.fixed = _graphsim.consts.ios_base_fixed
ios_base.hex = _graphsim.consts.ios_base_hex
ios_base.internal = _graphsim.consts.ios_base_internal
ios_base.left = _graphsim.consts.ios_base_left
ios_base.oct = _graphsim.consts.ios_base_oct
ios_base.right = _graphsim.consts.ios_base_right
ios_base.scientific = _graphsim.consts.ios_base_scientific
ios_base.showbase = _graphsim.consts.ios_base_showbase
ios_base.showpoint = _graphsim.consts.ios_base_showpoint
ios_base.showpos = _graphsim.consts.ios_base_showpos
ios_base.skipws = _graphsim.consts.ios_base_skipws
ios_base.unitbuf = _graphsim.consts.ios_base_unitbuf
ios_base.uppercase = _graphsim.consts.ios_base_uppercase
ios_base.adjustfield = _graphsim.consts.ios_base_adjustfield
ios_base.basefield = _graphsim.consts.ios_base_basefield
ios_base.floatfield = _graphsim.consts.ios_base_floatfield
ios_base.badbit = _graphsim.consts.ios_base_badbit
ios_base.eofbit = _graphsim.consts.ios_base_eofbit
ios_base.failbit = _graphsim.consts.ios_base_failbit
ios_base.goodbit = _graphsim.consts.ios_base_goodbit
ios_base.app = _graphsim.consts.ios_base_app
ios_base.ate = _graphsim.consts.ios_base_ate
ios_base.binary = _graphsim.consts.ios_base_binary
ios_base.ios_base_in = _graphsim.consts.ios_base_ios_base_in
ios_base.out = _graphsim.consts.ios_base_out
ios_base.trunc = _graphsim.consts.ios_base_trunc
ios_base.beg = _graphsim.consts.ios_base_beg
ios_base.cur = _graphsim.consts.ios_base_cur
ios_base.end = _graphsim.consts.ios_base_end

def ios_base_sync_with_stdio(__sync=True):
  """
    sync_with_stdio(bool __sync=True) -> bool
    ios_base_sync_with_stdio() -> bool
    """
  return _graphsim.ios_base_sync_with_stdio(__sync)

def ios_base_xalloc():
  """ios_base_xalloc() -> int"""
  return _graphsim.ios_base_xalloc()

class ios(ios_base):
    """Proxy of C++ std::basic_ios<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios_base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
    __swig_getmethods__ = {}
    for _s in [ios_base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
    __repr__ = _swig_repr
    def rdstate(self):
        """rdstate(ios self) -> std::ios_base::iostate"""
        return _graphsim.ios_rdstate(self)

    def clear(self, *args):
        """
        clear(ios self, std::ios_base::iostate __state=goodbit)
        clear(ios self)
        """
        return _graphsim.ios_clear(self, *args)

    def setstate(self, *args):
        """setstate(ios self, std::ios_base::iostate __state)"""
        return _graphsim.ios_setstate(self, *args)

    def good(self):
        """good(ios self) -> bool"""
        return _graphsim.ios_good(self)

    def eof(self):
        """eof(ios self) -> bool"""
        return _graphsim.ios_eof(self)

    def fail(self):
        """fail(ios self) -> bool"""
        return _graphsim.ios_fail(self)

    def bad(self):
        """bad(ios self) -> bool"""
        return _graphsim.ios_bad(self)

    def exceptions(self, *args):
        """
        exceptions(ios self) -> std::ios_base::iostate
        exceptions(ios self, std::ios_base::iostate __except)
        """
        return _graphsim.ios_exceptions(self, *args)

    def __init__(self, *args): 
        """__init__(std::basic_ios<(char)> self, streambuf __sb) -> ios"""
        this = _graphsim.new_ios(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_ios
    __del__ = lambda self : None;
    def tie(self, *args):
        """
        tie(ios self) -> ostream
        tie(ios self, ostream __tiestr) -> ostream
        """
        return _graphsim.ios_tie(self, *args)

    def rdbuf(self, *args):
        """
        rdbuf(ios self) -> streambuf
        rdbuf(ios self, streambuf __sb) -> streambuf
        """
        return _graphsim.ios_rdbuf(self, *args)

    def copyfmt(self, *args):
        """copyfmt(ios self, ios __rhs) -> ios"""
        return _graphsim.ios_copyfmt(self, *args)

    def fill(self, *args):
        """
        fill(ios self) -> std::basic_ios< char >::char_type
        fill(ios self, std::basic_ios< char >::char_type __ch) -> std::basic_ios< char >::char_type
        """
        return _graphsim.ios_fill(self, *args)

    def imbue(self, *args):
        """imbue(ios self, std::locale const & __loc) -> std::locale"""
        return _graphsim.ios_imbue(self, *args)

    def narrow(self, *args):
        """narrow(ios self, std::basic_ios< char >::char_type __c, char __dfault) -> char"""
        return _graphsim.ios_narrow(self, *args)

    def widen(self, *args):
        """widen(ios self, char __c) -> std::basic_ios< char >::char_type"""
        return _graphsim.ios_widen(self, *args)

ios_swigregister = _graphsim.ios_swigregister
ios_swigregister(ios)

class streambuf(_object):
    """Proxy of C++ std::basic_streambuf<(char)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, streambuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, streambuf, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _graphsim.delete_streambuf
    __del__ = lambda self : None;
    def pubimbue(self, *args):
        """pubimbue(streambuf self, std::locale const & __loc) -> std::locale"""
        return _graphsim.streambuf_pubimbue(self, *args)

    def getloc(self):
        """getloc(streambuf self) -> std::locale"""
        return _graphsim.streambuf_getloc(self)

    def pubsetbuf(self, *args):
        """pubsetbuf(streambuf self, std::basic_streambuf< char >::char_type * __s, std::streamsize __n) -> streambuf"""
        return _graphsim.streambuf_pubsetbuf(self, *args)

    def pubseekoff(self, *args):
        """
        pubseekoff(streambuf self, std::basic_streambuf< char >::off_type __off, std::ios_base::seekdir __way, std::ios_base::openmode __mode=std::ios_base::in|std::ios_base::out) -> std::basic_streambuf< char >::pos_type
        pubseekoff(streambuf self, std::basic_streambuf< char >::off_type __off, std::ios_base::seekdir __way) -> std::basic_streambuf< char >::pos_type
        """
        return _graphsim.streambuf_pubseekoff(self, *args)

    def pubseekpos(self, *args):
        """
        pubseekpos(streambuf self, std::basic_streambuf< char >::pos_type __sp, std::ios_base::openmode __mode=std::ios_base::in|std::ios_base::out) -> std::basic_streambuf< char >::pos_type
        pubseekpos(streambuf self, std::basic_streambuf< char >::pos_type __sp) -> std::basic_streambuf< char >::pos_type
        """
        return _graphsim.streambuf_pubseekpos(self, *args)

    def pubsync(self):
        """pubsync(streambuf self) -> int"""
        return _graphsim.streambuf_pubsync(self)

    def in_avail(self):
        """in_avail(streambuf self) -> std::streamsize"""
        return _graphsim.streambuf_in_avail(self)

    def snextc(self):
        """snextc(streambuf self) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_snextc(self)

    def sbumpc(self):
        """sbumpc(streambuf self) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_sbumpc(self)

    def sgetc(self):
        """sgetc(streambuf self) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_sgetc(self)

    def sgetn(self, *args):
        """sgetn(streambuf self, std::basic_streambuf< char >::char_type * __s, std::streamsize __n) -> std::streamsize"""
        return _graphsim.streambuf_sgetn(self, *args)

    def sputbackc(self, *args):
        """sputbackc(streambuf self, std::basic_streambuf< char >::char_type __c) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_sputbackc(self, *args)

    def sungetc(self):
        """sungetc(streambuf self) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_sungetc(self)

    def sputc(self, *args):
        """sputc(streambuf self, std::basic_streambuf< char >::char_type __c) -> std::basic_streambuf< char >::int_type"""
        return _graphsim.streambuf_sputc(self, *args)

    def sputn(self, *args):
        """sputn(streambuf self, std::basic_streambuf< char >::char_type const * __s, std::streamsize __n) -> std::streamsize"""
        return _graphsim.streambuf_sputn(self, *args)

streambuf_swigregister = _graphsim.streambuf_swigregister
streambuf_swigregister(streambuf)

class ostream(ios):
    """Proxy of C++ std::basic_ostream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(std::basic_ostream<(char)> self, streambuf __sb) -> ostream"""
        this = _graphsim.new_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_ostream
    __del__ = lambda self : None;
    def __lshift__(self, *args):
        """
        __lshift__(ostream self, std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &) __pf) -> ostream
        __lshift__(ostream self, std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &) __pf) -> ostream
        __lshift__(ostream self, std::ios_base &(*)(std::ios_base &) __pf) -> ostream
        __lshift__(ostream self, long __n) -> ostream
        __lshift__(ostream self, unsigned long __n) -> ostream
        __lshift__(ostream self, bool __n) -> ostream
        __lshift__(ostream self, short __n) -> ostream
        __lshift__(ostream self, unsigned short __n) -> ostream
        __lshift__(ostream self, int __n) -> ostream
        __lshift__(ostream self, unsigned int __n) -> ostream
        __lshift__(ostream self, long long __n) -> ostream
        __lshift__(ostream self, unsigned long long __n) -> ostream
        __lshift__(ostream self, double __f) -> ostream
        __lshift__(ostream self, float __f) -> ostream
        __lshift__(ostream self, long double __f) -> ostream
        __lshift__(ostream self, void const * __p) -> ostream
        __lshift__(ostream self, streambuf __sb) -> ostream
        __lshift__(ostream self, std::basic_string< char,std::char_traits< char >,std::allocator< char > > const & s) -> ostream
        """
        return _graphsim.ostream___lshift__(self, *args)

    def put(self, *args):
        """put(ostream self, std::basic_ostream< char >::char_type __c) -> ostream"""
        return _graphsim.ostream_put(self, *args)

    def write(self, *args):
        """write(ostream self, std::basic_ostream< char >::char_type const * __s, std::streamsize __n) -> ostream"""
        return _graphsim.ostream_write(self, *args)

    def flush(self):
        """flush(ostream self) -> ostream"""
        return _graphsim.ostream_flush(self)

    def tellp(self):
        """tellp(ostream self) -> std::basic_ostream< char >::pos_type"""
        return _graphsim.ostream_tellp(self)

    def seekp(self, *args):
        """
        seekp(ostream self, std::basic_ostream< char >::pos_type arg2) -> ostream
        seekp(ostream self, std::basic_ostream< char >::off_type arg2, std::ios_base::seekdir arg3) -> ostream
        """
        return _graphsim.ostream_seekp(self, *args)

ostream_swigregister = _graphsim.ostream_swigregister
ostream_swigregister(ostream)
cin = consts.cin
cout = consts.cout
cerr = consts.cerr
clog = consts.clog

class istream(ios):
    """Proxy of C++ std::basic_istream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(std::basic_istream<(char)> self, streambuf __sb) -> istream"""
        this = _graphsim.new_istream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_istream
    __del__ = lambda self : None;
    def __rshift__(self, *args):
        """
        __rshift__(istream self, std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &) __pf) -> istream
        __rshift__(istream self, std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &) __pf) -> istream
        __rshift__(istream self, std::ios_base &(*)(std::ios_base &) __pf) -> istream
        __rshift__(istream self, bool & __n) -> istream
        __rshift__(istream self, short & __n) -> istream
        __rshift__(istream self, unsigned short & __n) -> istream
        __rshift__(istream self, int & __n) -> istream
        __rshift__(istream self, unsigned int & __n) -> istream
        __rshift__(istream self, long & __n) -> istream
        __rshift__(istream self, unsigned long & __n) -> istream
        __rshift__(istream self, long long & __n) -> istream
        __rshift__(istream self, unsigned long long & __n) -> istream
        __rshift__(istream self, float & __f) -> istream
        __rshift__(istream self, double & __f) -> istream
        __rshift__(istream self, long double & __f) -> istream
        __rshift__(istream self, void *& __p) -> istream
        __rshift__(istream self, streambuf __sb) -> istream
        """
        return _graphsim.istream___rshift__(self, *args)

    def gcount(self):
        """gcount(istream self) -> std::streamsize"""
        return _graphsim.istream_gcount(self)

    def get(self, *args):
        """
        get(istream self) -> std::basic_istream< char >::int_type
        get(istream self, std::basic_istream< char >::char_type & __c) -> istream
        get(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n, std::basic_istream< char >::char_type __delim) -> istream
        get(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream
        get(istream self, streambuf __sb, std::basic_istream< char >::char_type __delim) -> istream
        get(istream self, streambuf __sb) -> istream
        """
        return _graphsim.istream_get(self, *args)

    def getline(self, *args):
        """
        getline(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n, std::basic_istream< char >::char_type __delim) -> istream
        getline(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream
        """
        return _graphsim.istream_getline(self, *args)

    def ignore(self, *args):
        """
        ignore(istream self, std::streamsize __n=1, std::basic_istream< char >::int_type __delim=std::char_traits< char >::eof()) -> istream
        ignore(istream self, std::streamsize __n=1) -> istream
        ignore(istream self) -> istream
        """
        return _graphsim.istream_ignore(self, *args)

    def peek(self):
        """peek(istream self) -> std::basic_istream< char >::int_type"""
        return _graphsim.istream_peek(self)

    def read(self, *args):
        """read(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> istream"""
        return _graphsim.istream_read(self, *args)

    def readsome(self, *args):
        """readsome(istream self, std::basic_istream< char >::char_type * __s, std::streamsize __n) -> std::streamsize"""
        return _graphsim.istream_readsome(self, *args)

    def putback(self, *args):
        """putback(istream self, std::basic_istream< char >::char_type __c) -> istream"""
        return _graphsim.istream_putback(self, *args)

    def unget(self):
        """unget(istream self) -> istream"""
        return _graphsim.istream_unget(self)

    def sync(self):
        """sync(istream self) -> int"""
        return _graphsim.istream_sync(self)

    def tellg(self):
        """tellg(istream self) -> std::basic_istream< char >::pos_type"""
        return _graphsim.istream_tellg(self)

    def seekg(self, *args):
        """
        seekg(istream self, std::basic_istream< char >::pos_type arg2) -> istream
        seekg(istream self, std::basic_istream< char >::off_type arg2, std::ios_base::seekdir arg3) -> istream
        """
        return _graphsim.istream_seekg(self, *args)

istream_swigregister = _graphsim.istream_swigregister
istream_swigregister(istream)

class iostream(istream,ostream):
    """Proxy of C++ std::basic_iostream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [istream,ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream,ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(std::basic_iostream<(char)> self, streambuf __sb) -> iostream"""
        this = _graphsim.new_iostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_iostream
    __del__ = lambda self : None;
iostream_swigregister = _graphsim.iostream_swigregister
iostream_swigregister(iostream)

endl_cb_ptr = _graphsim.endl_cb_ptr

def endl(*args):
  """endl(ostream arg1) -> ostream"""
  return _graphsim.endl(*args)
endl = _graphsim.endl
ends_cb_ptr = _graphsim.ends_cb_ptr

def ends(*args):
  """ends(ostream arg1) -> ostream"""
  return _graphsim.ends(*args)
ends = _graphsim.ends
flush_cb_ptr = _graphsim.flush_cb_ptr

def flush(*args):
  """flush(ostream arg1) -> ostream"""
  return _graphsim.flush(*args)
flush = _graphsim.flush
class istringstream(istream):
    """Proxy of C++ std::basic_istringstream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [istream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::basic_istringstream<(char)> self, std::ios_base::openmode __mode=ios_base_in) -> istringstream
        __init__(std::basic_istringstream<(char)> self) -> istringstream
        __init__(std::basic_istringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str, 
            std::ios_base::openmode __mode=ios_base_in) -> istringstream
        __init__(std::basic_istringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str) -> istringstream
        """
        this = _graphsim.new_istringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_istringstream
    __del__ = lambda self : None;
    def rdbuf(self):
        """rdbuf(istringstream self) -> std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *"""
        return _graphsim.istringstream_rdbuf(self)

    def str(self, *args):
        """
        str(istringstream self) -> basic_string< char,std::char_traits< char >,std::allocator< char > >
        str(istringstream self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __s)
        """
        return _graphsim.istringstream_str(self, *args)

istringstream_swigregister = _graphsim.istringstream_swigregister
istringstream_swigregister(istringstream)

class ostringstream(ostream):
    """Proxy of C++ std::basic_ostringstream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::basic_ostringstream<(char)> self, std::ios_base::openmode __mode=out) -> ostringstream
        __init__(std::basic_ostringstream<(char)> self) -> ostringstream
        __init__(std::basic_ostringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str, 
            std::ios_base::openmode __mode=out) -> ostringstream
        __init__(std::basic_ostringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str) -> ostringstream
        """
        this = _graphsim.new_ostringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_ostringstream
    __del__ = lambda self : None;
    def rdbuf(self):
        """rdbuf(ostringstream self) -> std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *"""
        return _graphsim.ostringstream_rdbuf(self)

    def str(self):
        """str(ostringstream self) -> basic_string< char,std::char_traits< char >,std::allocator< char > >"""
        return _graphsim.ostringstream_str(self)

ostringstream_swigregister = _graphsim.ostringstream_swigregister
ostringstream_swigregister(ostringstream)

class stringstream(iostream):
    """Proxy of C++ std::basic_stringstream<(char)> class"""
    __swig_setmethods__ = {}
    for _s in [iostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, stringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [iostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, stringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::basic_stringstream<(char)> self, std::ios_base::openmode __m=ios_base::out|ios_base::in) -> stringstream
        __init__(std::basic_stringstream<(char)> self) -> stringstream
        __init__(std::basic_stringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str, 
            std::ios_base::openmode __m=ios_base::out|ios_base::in) -> stringstream
        __init__(std::basic_stringstream<(char)> self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __str) -> stringstream
        """
        this = _graphsim.new_stringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_stringstream
    __del__ = lambda self : None;
    def rdbuf(self):
        """rdbuf(stringstream self) -> std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *"""
        return _graphsim.stringstream_rdbuf(self)

    def str(self, *args):
        """
        str(stringstream self) -> basic_string< char,std::char_traits< char >,std::allocator< char > >
        str(stringstream self, basic_string< char,std::char_traits< char >,std::allocator< char > > const & __s)
        """
        return _graphsim.stringstream_str(self, *args)

stringstream_swigregister = _graphsim.stringstream_swigregister
stringstream_swigregister(stringstream)

class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _graphsim.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _graphsim.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _graphsim.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _graphsim.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _graphsim.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graphsim.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _graphsim.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _graphsim.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _graphsim.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _graphsim.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graphsim.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graphsim.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graphsim.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graphsim.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graphsim.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graphsim.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _graphsim.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _graphsim.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class QubitVertex(_object):
    """Proxy of C++ QubitVertex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QubitVertex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QubitVertex, name)
    __repr__ = _swig_repr
    __swig_setmethods__["byprod"] = _graphsim.QubitVertex_byprod_set
    __swig_getmethods__["byprod"] = _graphsim.QubitVertex_byprod_get
    if _newclass:byprod = _swig_property(_graphsim.QubitVertex_byprod_get, _graphsim.QubitVertex_byprod_set)
    __swig_setmethods__["neighbors"] = _graphsim.QubitVertex_neighbors_set
    __swig_getmethods__["neighbors"] = _graphsim.QubitVertex_neighbors_get
    if _newclass:neighbors = _swig_property(_graphsim.QubitVertex_neighbors_get, _graphsim.QubitVertex_neighbors_set)
    def __init__(self): 
        """__init__(QubitVertex self) -> QubitVertex"""
        this = _graphsim.new_QubitVertex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_QubitVertex
    __del__ = lambda self : None;
QubitVertex_swigregister = _graphsim.QubitVertex_swigregister
QubitVertex_swigregister(QubitVertex)

class GraphRegister(_object):
    """Proxy of C++ GraphRegister class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphRegister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GraphRegister, name)
    __repr__ = _swig_repr
    __swig_setmethods__["vertices"] = _graphsim.GraphRegister_vertices_set
    __swig_getmethods__["vertices"] = _graphsim.GraphRegister_vertices_get
    if _newclass:vertices = _swig_property(_graphsim.GraphRegister_vertices_get, _graphsim.GraphRegister_vertices_set)
    def __init__(self, *args): 
        """
        __init__(GraphRegister self, VertexIndex numQubits, int randomize=-1) -> GraphRegister
        __init__(GraphRegister self, VertexIndex numQubits) -> GraphRegister
        __init__(GraphRegister self, GraphRegister gr) -> GraphRegister
        """
        this = _graphsim.new_GraphRegister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graphsim.delete_GraphRegister
    __del__ = lambda self : None;
    def local_op(self, *args):
        """local_op(GraphRegister self, VertexIndex v, LocCliffOp o)"""
        return _graphsim.GraphRegister_local_op(self, *args)

    def hadamard(self, *args):
        """hadamard(GraphRegister self, VertexIndex v)"""
        return _graphsim.GraphRegister_hadamard(self, *args)

    def phaserot(self, *args):
        """phaserot(GraphRegister self, VertexIndex v)"""
        return _graphsim.GraphRegister_phaserot(self, *args)

    def bitflip(self, *args):
        """bitflip(GraphRegister self, VertexIndex v)"""
        return _graphsim.GraphRegister_bitflip(self, *args)

    def phaseflip(self, *args):
        """phaseflip(GraphRegister self, VertexIndex v)"""
        return _graphsim.GraphRegister_phaseflip(self, *args)

    def cphase(self, *args):
        """cphase(GraphRegister self, VertexIndex v1, VertexIndex v2)"""
        return _graphsim.GraphRegister_cphase(self, *args)

    def cnot(self, *args):
        """cnot(GraphRegister self, VertexIndex vc, VertexIndex vt)"""
        return _graphsim.GraphRegister_cnot(self, *args)

    def measure(self, *args):
        """
        measure(GraphRegister self, VertexIndex v, LocCliffOp basis=lco_Z, bool * determined=None, int force=-1) -> int
        measure(GraphRegister self, VertexIndex v, LocCliffOp basis=lco_Z, bool * determined=None) -> int
        measure(GraphRegister self, VertexIndex v, LocCliffOp basis=lco_Z) -> int
        measure(GraphRegister self, VertexIndex v) -> int
        """
        return _graphsim.GraphRegister_measure(self, *args)

    def get_full_stabilizer(self):
        """get_full_stabilizer(GraphRegister self) -> Stabilizer"""
        return _graphsim.GraphRegister_get_full_stabilizer(self)

    def invert_neighborhood(self, *args):
        """invert_neighborhood(GraphRegister self, VertexIndex v)"""
        return _graphsim.GraphRegister_invert_neighborhood(self, *args)

    def print_adj_list(self, *args):
        """
        print_adj_list(GraphRegister self, ostream os=cout)
        print_adj_list(GraphRegister self)
        """
        return _graphsim.GraphRegister_print_adj_list(self, *args)

    def print_adj_list_line(self, *args):
        """print_adj_list_line(GraphRegister self, ostream os, VertexIndex i)"""
        return _graphsim.GraphRegister_print_adj_list_line(self, *args)

    def print_stabilizer(self, *args):
        """
        print_stabilizer(GraphRegister self, ostream os=cout)
        print_stabilizer(GraphRegister self)
        """
        return _graphsim.GraphRegister_print_stabilizer(self, *args)

    def get_adj(self):
        """get_adj(GraphRegister self) -> PyObject *"""
        return _graphsim.GraphRegister_get_adj(self)

    def get_vop(self):
        """get_vop(GraphRegister self) -> PyObject *"""
        return _graphsim.GraphRegister_get_vop(self)

    def to_json(self):
        """to_json(GraphRegister self) -> PyObject *"""
        return _graphsim.GraphRegister_to_json(self)

GraphRegister_swigregister = _graphsim.GraphRegister_swigregister
GraphRegister_swigregister(GraphRegister)

# This file is compatible with both classic and new-style classes.


