# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _Hilbertxx

def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        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):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


class Hxx_TypeForBits(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_TypeForBits, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_TypeForBits, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_TypeForBits instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def setTo0(*args): return _Hilbertxx.Hxx_TypeForBits_setTo0(*args)
    def print_values(*args): return _Hilbertxx.Hxx_TypeForBits_print_values(*args)
    def setToOne(*args): return _Hilbertxx.Hxx_TypeForBits_setToOne(*args)
    def setToValue(*args): return _Hilbertxx.Hxx_TypeForBits_setToValue(*args)
    def isZero(*args): return _Hilbertxx.Hxx_TypeForBits_isZero(*args)
    def countOne(*args): return _Hilbertxx.Hxx_TypeForBits_countOne(*args)
    def __str__(*args): return _Hilbertxx.Hxx_TypeForBits___str__(*args)
    def __or__(*args): return _Hilbertxx.Hxx_TypeForBits___or__(*args)
    def __and__(*args): return _Hilbertxx.Hxx_TypeForBits___and__(*args)
    def __xor__(*args): return _Hilbertxx.Hxx_TypeForBits___xor__(*args)
    def __rshift__(*args): return _Hilbertxx.Hxx_TypeForBits___rshift__(*args)
    def __lshift__(*args): return _Hilbertxx.Hxx_TypeForBits___lshift__(*args)
    def __eq__(*args): return _Hilbertxx.Hxx_TypeForBits___eq__(*args)
    def __ne__(*args): return _Hilbertxx.Hxx_TypeForBits___ne__(*args)
    def __lt__(*args): return _Hilbertxx.Hxx_TypeForBits___lt__(*args)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_TypeForBits, 'this', _Hilbertxx.new_Hxx_TypeForBits(*args))
        _swig_setattr(self, Hxx_TypeForBits, 'thisown', 1)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_TypeForBits):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_TypeForBitsPtr(Hxx_TypeForBits):
    def __init__(self, this):
        _swig_setattr(self, Hxx_TypeForBits, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_TypeForBits, 'thisown', 0)
        _swig_setattr(self, Hxx_TypeForBits,self.__class__,Hxx_TypeForBits)
_Hilbertxx.Hxx_TypeForBits_swigregister(Hxx_TypeForBitsPtr)

class Hxx_FermionicState(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_FermionicState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_FermionicState, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_FermionicState instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_FermionicState, 'this', _Hilbertxx.new_Hxx_FermionicState(*args))
        _swig_setattr(self, Hxx_FermionicState, 'thisown', 1)
    def print_values(*args): return _Hilbertxx.Hxx_FermionicState_print_values(*args)
    def n_particles(*args): return _Hilbertxx.Hxx_FermionicState_n_particles(*args)
    def get_value(*args): return _Hilbertxx.Hxx_FermionicState_get_value(*args)
    __swig_setmethods__["occupancies"] = _Hilbertxx.Hxx_FermionicState_occupancies_set
    __swig_getmethods__["occupancies"] = _Hilbertxx.Hxx_FermionicState_occupancies_get
    if _newclass:occupancies = property(_Hilbertxx.Hxx_FermionicState_occupancies_get, _Hilbertxx.Hxx_FermionicState_occupancies_set)
    def __getitem__(*args): return _Hilbertxx.Hxx_FermionicState___getitem__(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_FermionicState):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_FermionicStatePtr(Hxx_FermionicState):
    def __init__(self, this):
        _swig_setattr(self, Hxx_FermionicState, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_FermionicState, 'thisown', 0)
        _swig_setattr(self, Hxx_FermionicState,self.__class__,Hxx_FermionicState)
_Hilbertxx.Hxx_FermionicState_swigregister(Hxx_FermionicStatePtr)

class Hxx_Filter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_Filter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_Filter, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_Filter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def addCondition(*args): return _Hilbertxx.Hxx_Filter_addCondition(*args)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_Filter, 'this', _Hilbertxx.new_Hxx_Filter(*args))
        _swig_setattr(self, Hxx_Filter, 'thisown', 1)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_Filter):
        try:
            if self.thisown: destroy(self)
        except: pass

    def filtre(*args): return _Hilbertxx.Hxx_Filter_filtre(*args)
    __swig_setmethods__["min"] = _Hilbertxx.Hxx_Filter_min_set
    __swig_getmethods__["min"] = _Hilbertxx.Hxx_Filter_min_get
    if _newclass:min = property(_Hilbertxx.Hxx_Filter_min_get, _Hilbertxx.Hxx_Filter_min_set)
    __swig_setmethods__["max"] = _Hilbertxx.Hxx_Filter_max_set
    __swig_getmethods__["max"] = _Hilbertxx.Hxx_Filter_max_get
    if _newclass:max = property(_Hilbertxx.Hxx_Filter_max_get, _Hilbertxx.Hxx_Filter_max_set)
    __swig_getmethods__["opFilter"] = _Hilbertxx.Hxx_Filter_opFilter_get
    if _newclass:opFilter = property(_Hilbertxx.Hxx_Filter_opFilter_get)

class Hxx_FilterPtr(Hxx_Filter):
    def __init__(self, this):
        _swig_setattr(self, Hxx_Filter, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_Filter, 'thisown', 0)
        _swig_setattr(self, Hxx_Filter,self.__class__,Hxx_Filter)
_Hilbertxx.Hxx_Filter_swigregister(Hxx_FilterPtr)

class Hxx_Filter_opFilter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_Filter_opFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_Filter_opFilter, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_Filter_opFilter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["mask"] = _Hilbertxx.Hxx_Filter_opFilter_mask_set
    __swig_getmethods__["mask"] = _Hilbertxx.Hxx_Filter_opFilter_mask_get
    if _newclass:mask = property(_Hilbertxx.Hxx_Filter_opFilter_mask_get, _Hilbertxx.Hxx_Filter_opFilter_mask_set)
    __swig_setmethods__["operation"] = _Hilbertxx.Hxx_Filter_opFilter_operation_set
    __swig_getmethods__["operation"] = _Hilbertxx.Hxx_Filter_opFilter_operation_get
    if _newclass:operation = property(_Hilbertxx.Hxx_Filter_opFilter_operation_get, _Hilbertxx.Hxx_Filter_opFilter_operation_set)
    __swig_setmethods__["factor"] = _Hilbertxx.Hxx_Filter_opFilter_factor_set
    __swig_getmethods__["factor"] = _Hilbertxx.Hxx_Filter_opFilter_factor_get
    if _newclass:factor = property(_Hilbertxx.Hxx_Filter_opFilter_factor_get, _Hilbertxx.Hxx_Filter_opFilter_factor_set)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_Filter_opFilter, 'this', _Hilbertxx.new_Hxx_Filter_opFilter(*args))
        _swig_setattr(self, Hxx_Filter_opFilter, 'thisown', 1)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_Filter_opFilter):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_Filter_opFilterPtr(Hxx_Filter_opFilter):
    def __init__(self, this):
        _swig_setattr(self, Hxx_Filter_opFilter, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_Filter_opFilter, 'thisown', 0)
        _swig_setattr(self, Hxx_Filter_opFilter,self.__class__,Hxx_Filter_opFilter)
_Hilbertxx.Hxx_Filter_opFilter_swigregister(Hxx_Filter_opFilterPtr)

class Hxx_1p_FermionicOperator_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_1p_FermionicOperator_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_1p_FermionicOperator_, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_1p_FermionicOperator_ instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_1p_FermionicOperator_, 'this', _Hilbertxx.new_Hxx_1p_FermionicOperator_(*args))
        _swig_setattr(self, Hxx_1p_FermionicOperator_, 'thisown', 1)
    def get_1p_state(*args): return _Hilbertxx.Hxx_1p_FermionicOperator__get_1p_state(*args)
    def __getitem__(*args): return _Hilbertxx.Hxx_1p_FermionicOperator____getitem__(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_1p_FermionicOperator_):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_1p_FermionicOperator_Ptr(Hxx_1p_FermionicOperator_):
    def __init__(self, this):
        _swig_setattr(self, Hxx_1p_FermionicOperator_, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_1p_FermionicOperator_, 'thisown', 0)
        _swig_setattr(self, Hxx_1p_FermionicOperator_,self.__class__,Hxx_1p_FermionicOperator_)
_Hilbertxx.Hxx_1p_FermionicOperator__swigregister(Hxx_1p_FermionicOperator_Ptr)

class Hxx_1p_FermionicOperators(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_1p_FermionicOperators, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_1p_FermionicOperators, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_1p_FermionicOperators instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_getmethods__["Initialise"] = lambda x: _Hilbertxx.Hxx_1p_FermionicOperators_Initialise
    if _newclass:Initialise = staticmethod(_Hilbertxx.Hxx_1p_FermionicOperators_Initialise)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_1p_FermionicOperators, 'this', _Hilbertxx.new_Hxx_1p_FermionicOperators(*args))
        _swig_setattr(self, Hxx_1p_FermionicOperators, 'thisown', 1)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_1p_FermionicOperators):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_1p_FermionicOperatorsPtr(Hxx_1p_FermionicOperators):
    def __init__(self, this):
        _swig_setattr(self, Hxx_1p_FermionicOperators, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_1p_FermionicOperators, 'thisown', 0)
        _swig_setattr(self, Hxx_1p_FermionicOperators,self.__class__,Hxx_1p_FermionicOperators)
_Hilbertxx.Hxx_1p_FermionicOperators_swigregister(Hxx_1p_FermionicOperatorsPtr)

Hxx_1p_FermionicOperators_Initialise = _Hilbertxx.Hxx_1p_FermionicOperators_Initialise

class Hxx_N_counter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_N_counter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_N_counter, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_N_counter instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_N_counter, 'this', _Hilbertxx.new_Hxx_N_counter(*args))
        _swig_setattr(self, Hxx_N_counter, 'thisown', 1)
    def N(*args): return _Hilbertxx.Hxx_N_counter_N(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_N_counter):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_N_counterPtr(Hxx_N_counter):
    def __init__(self, this):
        _swig_setattr(self, Hxx_N_counter, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_N_counter, 'thisown', 0)
        _swig_setattr(self, Hxx_N_counter,self.__class__,Hxx_N_counter)
_Hilbertxx.Hxx_N_counter_swigregister(Hxx_N_counterPtr)

class Hxx_Normal_Operators_Collection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_Normal_Operators_Collection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_Normal_Operators_Collection, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_Normal_Operators_Collection instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_Normal_Operators_Collection, 'this', _Hilbertxx.new_Hxx_Normal_Operators_Collection(*args))
        _swig_setattr(self, Hxx_Normal_Operators_Collection, 'thisown', 1)
    def add_product(*args): return _Hilbertxx.Hxx_Normal_Operators_Collection_add_product(*args)
    def reorder(*args): return _Hilbertxx.Hxx_Normal_Operators_Collection_reorder(*args)
    def get_n_items(*args): return _Hilbertxx.Hxx_Normal_Operators_Collection_get_n_items(*args)
    def operate(*args): return _Hilbertxx.Hxx_Normal_Operators_Collection_operate(*args)
    def myprint(*args): return _Hilbertxx.Hxx_Normal_Operators_Collection_myprint(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_Normal_Operators_Collection):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_Normal_Operators_CollectionPtr(Hxx_Normal_Operators_Collection):
    def __init__(self, this):
        _swig_setattr(self, Hxx_Normal_Operators_Collection, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_Normal_Operators_Collection, 'thisown', 0)
        _swig_setattr(self, Hxx_Normal_Operators_Collection,self.__class__,Hxx_Normal_Operators_Collection)
_Hilbertxx.Hxx_Normal_Operators_Collection_swigregister(Hxx_Normal_Operators_CollectionPtr)

class Hxx_basis(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_basis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_basis, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_basis instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_basis, 'this', _Hilbertxx.new_Hxx_basis(*args))
        _swig_setattr(self, Hxx_basis, 'thisown', 1)
    def add_state(*args): return _Hilbertxx.Hxx_basis_add_state(*args)
    def operate_andputin_Tree(*args): return _Hilbertxx.Hxx_basis_operate_andputin_Tree(*args)
    def set_filter(*args): return _Hilbertxx.Hxx_basis_set_filter(*args)
    def reconstruct_basis(*args): return _Hilbertxx.Hxx_basis_reconstruct_basis(*args)
    def get_dimension(*args): return _Hilbertxx.Hxx_basis_get_dimension(*args)
    def find_state(*args): return _Hilbertxx.Hxx_basis_find_state(*args)
    def get_basis(*args): return _Hilbertxx.Hxx_basis_get_basis(*args)
    def set_pyfilter(*args): return _Hilbertxx.Hxx_basis_set_pyfilter(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_basis):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_basisPtr(Hxx_basis):
    def __init__(self, this):
        _swig_setattr(self, Hxx_basis, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_basis, 'thisown', 0)
        _swig_setattr(self, Hxx_basis,self.__class__,Hxx_basis)
_Hilbertxx.Hxx_basis_swigregister(Hxx_basisPtr)

class Hxx_transition(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_transition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_transition, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_transition instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_transition, 'this', _Hilbertxx.new_Hxx_transition(*args))
        _swig_setattr(self, Hxx_transition, 'thisown', 1)
    def initialise(*args): return _Hilbertxx.Hxx_transition_initialise(*args)
    def add_coeff(*args): return _Hilbertxx.Hxx_transition_add_coeff(*args)
    def get_from(*args): return _Hilbertxx.Hxx_transition_get_from(*args)
    def get_to(*args): return _Hilbertxx.Hxx_transition_get_to(*args)
    def get_coeff(*args): return _Hilbertxx.Hxx_transition_get_coeff(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_transition):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_transitionPtr(Hxx_transition):
    def __init__(self, this):
        _swig_setattr(self, Hxx_transition, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_transition, 'thisown', 0)
        _swig_setattr(self, Hxx_transition,self.__class__,Hxx_transition)
_Hilbertxx.Hxx_transition_swigregister(Hxx_transitionPtr)

class Hxx_TransitionMatrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hxx_TransitionMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hxx_TransitionMatrix, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ Hxx_TransitionMatrix instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Hxx_TransitionMatrix, 'this', _Hilbertxx.new_Hxx_TransitionMatrix(*args))
        _swig_setattr(self, Hxx_TransitionMatrix, 'thisown', 1)
    def add_contribution_debug(*args): return _Hilbertxx.Hxx_TransitionMatrix_add_contribution_debug(*args)
    def add_contribution(*args): return _Hilbertxx.Hxx_TransitionMatrix_add_contribution(*args)
    def Write_and_Clean(*args): return _Hilbertxx.Hxx_TransitionMatrix_Write_and_Clean(*args)
    def Read_add(*args): return _Hilbertxx.Hxx_TransitionMatrix_Read_add(*args)
    def Read_add_forhops(*args): return _Hilbertxx.Hxx_TransitionMatrix_Read_add_forhops(*args)
    def create_3Array_and_Clean(*args): return _Hilbertxx.Hxx_TransitionMatrix_create_3Array_and_Clean(*args)
    def free_space(*args): return _Hilbertxx.Hxx_TransitionMatrix_free_space(*args)
    def __del__(self, destroy=_Hilbertxx.delete_Hxx_TransitionMatrix):
        try:
            if self.thisown: destroy(self)
        except: pass


class Hxx_TransitionMatrixPtr(Hxx_TransitionMatrix):
    def __init__(self, this):
        _swig_setattr(self, Hxx_TransitionMatrix, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Hxx_TransitionMatrix, 'thisown', 0)
        _swig_setattr(self, Hxx_TransitionMatrix,self.__class__,Hxx_TransitionMatrix)
_Hilbertxx.Hxx_TransitionMatrix_swigregister(Hxx_TransitionMatrixPtr)


Wigner3J = _Hilbertxx.Wigner3J

