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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_infomap')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_infomap')
    _infomap = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_infomap', [dirname(__file__)])
        except ImportError:
            import _infomap
            return _infomap
        try:
            _mod = imp.load_module('_infomap', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _infomap = swig_import_helper()
    del swig_import_helper
else:
    import _infomap
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class FlowModel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FlowModel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FlowModel, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _infomap.new_FlowModel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_FlowModel
    __del__ = lambda self: None
FlowModel_swigregister = _infomap.FlowModel_swigregister
FlowModel_swigregister(FlowModel)
cvar = _infomap.cvar
FlowModel.undirected = _infomap.cvar.FlowModel_undirected
FlowModel.directed = _infomap.cvar.FlowModel_directed
FlowModel.undirdir = _infomap.cvar.FlowModel_undirdir
FlowModel.outdirdir = _infomap.cvar.FlowModel_outdirdir
FlowModel.rawdir = _infomap.cvar.FlowModel_rawdir

class Config(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Config, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Config, name)
    __repr__ = _swig_repr
    __swig_setmethods__["networkFile"] = _infomap.Config_networkFile_set
    __swig_getmethods__["networkFile"] = _infomap.Config_networkFile_get
    if _newclass:
        networkFile = _swig_property(_infomap.Config_networkFile_get, _infomap.Config_networkFile_set)
    __swig_setmethods__["additionalInput"] = _infomap.Config_additionalInput_set
    __swig_getmethods__["additionalInput"] = _infomap.Config_additionalInput_get
    if _newclass:
        additionalInput = _swig_property(_infomap.Config_additionalInput_get, _infomap.Config_additionalInput_set)
    __swig_setmethods__["inputFormat"] = _infomap.Config_inputFormat_set
    __swig_getmethods__["inputFormat"] = _infomap.Config_inputFormat_get
    if _newclass:
        inputFormat = _swig_property(_infomap.Config_inputFormat_get, _infomap.Config_inputFormat_set)
    __swig_setmethods__["memoryInput"] = _infomap.Config_memoryInput_set
    __swig_getmethods__["memoryInput"] = _infomap.Config_memoryInput_get
    if _newclass:
        memoryInput = _swig_property(_infomap.Config_memoryInput_get, _infomap.Config_memoryInput_set)
    __swig_setmethods__["withMemory"] = _infomap.Config_withMemory_set
    __swig_getmethods__["withMemory"] = _infomap.Config_withMemory_get
    if _newclass:
        withMemory = _swig_property(_infomap.Config_withMemory_get, _infomap.Config_withMemory_set)
    __swig_setmethods__["weightThreshold"] = _infomap.Config_weightThreshold_set
    __swig_getmethods__["weightThreshold"] = _infomap.Config_weightThreshold_get
    if _newclass:
        weightThreshold = _swig_property(_infomap.Config_weightThreshold_get, _infomap.Config_weightThreshold_set)
    __swig_setmethods__["unweightedPaths"] = _infomap.Config_unweightedPaths_set
    __swig_getmethods__["unweightedPaths"] = _infomap.Config_unweightedPaths_get
    if _newclass:
        unweightedPaths = _swig_property(_infomap.Config_unweightedPaths_get, _infomap.Config_unweightedPaths_set)
    __swig_setmethods__["pathMarkovOrder"] = _infomap.Config_pathMarkovOrder_set
    __swig_getmethods__["pathMarkovOrder"] = _infomap.Config_pathMarkovOrder_get
    if _newclass:
        pathMarkovOrder = _swig_property(_infomap.Config_pathMarkovOrder_get, _infomap.Config_pathMarkovOrder_set)
    __swig_setmethods__["bipartite"] = _infomap.Config_bipartite_set
    __swig_getmethods__["bipartite"] = _infomap.Config_bipartite_get
    if _newclass:
        bipartite = _swig_property(_infomap.Config_bipartite_get, _infomap.Config_bipartite_set)
    __swig_setmethods__["skipAdjustBipartiteFlow"] = _infomap.Config_skipAdjustBipartiteFlow_set
    __swig_getmethods__["skipAdjustBipartiteFlow"] = _infomap.Config_skipAdjustBipartiteFlow_get
    if _newclass:
        skipAdjustBipartiteFlow = _swig_property(_infomap.Config_skipAdjustBipartiteFlow_get, _infomap.Config_skipAdjustBipartiteFlow_set)
    __swig_setmethods__["hardPartitions"] = _infomap.Config_hardPartitions_set
    __swig_getmethods__["hardPartitions"] = _infomap.Config_hardPartitions_get
    if _newclass:
        hardPartitions = _swig_property(_infomap.Config_hardPartitions_get, _infomap.Config_hardPartitions_set)
    __swig_setmethods__["nonBacktracking"] = _infomap.Config_nonBacktracking_set
    __swig_getmethods__["nonBacktracking"] = _infomap.Config_nonBacktracking_get
    if _newclass:
        nonBacktracking = _swig_property(_infomap.Config_nonBacktracking_get, _infomap.Config_nonBacktracking_set)
    __swig_setmethods__["parseWithoutIOStreams"] = _infomap.Config_parseWithoutIOStreams_set
    __swig_getmethods__["parseWithoutIOStreams"] = _infomap.Config_parseWithoutIOStreams_get
    if _newclass:
        parseWithoutIOStreams = _swig_property(_infomap.Config_parseWithoutIOStreams_get, _infomap.Config_parseWithoutIOStreams_set)
    __swig_setmethods__["zeroBasedNodeNumbers"] = _infomap.Config_zeroBasedNodeNumbers_set
    __swig_getmethods__["zeroBasedNodeNumbers"] = _infomap.Config_zeroBasedNodeNumbers_get
    if _newclass:
        zeroBasedNodeNumbers = _swig_property(_infomap.Config_zeroBasedNodeNumbers_get, _infomap.Config_zeroBasedNodeNumbers_set)
    __swig_setmethods__["includeSelfLinks"] = _infomap.Config_includeSelfLinks_set
    __swig_getmethods__["includeSelfLinks"] = _infomap.Config_includeSelfLinks_get
    if _newclass:
        includeSelfLinks = _swig_property(_infomap.Config_includeSelfLinks_get, _infomap.Config_includeSelfLinks_set)
    __swig_setmethods__["ignoreEdgeWeights"] = _infomap.Config_ignoreEdgeWeights_set
    __swig_getmethods__["ignoreEdgeWeights"] = _infomap.Config_ignoreEdgeWeights_get
    if _newclass:
        ignoreEdgeWeights = _swig_property(_infomap.Config_ignoreEdgeWeights_get, _infomap.Config_ignoreEdgeWeights_set)
    __swig_setmethods__["skipCompleteDanglingMemoryNodes"] = _infomap.Config_skipCompleteDanglingMemoryNodes_set
    __swig_getmethods__["skipCompleteDanglingMemoryNodes"] = _infomap.Config_skipCompleteDanglingMemoryNodes_get
    if _newclass:
        skipCompleteDanglingMemoryNodes = _swig_property(_infomap.Config_skipCompleteDanglingMemoryNodes_get, _infomap.Config_skipCompleteDanglingMemoryNodes_set)
    __swig_setmethods__["nodeLimit"] = _infomap.Config_nodeLimit_set
    __swig_getmethods__["nodeLimit"] = _infomap.Config_nodeLimit_get
    if _newclass:
        nodeLimit = _swig_property(_infomap.Config_nodeLimit_get, _infomap.Config_nodeLimit_set)
    __swig_setmethods__["preClusterMultilayer"] = _infomap.Config_preClusterMultilayer_set
    __swig_getmethods__["preClusterMultilayer"] = _infomap.Config_preClusterMultilayer_get
    if _newclass:
        preClusterMultilayer = _swig_property(_infomap.Config_preClusterMultilayer_get, _infomap.Config_preClusterMultilayer_set)
    __swig_setmethods__["clusterDataFile"] = _infomap.Config_clusterDataFile_set
    __swig_getmethods__["clusterDataFile"] = _infomap.Config_clusterDataFile_get
    if _newclass:
        clusterDataFile = _swig_property(_infomap.Config_clusterDataFile_get, _infomap.Config_clusterDataFile_set)
    __swig_setmethods__["clusterDataIsHard"] = _infomap.Config_clusterDataIsHard_set
    __swig_getmethods__["clusterDataIsHard"] = _infomap.Config_clusterDataIsHard_get
    if _newclass:
        clusterDataIsHard = _swig_property(_infomap.Config_clusterDataIsHard_get, _infomap.Config_clusterDataIsHard_set)
    __swig_setmethods__["setUnidentifiedNodesToClosestModule"] = _infomap.Config_setUnidentifiedNodesToClosestModule_set
    __swig_getmethods__["setUnidentifiedNodesToClosestModule"] = _infomap.Config_setUnidentifiedNodesToClosestModule_get
    if _newclass:
        setUnidentifiedNodesToClosestModule = _swig_property(_infomap.Config_setUnidentifiedNodesToClosestModule_get, _infomap.Config_setUnidentifiedNodesToClosestModule_set)
    __swig_setmethods__["noInfomap"] = _infomap.Config_noInfomap_set
    __swig_getmethods__["noInfomap"] = _infomap.Config_noInfomap_get
    if _newclass:
        noInfomap = _swig_property(_infomap.Config_noInfomap_get, _infomap.Config_noInfomap_set)
    __swig_setmethods__["flowModel"] = _infomap.Config_flowModel_set
    __swig_getmethods__["flowModel"] = _infomap.Config_flowModel_get
    if _newclass:
        flowModel = _swig_property(_infomap.Config_flowModel_get, _infomap.Config_flowModel_set)
    __swig_setmethods__["directed"] = _infomap.Config_directed_set
    __swig_getmethods__["directed"] = _infomap.Config_directed_get
    if _newclass:
        directed = _swig_property(_infomap.Config_directed_get, _infomap.Config_directed_set)
    __swig_setmethods__["undirdir"] = _infomap.Config_undirdir_set
    __swig_getmethods__["undirdir"] = _infomap.Config_undirdir_get
    if _newclass:
        undirdir = _swig_property(_infomap.Config_undirdir_get, _infomap.Config_undirdir_set)
    __swig_setmethods__["outdirdir"] = _infomap.Config_outdirdir_set
    __swig_getmethods__["outdirdir"] = _infomap.Config_outdirdir_get
    if _newclass:
        outdirdir = _swig_property(_infomap.Config_outdirdir_get, _infomap.Config_outdirdir_set)
    __swig_setmethods__["rawdir"] = _infomap.Config_rawdir_set
    __swig_getmethods__["rawdir"] = _infomap.Config_rawdir_get
    if _newclass:
        rawdir = _swig_property(_infomap.Config_rawdir_get, _infomap.Config_rawdir_set)
    __swig_setmethods__["teleportToNodes"] = _infomap.Config_teleportToNodes_set
    __swig_getmethods__["teleportToNodes"] = _infomap.Config_teleportToNodes_get
    if _newclass:
        teleportToNodes = _swig_property(_infomap.Config_teleportToNodes_get, _infomap.Config_teleportToNodes_set)
    __swig_setmethods__["selfTeleportationProbability"] = _infomap.Config_selfTeleportationProbability_set
    __swig_getmethods__["selfTeleportationProbability"] = _infomap.Config_selfTeleportationProbability_get
    if _newclass:
        selfTeleportationProbability = _swig_property(_infomap.Config_selfTeleportationProbability_get, _infomap.Config_selfTeleportationProbability_set)
    __swig_setmethods__["markovTime"] = _infomap.Config_markovTime_set
    __swig_getmethods__["markovTime"] = _infomap.Config_markovTime_get
    if _newclass:
        markovTime = _swig_property(_infomap.Config_markovTime_get, _infomap.Config_markovTime_set)
    __swig_setmethods__["multilayerRelaxRate"] = _infomap.Config_multilayerRelaxRate_set
    __swig_getmethods__["multilayerRelaxRate"] = _infomap.Config_multilayerRelaxRate_get
    if _newclass:
        multilayerRelaxRate = _swig_property(_infomap.Config_multilayerRelaxRate_get, _infomap.Config_multilayerRelaxRate_set)
    __swig_setmethods__["multilayerRelaxLimit"] = _infomap.Config_multilayerRelaxLimit_set
    __swig_getmethods__["multilayerRelaxLimit"] = _infomap.Config_multilayerRelaxLimit_get
    if _newclass:
        multilayerRelaxLimit = _swig_property(_infomap.Config_multilayerRelaxLimit_get, _infomap.Config_multilayerRelaxLimit_set)
    __swig_setmethods__["twoLevel"] = _infomap.Config_twoLevel_set
    __swig_getmethods__["twoLevel"] = _infomap.Config_twoLevel_get
    if _newclass:
        twoLevel = _swig_property(_infomap.Config_twoLevel_get, _infomap.Config_twoLevel_set)
    __swig_setmethods__["noCoarseTune"] = _infomap.Config_noCoarseTune_set
    __swig_getmethods__["noCoarseTune"] = _infomap.Config_noCoarseTune_get
    if _newclass:
        noCoarseTune = _swig_property(_infomap.Config_noCoarseTune_get, _infomap.Config_noCoarseTune_set)
    __swig_setmethods__["directedEdges"] = _infomap.Config_directedEdges_set
    __swig_getmethods__["directedEdges"] = _infomap.Config_directedEdges_get
    if _newclass:
        directedEdges = _swig_property(_infomap.Config_directedEdges_get, _infomap.Config_directedEdges_set)
    __swig_setmethods__["recordedTeleportation"] = _infomap.Config_recordedTeleportation_set
    __swig_getmethods__["recordedTeleportation"] = _infomap.Config_recordedTeleportation_get
    if _newclass:
        recordedTeleportation = _swig_property(_infomap.Config_recordedTeleportation_get, _infomap.Config_recordedTeleportation_set)
    __swig_setmethods__["teleportationProbability"] = _infomap.Config_teleportationProbability_set
    __swig_getmethods__["teleportationProbability"] = _infomap.Config_teleportationProbability_get
    if _newclass:
        teleportationProbability = _swig_property(_infomap.Config_teleportationProbability_get, _infomap.Config_teleportationProbability_set)
    __swig_setmethods__["preferredNumberOfModules"] = _infomap.Config_preferredNumberOfModules_set
    __swig_getmethods__["preferredNumberOfModules"] = _infomap.Config_preferredNumberOfModules_get
    if _newclass:
        preferredNumberOfModules = _swig_property(_infomap.Config_preferredNumberOfModules_get, _infomap.Config_preferredNumberOfModules_set)
    __swig_setmethods__["seedToRandomNumberGenerator"] = _infomap.Config_seedToRandomNumberGenerator_set
    __swig_getmethods__["seedToRandomNumberGenerator"] = _infomap.Config_seedToRandomNumberGenerator_get
    if _newclass:
        seedToRandomNumberGenerator = _swig_property(_infomap.Config_seedToRandomNumberGenerator_get, _infomap.Config_seedToRandomNumberGenerator_set)
    __swig_setmethods__["numTrials"] = _infomap.Config_numTrials_set
    __swig_getmethods__["numTrials"] = _infomap.Config_numTrials_get
    if _newclass:
        numTrials = _swig_property(_infomap.Config_numTrials_get, _infomap.Config_numTrials_set)
    __swig_setmethods__["minimumCodelengthImprovement"] = _infomap.Config_minimumCodelengthImprovement_set
    __swig_getmethods__["minimumCodelengthImprovement"] = _infomap.Config_minimumCodelengthImprovement_get
    if _newclass:
        minimumCodelengthImprovement = _swig_property(_infomap.Config_minimumCodelengthImprovement_get, _infomap.Config_minimumCodelengthImprovement_set)
    __swig_setmethods__["minimumSingleNodeCodelengthImprovement"] = _infomap.Config_minimumSingleNodeCodelengthImprovement_set
    __swig_getmethods__["minimumSingleNodeCodelengthImprovement"] = _infomap.Config_minimumSingleNodeCodelengthImprovement_get
    if _newclass:
        minimumSingleNodeCodelengthImprovement = _swig_property(_infomap.Config_minimumSingleNodeCodelengthImprovement_get, _infomap.Config_minimumSingleNodeCodelengthImprovement_set)
    __swig_setmethods__["randomizeCoreLoopLimit"] = _infomap.Config_randomizeCoreLoopLimit_set
    __swig_getmethods__["randomizeCoreLoopLimit"] = _infomap.Config_randomizeCoreLoopLimit_get
    if _newclass:
        randomizeCoreLoopLimit = _swig_property(_infomap.Config_randomizeCoreLoopLimit_get, _infomap.Config_randomizeCoreLoopLimit_set)
    __swig_setmethods__["coreLoopLimit"] = _infomap.Config_coreLoopLimit_set
    __swig_getmethods__["coreLoopLimit"] = _infomap.Config_coreLoopLimit_get
    if _newclass:
        coreLoopLimit = _swig_property(_infomap.Config_coreLoopLimit_get, _infomap.Config_coreLoopLimit_set)
    __swig_setmethods__["levelAggregationLimit"] = _infomap.Config_levelAggregationLimit_set
    __swig_getmethods__["levelAggregationLimit"] = _infomap.Config_levelAggregationLimit_get
    if _newclass:
        levelAggregationLimit = _swig_property(_infomap.Config_levelAggregationLimit_get, _infomap.Config_levelAggregationLimit_set)
    __swig_setmethods__["tuneIterationLimit"] = _infomap.Config_tuneIterationLimit_set
    __swig_getmethods__["tuneIterationLimit"] = _infomap.Config_tuneIterationLimit_get
    if _newclass:
        tuneIterationLimit = _swig_property(_infomap.Config_tuneIterationLimit_get, _infomap.Config_tuneIterationLimit_set)
    __swig_setmethods__["minimumRelativeTuneIterationImprovement"] = _infomap.Config_minimumRelativeTuneIterationImprovement_set
    __swig_getmethods__["minimumRelativeTuneIterationImprovement"] = _infomap.Config_minimumRelativeTuneIterationImprovement_get
    if _newclass:
        minimumRelativeTuneIterationImprovement = _swig_property(_infomap.Config_minimumRelativeTuneIterationImprovement_get, _infomap.Config_minimumRelativeTuneIterationImprovement_set)
    __swig_setmethods__["fastCoarseTunePartition"] = _infomap.Config_fastCoarseTunePartition_set
    __swig_getmethods__["fastCoarseTunePartition"] = _infomap.Config_fastCoarseTunePartition_get
    if _newclass:
        fastCoarseTunePartition = _swig_property(_infomap.Config_fastCoarseTunePartition_get, _infomap.Config_fastCoarseTunePartition_set)
    __swig_setmethods__["alternateCoarseTuneLevel"] = _infomap.Config_alternateCoarseTuneLevel_set
    __swig_getmethods__["alternateCoarseTuneLevel"] = _infomap.Config_alternateCoarseTuneLevel_get
    if _newclass:
        alternateCoarseTuneLevel = _swig_property(_infomap.Config_alternateCoarseTuneLevel_get, _infomap.Config_alternateCoarseTuneLevel_set)
    __swig_setmethods__["coarseTuneLevel"] = _infomap.Config_coarseTuneLevel_set
    __swig_getmethods__["coarseTuneLevel"] = _infomap.Config_coarseTuneLevel_get
    if _newclass:
        coarseTuneLevel = _swig_property(_infomap.Config_coarseTuneLevel_get, _infomap.Config_coarseTuneLevel_set)
    __swig_setmethods__["superLevelLimit"] = _infomap.Config_superLevelLimit_set
    __swig_getmethods__["superLevelLimit"] = _infomap.Config_superLevelLimit_get
    if _newclass:
        superLevelLimit = _swig_property(_infomap.Config_superLevelLimit_get, _infomap.Config_superLevelLimit_set)
    __swig_setmethods__["onlySuperModules"] = _infomap.Config_onlySuperModules_set
    __swig_getmethods__["onlySuperModules"] = _infomap.Config_onlySuperModules_get
    if _newclass:
        onlySuperModules = _swig_property(_infomap.Config_onlySuperModules_get, _infomap.Config_onlySuperModules_set)
    __swig_setmethods__["fastHierarchicalSolution"] = _infomap.Config_fastHierarchicalSolution_set
    __swig_getmethods__["fastHierarchicalSolution"] = _infomap.Config_fastHierarchicalSolution_get
    if _newclass:
        fastHierarchicalSolution = _swig_property(_infomap.Config_fastHierarchicalSolution_get, _infomap.Config_fastHierarchicalSolution_set)
    __swig_setmethods__["fastFirstIteration"] = _infomap.Config_fastFirstIteration_set
    __swig_getmethods__["fastFirstIteration"] = _infomap.Config_fastFirstIteration_get
    if _newclass:
        fastFirstIteration = _swig_property(_infomap.Config_fastFirstIteration_get, _infomap.Config_fastFirstIteration_set)
    __swig_setmethods__["skipReplaceToOneModuleIfBetter"] = _infomap.Config_skipReplaceToOneModuleIfBetter_set
    __swig_getmethods__["skipReplaceToOneModuleIfBetter"] = _infomap.Config_skipReplaceToOneModuleIfBetter_get
    if _newclass:
        skipReplaceToOneModuleIfBetter = _swig_property(_infomap.Config_skipReplaceToOneModuleIfBetter_get, _infomap.Config_skipReplaceToOneModuleIfBetter_set)
    __swig_setmethods__["lowMemoryPriority"] = _infomap.Config_lowMemoryPriority_set
    __swig_getmethods__["lowMemoryPriority"] = _infomap.Config_lowMemoryPriority_get
    if _newclass:
        lowMemoryPriority = _swig_property(_infomap.Config_lowMemoryPriority_get, _infomap.Config_lowMemoryPriority_set)
    __swig_setmethods__["innerParallelization"] = _infomap.Config_innerParallelization_set
    __swig_getmethods__["innerParallelization"] = _infomap.Config_innerParallelization_get
    if _newclass:
        innerParallelization = _swig_property(_infomap.Config_innerParallelization_get, _infomap.Config_innerParallelization_set)
    __swig_setmethods__["outDirectory"] = _infomap.Config_outDirectory_set
    __swig_getmethods__["outDirectory"] = _infomap.Config_outDirectory_get
    if _newclass:
        outDirectory = _swig_property(_infomap.Config_outDirectory_get, _infomap.Config_outDirectory_set)
    __swig_setmethods__["outName"] = _infomap.Config_outName_set
    __swig_getmethods__["outName"] = _infomap.Config_outName_get
    if _newclass:
        outName = _swig_property(_infomap.Config_outName_get, _infomap.Config_outName_set)
    __swig_setmethods__["originallyUndirected"] = _infomap.Config_originallyUndirected_set
    __swig_getmethods__["originallyUndirected"] = _infomap.Config_originallyUndirected_get
    if _newclass:
        originallyUndirected = _swig_property(_infomap.Config_originallyUndirected_get, _infomap.Config_originallyUndirected_set)
    __swig_setmethods__["printTree"] = _infomap.Config_printTree_set
    __swig_getmethods__["printTree"] = _infomap.Config_printTree_get
    if _newclass:
        printTree = _swig_property(_infomap.Config_printTree_get, _infomap.Config_printTree_set)
    __swig_setmethods__["printFlowTree"] = _infomap.Config_printFlowTree_set
    __swig_getmethods__["printFlowTree"] = _infomap.Config_printFlowTree_get
    if _newclass:
        printFlowTree = _swig_property(_infomap.Config_printFlowTree_get, _infomap.Config_printFlowTree_set)
    __swig_setmethods__["printMap"] = _infomap.Config_printMap_set
    __swig_getmethods__["printMap"] = _infomap.Config_printMap_get
    if _newclass:
        printMap = _swig_property(_infomap.Config_printMap_get, _infomap.Config_printMap_set)
    __swig_setmethods__["printClu"] = _infomap.Config_printClu_set
    __swig_getmethods__["printClu"] = _infomap.Config_printClu_get
    if _newclass:
        printClu = _swig_property(_infomap.Config_printClu_get, _infomap.Config_printClu_set)
    __swig_setmethods__["printNodeRanks"] = _infomap.Config_printNodeRanks_set
    __swig_getmethods__["printNodeRanks"] = _infomap.Config_printNodeRanks_get
    if _newclass:
        printNodeRanks = _swig_property(_infomap.Config_printNodeRanks_get, _infomap.Config_printNodeRanks_set)
    __swig_setmethods__["printFlowNetwork"] = _infomap.Config_printFlowNetwork_set
    __swig_getmethods__["printFlowNetwork"] = _infomap.Config_printFlowNetwork_get
    if _newclass:
        printFlowNetwork = _swig_property(_infomap.Config_printFlowNetwork_get, _infomap.Config_printFlowNetwork_set)
    __swig_setmethods__["printPajekNetwork"] = _infomap.Config_printPajekNetwork_set
    __swig_getmethods__["printPajekNetwork"] = _infomap.Config_printPajekNetwork_get
    if _newclass:
        printPajekNetwork = _swig_property(_infomap.Config_printPajekNetwork_get, _infomap.Config_printPajekNetwork_set)
    __swig_setmethods__["printStateNetwork"] = _infomap.Config_printStateNetwork_set
    __swig_getmethods__["printStateNetwork"] = _infomap.Config_printStateNetwork_get
    if _newclass:
        printStateNetwork = _swig_property(_infomap.Config_printStateNetwork_get, _infomap.Config_printStateNetwork_set)
    __swig_setmethods__["printBinaryTree"] = _infomap.Config_printBinaryTree_set
    __swig_getmethods__["printBinaryTree"] = _infomap.Config_printBinaryTree_get
    if _newclass:
        printBinaryTree = _swig_property(_infomap.Config_printBinaryTree_get, _infomap.Config_printBinaryTree_set)
    __swig_setmethods__["printBinaryFlowTree"] = _infomap.Config_printBinaryFlowTree_set
    __swig_getmethods__["printBinaryFlowTree"] = _infomap.Config_printBinaryFlowTree_get
    if _newclass:
        printBinaryFlowTree = _swig_property(_infomap.Config_printBinaryFlowTree_get, _infomap.Config_printBinaryFlowTree_set)
    __swig_setmethods__["printExpanded"] = _infomap.Config_printExpanded_set
    __swig_getmethods__["printExpanded"] = _infomap.Config_printExpanded_get
    if _newclass:
        printExpanded = _swig_property(_infomap.Config_printExpanded_get, _infomap.Config_printExpanded_set)
    __swig_setmethods__["noFileOutput"] = _infomap.Config_noFileOutput_set
    __swig_getmethods__["noFileOutput"] = _infomap.Config_noFileOutput_get
    if _newclass:
        noFileOutput = _swig_property(_infomap.Config_noFileOutput_get, _infomap.Config_noFileOutput_set)
    __swig_setmethods__["verbosity"] = _infomap.Config_verbosity_set
    __swig_getmethods__["verbosity"] = _infomap.Config_verbosity_get
    if _newclass:
        verbosity = _swig_property(_infomap.Config_verbosity_get, _infomap.Config_verbosity_set)
    __swig_setmethods__["verboseNumberPrecision"] = _infomap.Config_verboseNumberPrecision_set
    __swig_getmethods__["verboseNumberPrecision"] = _infomap.Config_verboseNumberPrecision_get
    if _newclass:
        verboseNumberPrecision = _swig_property(_infomap.Config_verboseNumberPrecision_get, _infomap.Config_verboseNumberPrecision_set)
    __swig_setmethods__["silent"] = _infomap.Config_silent_set
    __swig_getmethods__["silent"] = _infomap.Config_silent_get
    if _newclass:
        silent = _swig_property(_infomap.Config_silent_get, _infomap.Config_silent_set)
    __swig_setmethods__["benchmark"] = _infomap.Config_benchmark_set
    __swig_getmethods__["benchmark"] = _infomap.Config_benchmark_get
    if _newclass:
        benchmark = _swig_property(_infomap.Config_benchmark_get, _infomap.Config_benchmark_set)
    __swig_setmethods__["maxNodeIndexVisible"] = _infomap.Config_maxNodeIndexVisible_set
    __swig_getmethods__["maxNodeIndexVisible"] = _infomap.Config_maxNodeIndexVisible_get
    if _newclass:
        maxNodeIndexVisible = _swig_property(_infomap.Config_maxNodeIndexVisible_get, _infomap.Config_maxNodeIndexVisible_set)
    __swig_setmethods__["showBiNodes"] = _infomap.Config_showBiNodes_set
    __swig_getmethods__["showBiNodes"] = _infomap.Config_showBiNodes_get
    if _newclass:
        showBiNodes = _swig_property(_infomap.Config_showBiNodes_get, _infomap.Config_showBiNodes_set)
    __swig_setmethods__["minBipartiteNodeIndex"] = _infomap.Config_minBipartiteNodeIndex_set
    __swig_getmethods__["minBipartiteNodeIndex"] = _infomap.Config_minBipartiteNodeIndex_get
    if _newclass:
        minBipartiteNodeIndex = _swig_property(_infomap.Config_minBipartiteNodeIndex_get, _infomap.Config_minBipartiteNodeIndex_set)
    __swig_setmethods__["startDate"] = _infomap.Config_startDate_set
    __swig_getmethods__["startDate"] = _infomap.Config_startDate_get
    if _newclass:
        startDate = _swig_property(_infomap.Config_startDate_get, _infomap.Config_startDate_set)
    __swig_setmethods__["version"] = _infomap.Config_version_set
    __swig_getmethods__["version"] = _infomap.Config_version_get
    if _newclass:
        version = _swig_property(_infomap.Config_version_get, _infomap.Config_version_set)
    __swig_setmethods__["parsedString"] = _infomap.Config_parsedString_set
    __swig_getmethods__["parsedString"] = _infomap.Config_parsedString_get
    if _newclass:
        parsedString = _swig_property(_infomap.Config_parsedString_get, _infomap.Config_parsedString_set)
    __swig_setmethods__["parsedOptions"] = _infomap.Config_parsedOptions_set
    __swig_getmethods__["parsedOptions"] = _infomap.Config_parsedOptions_get
    if _newclass:
        parsedOptions = _swig_property(_infomap.Config_parsedOptions_get, _infomap.Config_parsedOptions_set)
    __swig_setmethods__["error"] = _infomap.Config_error_set
    __swig_getmethods__["error"] = _infomap.Config_error_get
    if _newclass:
        error = _swig_property(_infomap.Config_error_get, _infomap.Config_error_set)

    def __init__(self, *args):
        this = _infomap.new_Config(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def cloneAsNonMain(self, other):
        return _infomap.Config_cloneAsNonMain(self, other)

    def setOptimizationLevel(self, level):
        return _infomap.Config_setOptimizationLevel(self, level)

    def adaptDefaults(self):
        return _infomap.Config_adaptDefaults(self)

    def setDirectedInput(self):
        return _infomap.Config_setDirectedInput(self)

    def setMemoryInput(self):
        return _infomap.Config_setMemoryInput(self)

    def isUndirectedClustering(self):
        return _infomap.Config_isUndirectedClustering(self)

    def isUndirectedFlow(self):
        return _infomap.Config_isUndirectedFlow(self)

    def printAsUndirected(self):
        return _infomap.Config_printAsUndirected(self)

    def useTeleportation(self):
        return _infomap.Config_useTeleportation(self)

    def is3gram(self):
        return _infomap.Config_is3gram(self)

    def isPath(self):
        return _infomap.Config_isPath(self)

    def isMultilayerNetwork(self):
        return _infomap.Config_isMultilayerNetwork(self)

    def isStateNetwork(self):
        return _infomap.Config_isStateNetwork(self)

    def isBipartite(self):
        return _infomap.Config_isBipartite(self)

    def isMemoryNetwork(self):
        return _infomap.Config_isMemoryNetwork(self)

    def haveOutput(self):
        return _infomap.Config_haveOutput(self)

    def haveModularResultOutput(self):
        return _infomap.Config_haveModularResultOutput(self)

    def elapsedTime(self):
        return _infomap.Config_elapsedTime(self)

    def setError(self, err):
        return _infomap.Config_setError(self, err)

    def haveError(self):
        return _infomap.Config_haveError(self)
    if _newclass:
        fromString = staticmethod(_infomap.Config_fromString)
    else:
        fromString = _infomap.Config_fromString
    __swig_destroy__ = _infomap.delete_Config
    __del__ = lambda self: None
Config_swigregister = _infomap.Config_swigregister
Config_swigregister(Config)

def Config_fromString(flags, requireFileInput=False):
    return _infomap.Config_fromString(flags, requireFileInput)
Config_fromString = _infomap.Config_fromString

class FlowData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FlowData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FlowData, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_FlowData(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["flow"] = _infomap.FlowData_flow_set
    __swig_getmethods__["flow"] = _infomap.FlowData_flow_get
    if _newclass:
        flow = _swig_property(_infomap.FlowData_flow_get, _infomap.FlowData_flow_set)
    __swig_setmethods__["enterFlow"] = _infomap.FlowData_enterFlow_set
    __swig_getmethods__["enterFlow"] = _infomap.FlowData_enterFlow_get
    if _newclass:
        enterFlow = _swig_property(_infomap.FlowData_enterFlow_get, _infomap.FlowData_enterFlow_set)
    __swig_setmethods__["exitFlow"] = _infomap.FlowData_exitFlow_set
    __swig_getmethods__["exitFlow"] = _infomap.FlowData_exitFlow_get
    if _newclass:
        exitFlow = _swig_property(_infomap.FlowData_exitFlow_get, _infomap.FlowData_exitFlow_set)

    def __iadd__(self, other):
        return _infomap.FlowData___iadd__(self, other)

    def __isub__(self, other):
        return _infomap.FlowData___isub__(self, other)
    __swig_destroy__ = _infomap.delete_FlowData
    __del__ = lambda self: None
FlowData_swigregister = _infomap.FlowData_swigregister
FlowData_swigregister(FlowData)

class DeltaFlow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeltaFlow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DeltaFlow, name)
    __repr__ = _swig_repr
    __swig_setmethods__["module"] = _infomap.DeltaFlow_module_set
    __swig_getmethods__["module"] = _infomap.DeltaFlow_module_get
    if _newclass:
        module = _swig_property(_infomap.DeltaFlow_module_get, _infomap.DeltaFlow_module_set)
    __swig_setmethods__["deltaExit"] = _infomap.DeltaFlow_deltaExit_set
    __swig_getmethods__["deltaExit"] = _infomap.DeltaFlow_deltaExit_get
    if _newclass:
        deltaExit = _swig_property(_infomap.DeltaFlow_deltaExit_get, _infomap.DeltaFlow_deltaExit_set)
    __swig_setmethods__["deltaEnter"] = _infomap.DeltaFlow_deltaEnter_set
    __swig_getmethods__["deltaEnter"] = _infomap.DeltaFlow_deltaEnter_get
    if _newclass:
        deltaEnter = _swig_property(_infomap.DeltaFlow_deltaEnter_get, _infomap.DeltaFlow_deltaEnter_set)
    __swig_setmethods__["count"] = _infomap.DeltaFlow_count_set
    __swig_getmethods__["count"] = _infomap.DeltaFlow_count_get
    if _newclass:
        count = _swig_property(_infomap.DeltaFlow_count_get, _infomap.DeltaFlow_count_set)
    __swig_destroy__ = _infomap.delete_DeltaFlow
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _infomap.new_DeltaFlow(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iadd__(self, other):
        return _infomap.DeltaFlow___iadd__(self, other)

    def reset(self):
        return _infomap.DeltaFlow_reset(self)
DeltaFlow_swigregister = _infomap.DeltaFlow_swigregister
DeltaFlow_swigregister(DeltaFlow)

class MemDeltaFlow(DeltaFlow):
    __swig_setmethods__ = {}
    for _s in [DeltaFlow]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MemDeltaFlow, name, value)
    __swig_getmethods__ = {}
    for _s in [DeltaFlow]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MemDeltaFlow, name)
    __repr__ = _swig_repr
    __swig_setmethods__["sumDeltaPlogpPhysFlow"] = _infomap.MemDeltaFlow_sumDeltaPlogpPhysFlow_set
    __swig_getmethods__["sumDeltaPlogpPhysFlow"] = _infomap.MemDeltaFlow_sumDeltaPlogpPhysFlow_get
    if _newclass:
        sumDeltaPlogpPhysFlow = _swig_property(_infomap.MemDeltaFlow_sumDeltaPlogpPhysFlow_get, _infomap.MemDeltaFlow_sumDeltaPlogpPhysFlow_set)
    __swig_setmethods__["sumPlogpPhysFlow"] = _infomap.MemDeltaFlow_sumPlogpPhysFlow_set
    __swig_getmethods__["sumPlogpPhysFlow"] = _infomap.MemDeltaFlow_sumPlogpPhysFlow_get
    if _newclass:
        sumPlogpPhysFlow = _swig_property(_infomap.MemDeltaFlow_sumPlogpPhysFlow_get, _infomap.MemDeltaFlow_sumPlogpPhysFlow_set)

    def __init__(self, *args):
        this = _infomap.new_MemDeltaFlow(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iadd__(self, other):
        return _infomap.MemDeltaFlow___iadd__(self, other)

    def reset(self):
        return _infomap.MemDeltaFlow_reset(self)
    __swig_destroy__ = _infomap.delete_MemDeltaFlow
    __del__ = lambda self: None
MemDeltaFlow_swigregister = _infomap.MemDeltaFlow_swigregister
MemDeltaFlow_swigregister(MemDeltaFlow)

class PhysData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhysData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PhysData, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_PhysData(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["physNodeIndex"] = _infomap.PhysData_physNodeIndex_set
    __swig_getmethods__["physNodeIndex"] = _infomap.PhysData_physNodeIndex_get
    if _newclass:
        physNodeIndex = _swig_property(_infomap.PhysData_physNodeIndex_get, _infomap.PhysData_physNodeIndex_set)
    __swig_setmethods__["sumFlowFromM2Node"] = _infomap.PhysData_sumFlowFromM2Node_set
    __swig_getmethods__["sumFlowFromM2Node"] = _infomap.PhysData_sumFlowFromM2Node_get
    if _newclass:
        sumFlowFromM2Node = _swig_property(_infomap.PhysData_sumFlowFromM2Node_get, _infomap.PhysData_sumFlowFromM2Node_set)
    __swig_destroy__ = _infomap.delete_PhysData
    __del__ = lambda self: None
PhysData_swigregister = _infomap.PhysData_swigregister
PhysData_swigregister(PhysData)

class InfoNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfoNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InfoNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _infomap.InfoNode_data_set
    __swig_getmethods__["data"] = _infomap.InfoNode_data_get
    if _newclass:
        data = _swig_property(_infomap.InfoNode_data_get, _infomap.InfoNode_data_set)
    __swig_setmethods__["index"] = _infomap.InfoNode_index_set
    __swig_getmethods__["index"] = _infomap.InfoNode_index_get
    if _newclass:
        index = _swig_property(_infomap.InfoNode_index_get, _infomap.InfoNode_index_set)
    __swig_setmethods__["stateId"] = _infomap.InfoNode_stateId_set
    __swig_getmethods__["stateId"] = _infomap.InfoNode_stateId_get
    if _newclass:
        stateId = _swig_property(_infomap.InfoNode_stateId_get, _infomap.InfoNode_stateId_set)
    __swig_setmethods__["physicalId"] = _infomap.InfoNode_physicalId_set
    __swig_getmethods__["physicalId"] = _infomap.InfoNode_physicalId_get
    if _newclass:
        physicalId = _swig_property(_infomap.InfoNode_physicalId_get, _infomap.InfoNode_physicalId_set)
    __swig_setmethods__["layerId"] = _infomap.InfoNode_layerId_set
    __swig_getmethods__["layerId"] = _infomap.InfoNode_layerId_get
    if _newclass:
        layerId = _swig_property(_infomap.InfoNode_layerId_get, _infomap.InfoNode_layerId_set)
    __swig_setmethods__["owner"] = _infomap.InfoNode_owner_set
    __swig_getmethods__["owner"] = _infomap.InfoNode_owner_get
    if _newclass:
        owner = _swig_property(_infomap.InfoNode_owner_get, _infomap.InfoNode_owner_set)
    __swig_setmethods__["parent"] = _infomap.InfoNode_parent_set
    __swig_getmethods__["parent"] = _infomap.InfoNode_parent_get
    if _newclass:
        parent = _swig_property(_infomap.InfoNode_parent_get, _infomap.InfoNode_parent_set)
    __swig_setmethods__["previous"] = _infomap.InfoNode_previous_set
    __swig_getmethods__["previous"] = _infomap.InfoNode_previous_get
    if _newclass:
        previous = _swig_property(_infomap.InfoNode_previous_get, _infomap.InfoNode_previous_set)
    __swig_setmethods__["next"] = _infomap.InfoNode_next_set
    __swig_getmethods__["next"] = _infomap.InfoNode_next_get
    if _newclass:
        next = _swig_property(_infomap.InfoNode_next_get, _infomap.InfoNode_next_set)
    __swig_setmethods__["firstChild"] = _infomap.InfoNode_firstChild_set
    __swig_getmethods__["firstChild"] = _infomap.InfoNode_firstChild_get
    if _newclass:
        firstChild = _swig_property(_infomap.InfoNode_firstChild_get, _infomap.InfoNode_firstChild_set)
    __swig_setmethods__["lastChild"] = _infomap.InfoNode_lastChild_set
    __swig_getmethods__["lastChild"] = _infomap.InfoNode_lastChild_get
    if _newclass:
        lastChild = _swig_property(_infomap.InfoNode_lastChild_get, _infomap.InfoNode_lastChild_set)
    __swig_setmethods__["collapsedFirstChild"] = _infomap.InfoNode_collapsedFirstChild_set
    __swig_getmethods__["collapsedFirstChild"] = _infomap.InfoNode_collapsedFirstChild_get
    if _newclass:
        collapsedFirstChild = _swig_property(_infomap.InfoNode_collapsedFirstChild_get, _infomap.InfoNode_collapsedFirstChild_set)
    __swig_setmethods__["collapsedLastChild"] = _infomap.InfoNode_collapsedLastChild_set
    __swig_getmethods__["collapsedLastChild"] = _infomap.InfoNode_collapsedLastChild_get
    if _newclass:
        collapsedLastChild = _swig_property(_infomap.InfoNode_collapsedLastChild_get, _infomap.InfoNode_collapsedLastChild_set)
    __swig_setmethods__["codelength"] = _infomap.InfoNode_codelength_set
    __swig_getmethods__["codelength"] = _infomap.InfoNode_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.InfoNode_codelength_get, _infomap.InfoNode_codelength_set)
    __swig_setmethods__["dirty"] = _infomap.InfoNode_dirty_set
    __swig_getmethods__["dirty"] = _infomap.InfoNode_dirty_get
    if _newclass:
        dirty = _swig_property(_infomap.InfoNode_dirty_get, _infomap.InfoNode_dirty_set)
    __swig_setmethods__["physicalNodes"] = _infomap.InfoNode_physicalNodes_set
    __swig_getmethods__["physicalNodes"] = _infomap.InfoNode_physicalNodes_get
    if _newclass:
        physicalNodes = _swig_property(_infomap.InfoNode_physicalNodes_get, _infomap.InfoNode_physicalNodes_set)
    __swig_setmethods__["stateNodes"] = _infomap.InfoNode_stateNodes_set
    __swig_getmethods__["stateNodes"] = _infomap.InfoNode_stateNodes_get
    if _newclass:
        stateNodes = _swig_property(_infomap.InfoNode_stateNodes_get, _infomap.InfoNode_stateNodes_set)

    def __init__(self, *args):
        this = _infomap.new_InfoNode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfoNode
    __del__ = lambda self: None

    def getInfomap(self):
        return _infomap.InfoNode_getInfomap(self)

    def setInfomap(self, arg2):
        return _infomap.InfoNode_setInfomap(self, arg2)

    def getInfomapRoot(self, *args):
        return _infomap.InfoNode_getInfomapRoot(self, *args)

    def disposeInfomap(self):
        return _infomap.InfoNode_disposeInfomap(self)

    def numPhysicalNodes(self):
        return _infomap.InfoNode_numPhysicalNodes(self)

    def begin(self, *args):
        return _infomap.InfoNode_begin(self, *args)

    def end(self, *args):
        return _infomap.InfoNode_end(self, *args)

    def begin_child(self, *args):
        return _infomap.InfoNode_begin_child(self, *args)

    def end_child(self, *args):
        return _infomap.InfoNode_end_child(self, *args)

    def children(self, *args):
        return _infomap.InfoNode_children(self, *args)

    def infomap_children(self, *args):
        return _infomap.InfoNode_infomap_children(self, *args)

    def begin_tree(self, *args):
        return _infomap.InfoNode_begin_tree(self, *args)

    def end_tree(self, *args):
        return _infomap.InfoNode_end_tree(self, *args)

    def infomapTree(self, *args):
        return _infomap.InfoNode_infomapTree(self, *args)

    def begin_outEdge(self):
        return _infomap.InfoNode_begin_outEdge(self)

    def end_outEdge(self):
        return _infomap.InfoNode_end_outEdge(self)

    def begin_inEdge(self):
        return _infomap.InfoNode_begin_inEdge(self)

    def end_inEdge(self):
        return _infomap.InfoNode_end_inEdge(self)

    def outEdges(self):
        return _infomap.InfoNode_outEdges(self)

    def inEdges(self):
        return _infomap.InfoNode_inEdges(self)

    def childDegree(self):
        return _infomap.InfoNode_childDegree(self)

    def isLeaf(self):
        return _infomap.InfoNode_isLeaf(self)

    def isLeafModule(self):
        return _infomap.InfoNode_isLeafModule(self)

    def isRoot(self):
        return _infomap.InfoNode_isRoot(self)

    def depth(self):
        return _infomap.InfoNode_depth(self)

    def firstDepthBelow(self):
        return _infomap.InfoNode_firstDepthBelow(self)

    def numLeafMembers(self):
        return _infomap.InfoNode_numLeafMembers(self)

    def isDangling(self):
        return _infomap.InfoNode_isDangling(self)

    def outDegree(self):
        return _infomap.InfoNode_outDegree(self)

    def inDegree(self):
        return _infomap.InfoNode_inDegree(self)

    def degree(self):
        return _infomap.InfoNode_degree(self)

    def isFirst(self):
        return _infomap.InfoNode_isFirst(self)

    def isLast(self):
        return _infomap.InfoNode_isLast(self)

    def childIndex(self):
        return _infomap.InfoNode_childIndex(self)

    def calculatePath(self):
        return _infomap.InfoNode_calculatePath(self)

    def infomapChildDegree(self):
        return _infomap.InfoNode_infomapChildDegree(self)

    def __eq__(self, rhs):
        return _infomap.InfoNode___eq__(self, rhs)

    def __ne__(self, rhs):
        return _infomap.InfoNode___ne__(self, rhs)

    def initClean(self):
        return _infomap.InfoNode_initClean(self)

    def collapseChildren(self):
        return _infomap.InfoNode_collapseChildren(self)

    def expandChildren(self):
        return _infomap.InfoNode_expandChildren(self)

    def setChildDegree(self, value):
        return _infomap.InfoNode_setChildDegree(self, value)

    def setNumLeafNodes(self, value):
        return _infomap.InfoNode_setNumLeafNodes(self, value)

    def addChild(self, child):
        return _infomap.InfoNode_addChild(self, child)

    def releaseChildren(self):
        return _infomap.InfoNode_releaseChildren(self)

    def replaceChildrenWithOneNode(self):
        return _infomap.InfoNode_replaceChildrenWithOneNode(self)

    def replaceWithChildren(self):
        return _infomap.InfoNode_replaceWithChildren(self)

    def replaceWithChildrenDebug(self):
        return _infomap.InfoNode_replaceWithChildrenDebug(self)

    def replaceChildrenWithGrandChildren(self):
        return _infomap.InfoNode_replaceChildrenWithGrandChildren(self)

    def replaceChildrenWithGrandChildrenDebug(self):
        return _infomap.InfoNode_replaceChildrenWithGrandChildrenDebug(self)

    def remove(self, removeChildren):
        return _infomap.InfoNode_remove(self, removeChildren)

    def deleteChildren(self):
        return _infomap.InfoNode_deleteChildren(self)

    def addOutEdge(self, target, weight, flow=0.0):
        return _infomap.InfoNode_addOutEdge(self, target, weight, flow)
InfoNode_swigregister = _infomap.InfoNode_swigregister
InfoNode_swigregister(InfoNode)

class SwigPyIterator(_object):
    __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__ = _infomap.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _infomap.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _infomap.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _infomap.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _infomap.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _infomap.SwigPyIterator_equal(self, x)

    def copy(self):
        return _infomap.SwigPyIterator_copy(self)

    def next(self):
        return _infomap.SwigPyIterator_next(self)

    def __next__(self):
        return _infomap.SwigPyIterator___next__(self)

    def previous(self):
        return _infomap.SwigPyIterator_previous(self)

    def advance(self, n):
        return _infomap.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _infomap.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _infomap.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _infomap.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _infomap.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _infomap.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _infomap.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _infomap.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class deque_uint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, deque_uint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, deque_uint, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.deque_uint_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.deque_uint___nonzero__(self)

    def __bool__(self):
        return _infomap.deque_uint___bool__(self)

    def __len__(self):
        return _infomap.deque_uint___len__(self)

    def __getslice__(self, i, j):
        return _infomap.deque_uint___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _infomap.deque_uint___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _infomap.deque_uint___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _infomap.deque_uint___delitem__(self, *args)

    def __getitem__(self, *args):
        return _infomap.deque_uint___getitem__(self, *args)

    def __setitem__(self, *args):
        return _infomap.deque_uint___setitem__(self, *args)

    def pop(self):
        return _infomap.deque_uint_pop(self)

    def append(self, x):
        return _infomap.deque_uint_append(self, x)

    def empty(self):
        return _infomap.deque_uint_empty(self)

    def size(self):
        return _infomap.deque_uint_size(self)

    def swap(self, v):
        return _infomap.deque_uint_swap(self, v)

    def begin(self):
        return _infomap.deque_uint_begin(self)

    def end(self):
        return _infomap.deque_uint_end(self)

    def rbegin(self):
        return _infomap.deque_uint_rbegin(self)

    def rend(self):
        return _infomap.deque_uint_rend(self)

    def clear(self):
        return _infomap.deque_uint_clear(self)

    def get_allocator(self):
        return _infomap.deque_uint_get_allocator(self)

    def pop_back(self):
        return _infomap.deque_uint_pop_back(self)

    def erase(self, *args):
        return _infomap.deque_uint_erase(self, *args)

    def __init__(self, *args):
        this = _infomap.new_deque_uint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _infomap.deque_uint_push_back(self, x)

    def front(self):
        return _infomap.deque_uint_front(self)

    def back(self):
        return _infomap.deque_uint_back(self)

    def assign(self, n, x):
        return _infomap.deque_uint_assign(self, n, x)

    def resize(self, *args):
        return _infomap.deque_uint_resize(self, *args)

    def insert(self, *args):
        return _infomap.deque_uint_insert(self, *args)

    def pop_front(self):
        return _infomap.deque_uint_pop_front(self)

    def push_front(self, x):
        return _infomap.deque_uint_push_front(self, x)
    __swig_destroy__ = _infomap.delete_deque_uint
    __del__ = lambda self: None
deque_uint_swigregister = _infomap.deque_uint_swigregister
deque_uint_swigregister(deque_uint)

class InfomapIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfomapIterator
    __del__ = lambda self: None

    def current(self, *args):
        return _infomap.InfomapIterator_current(self, *args)

    def __ref__(self, *args):
        return _infomap.InfomapIterator___ref__(self, *args)

    def __deref__(self, *args):
        return _infomap.InfomapIterator___deref__(self, *args)

    def __eq__(self, other):
        return _infomap.InfomapIterator___eq__(self, other)

    def __ne__(self, other):
        return _infomap.InfomapIterator___ne__(self, other)

    def stepForward(self):
        return _infomap.InfomapIterator_stepForward(self)

    def path(self):
        return _infomap.InfomapIterator_path(self)

    def moduleIndex(self):
        return _infomap.InfomapIterator_moduleIndex(self)

    def childIndex(self):
        return _infomap.InfomapIterator_childIndex(self)

    def depth(self):
        return _infomap.InfomapIterator_depth(self)

    def isEnd(self):
        return _infomap.InfomapIterator_isEnd(self)

    def __iter__(self):
    	self._firstYielded = False
    	return self

    def __next__(self):
    	if not self._firstYielded:
    		self._firstYielded = True
    	else:
    		self.stepForward()

    	if self.isEnd():
    		raise StopIteration

    	return self

    __swig_setmethods__["data"] = _infomap.InfomapIterator_data_set
    __swig_getmethods__["data"] = _infomap.InfomapIterator_data_get
    if _newclass:
        data = _swig_property(_infomap.InfomapIterator_data_get, _infomap.InfomapIterator_data_set)
    __swig_setmethods__["index"] = _infomap.InfomapIterator_index_set
    __swig_getmethods__["index"] = _infomap.InfomapIterator_index_get
    if _newclass:
        index = _swig_property(_infomap.InfomapIterator_index_get, _infomap.InfomapIterator_index_set)
    __swig_setmethods__["stateId"] = _infomap.InfomapIterator_stateId_set
    __swig_getmethods__["stateId"] = _infomap.InfomapIterator_stateId_get
    if _newclass:
        stateId = _swig_property(_infomap.InfomapIterator_stateId_get, _infomap.InfomapIterator_stateId_set)
    __swig_setmethods__["physicalId"] = _infomap.InfomapIterator_physicalId_set
    __swig_getmethods__["physicalId"] = _infomap.InfomapIterator_physicalId_get
    if _newclass:
        physicalId = _swig_property(_infomap.InfomapIterator_physicalId_get, _infomap.InfomapIterator_physicalId_set)
    __swig_setmethods__["layerId"] = _infomap.InfomapIterator_layerId_set
    __swig_getmethods__["layerId"] = _infomap.InfomapIterator_layerId_get
    if _newclass:
        layerId = _swig_property(_infomap.InfomapIterator_layerId_get, _infomap.InfomapIterator_layerId_set)
    __swig_setmethods__["owner"] = _infomap.InfomapIterator_owner_set
    __swig_getmethods__["owner"] = _infomap.InfomapIterator_owner_get
    if _newclass:
        owner = _swig_property(_infomap.InfomapIterator_owner_get, _infomap.InfomapIterator_owner_set)
    __swig_setmethods__["parent"] = _infomap.InfomapIterator_parent_set
    __swig_getmethods__["parent"] = _infomap.InfomapIterator_parent_get
    if _newclass:
        parent = _swig_property(_infomap.InfomapIterator_parent_get, _infomap.InfomapIterator_parent_set)
    __swig_setmethods__["previous"] = _infomap.InfomapIterator_previous_set
    __swig_getmethods__["previous"] = _infomap.InfomapIterator_previous_get
    if _newclass:
        previous = _swig_property(_infomap.InfomapIterator_previous_get, _infomap.InfomapIterator_previous_set)
    __swig_setmethods__["next"] = _infomap.InfomapIterator_next_set
    __swig_getmethods__["next"] = _infomap.InfomapIterator_next_get
    if _newclass:
        next = _swig_property(_infomap.InfomapIterator_next_get, _infomap.InfomapIterator_next_set)
    __swig_setmethods__["firstChild"] = _infomap.InfomapIterator_firstChild_set
    __swig_getmethods__["firstChild"] = _infomap.InfomapIterator_firstChild_get
    if _newclass:
        firstChild = _swig_property(_infomap.InfomapIterator_firstChild_get, _infomap.InfomapIterator_firstChild_set)
    __swig_setmethods__["lastChild"] = _infomap.InfomapIterator_lastChild_set
    __swig_getmethods__["lastChild"] = _infomap.InfomapIterator_lastChild_get
    if _newclass:
        lastChild = _swig_property(_infomap.InfomapIterator_lastChild_get, _infomap.InfomapIterator_lastChild_set)
    __swig_setmethods__["collapsedFirstChild"] = _infomap.InfomapIterator_collapsedFirstChild_set
    __swig_getmethods__["collapsedFirstChild"] = _infomap.InfomapIterator_collapsedFirstChild_get
    if _newclass:
        collapsedFirstChild = _swig_property(_infomap.InfomapIterator_collapsedFirstChild_get, _infomap.InfomapIterator_collapsedFirstChild_set)
    __swig_setmethods__["collapsedLastChild"] = _infomap.InfomapIterator_collapsedLastChild_set
    __swig_getmethods__["collapsedLastChild"] = _infomap.InfomapIterator_collapsedLastChild_get
    if _newclass:
        collapsedLastChild = _swig_property(_infomap.InfomapIterator_collapsedLastChild_get, _infomap.InfomapIterator_collapsedLastChild_set)
    __swig_setmethods__["codelength"] = _infomap.InfomapIterator_codelength_set
    __swig_getmethods__["codelength"] = _infomap.InfomapIterator_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.InfomapIterator_codelength_get, _infomap.InfomapIterator_codelength_set)
    __swig_setmethods__["dirty"] = _infomap.InfomapIterator_dirty_set
    __swig_getmethods__["dirty"] = _infomap.InfomapIterator_dirty_get
    if _newclass:
        dirty = _swig_property(_infomap.InfomapIterator_dirty_get, _infomap.InfomapIterator_dirty_set)
    __swig_setmethods__["physicalNodes"] = _infomap.InfomapIterator_physicalNodes_set
    __swig_getmethods__["physicalNodes"] = _infomap.InfomapIterator_physicalNodes_get
    if _newclass:
        physicalNodes = _swig_property(_infomap.InfomapIterator_physicalNodes_get, _infomap.InfomapIterator_physicalNodes_set)
    __swig_setmethods__["stateNodes"] = _infomap.InfomapIterator_stateNodes_set
    __swig_getmethods__["stateNodes"] = _infomap.InfomapIterator_stateNodes_get
    if _newclass:
        stateNodes = _swig_property(_infomap.InfomapIterator_stateNodes_get, _infomap.InfomapIterator_stateNodes_set)

    def getInfomap(self):
        return _infomap.InfomapIterator_getInfomap(self)

    def setInfomap(self, arg2):
        return _infomap.InfomapIterator_setInfomap(self, arg2)

    def getInfomapRoot(self, *args):
        return _infomap.InfomapIterator_getInfomapRoot(self, *args)

    def disposeInfomap(self):
        return _infomap.InfomapIterator_disposeInfomap(self)

    def numPhysicalNodes(self):
        return _infomap.InfomapIterator_numPhysicalNodes(self)

    def begin(self, *args):
        return _infomap.InfomapIterator_begin(self, *args)

    def end(self, *args):
        return _infomap.InfomapIterator_end(self, *args)

    def begin_child(self, *args):
        return _infomap.InfomapIterator_begin_child(self, *args)

    def end_child(self, *args):
        return _infomap.InfomapIterator_end_child(self, *args)

    def children(self, *args):
        return _infomap.InfomapIterator_children(self, *args)

    def infomap_children(self, *args):
        return _infomap.InfomapIterator_infomap_children(self, *args)

    def begin_tree(self, *args):
        return _infomap.InfomapIterator_begin_tree(self, *args)

    def end_tree(self, *args):
        return _infomap.InfomapIterator_end_tree(self, *args)

    def infomapTree(self, *args):
        return _infomap.InfomapIterator_infomapTree(self, *args)

    def begin_outEdge(self):
        return _infomap.InfomapIterator_begin_outEdge(self)

    def end_outEdge(self):
        return _infomap.InfomapIterator_end_outEdge(self)

    def begin_inEdge(self):
        return _infomap.InfomapIterator_begin_inEdge(self)

    def end_inEdge(self):
        return _infomap.InfomapIterator_end_inEdge(self)

    def outEdges(self):
        return _infomap.InfomapIterator_outEdges(self)

    def inEdges(self):
        return _infomap.InfomapIterator_inEdges(self)

    def childDegree(self):
        return _infomap.InfomapIterator_childDegree(self)

    def isLeaf(self):
        return _infomap.InfomapIterator_isLeaf(self)

    def isLeafModule(self):
        return _infomap.InfomapIterator_isLeafModule(self)

    def isRoot(self):
        return _infomap.InfomapIterator_isRoot(self)

    def firstDepthBelow(self):
        return _infomap.InfomapIterator_firstDepthBelow(self)

    def numLeafMembers(self):
        return _infomap.InfomapIterator_numLeafMembers(self)

    def isDangling(self):
        return _infomap.InfomapIterator_isDangling(self)

    def outDegree(self):
        return _infomap.InfomapIterator_outDegree(self)

    def inDegree(self):
        return _infomap.InfomapIterator_inDegree(self)

    def degree(self):
        return _infomap.InfomapIterator_degree(self)

    def isFirst(self):
        return _infomap.InfomapIterator_isFirst(self)

    def isLast(self):
        return _infomap.InfomapIterator_isLast(self)

    def calculatePath(self):
        return _infomap.InfomapIterator_calculatePath(self)

    def infomapChildDegree(self):
        return _infomap.InfomapIterator_infomapChildDegree(self)

    def initClean(self):
        return _infomap.InfomapIterator_initClean(self)

    def collapseChildren(self):
        return _infomap.InfomapIterator_collapseChildren(self)

    def expandChildren(self):
        return _infomap.InfomapIterator_expandChildren(self)

    def setChildDegree(self, value):
        return _infomap.InfomapIterator_setChildDegree(self, value)

    def setNumLeafNodes(self, value):
        return _infomap.InfomapIterator_setNumLeafNodes(self, value)

    def addChild(self, child):
        return _infomap.InfomapIterator_addChild(self, child)

    def releaseChildren(self):
        return _infomap.InfomapIterator_releaseChildren(self)

    def replaceChildrenWithOneNode(self):
        return _infomap.InfomapIterator_replaceChildrenWithOneNode(self)

    def replaceWithChildren(self):
        return _infomap.InfomapIterator_replaceWithChildren(self)

    def replaceWithChildrenDebug(self):
        return _infomap.InfomapIterator_replaceWithChildrenDebug(self)

    def replaceChildrenWithGrandChildren(self):
        return _infomap.InfomapIterator_replaceChildrenWithGrandChildren(self)

    def replaceChildrenWithGrandChildrenDebug(self):
        return _infomap.InfomapIterator_replaceChildrenWithGrandChildrenDebug(self)

    def remove(self, removeChildren):
        return _infomap.InfomapIterator_remove(self, removeChildren)

    def deleteChildren(self):
        return _infomap.InfomapIterator_deleteChildren(self)

    def addOutEdge(self, target, weight, flow=0.0):
        return _infomap.InfomapIterator_addOutEdge(self, target, weight, flow)
InfomapIterator_swigregister = _infomap.InfomapIterator_swigregister
InfomapIterator_swigregister(InfomapIterator)

class InfomapModuleIterator(InfomapIterator):
    __swig_setmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapModuleIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapModuleIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapModuleIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfomapModuleIterator
    __del__ = lambda self: None
InfomapModuleIterator_swigregister = _infomap.InfomapModuleIterator_swigregister
InfomapModuleIterator_swigregister(InfomapModuleIterator)

class InfomapLeafModuleIterator(InfomapIterator):
    __swig_setmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapLeafModuleIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapLeafModuleIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapLeafModuleIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def init(self):
        return _infomap.InfomapLeafModuleIterator_init(self)

    def __iter__(self):
    	self._firstYielded = False
    	return self

    def __next__(self):
    	if not self._firstYielded:
    		self._firstYielded = True
    	else:
    		self.stepForward()

    	if self.isEnd():
    		raise StopIteration

    	return self

    __swig_destroy__ = _infomap.delete_InfomapLeafModuleIterator
    __del__ = lambda self: None
InfomapLeafModuleIterator_swigregister = _infomap.InfomapLeafModuleIterator_swigregister
InfomapLeafModuleIterator_swigregister(InfomapLeafModuleIterator)

class InfomapLeafIterator(InfomapIterator):
    __swig_setmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapLeafIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapLeafIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapLeafIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def init(self):
        return _infomap.InfomapLeafIterator_init(self)

    def __iter__(self):
    	self._firstYielded = False
    	return self

    def __next__(self):
    	if not self._firstYielded:
    		self._firstYielded = True
    	else:
    		self.stepForward()

    	if self.isEnd():
    		raise StopIteration

    	return self

    __swig_destroy__ = _infomap.delete_InfomapLeafIterator
    __del__ = lambda self: None
InfomapLeafIterator_swigregister = _infomap.InfomapLeafIterator_swigregister
InfomapLeafIterator_swigregister(InfomapLeafIterator)

class InfomapIteratorPhysical(InfomapIterator):
    __swig_setmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapIteratorPhysical, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapIterator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapIteratorPhysical, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapIteratorPhysical(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iter__(self):
    	self._firstYielded = False
    	return self

    def __next__(self):
    	if not self._firstYielded:
    		self._firstYielded = True
    	else:
    		self.stepForward()

    	if self.isEnd():
    		raise StopIteration

    	return self

    __swig_destroy__ = _infomap.delete_InfomapIteratorPhysical
    __del__ = lambda self: None
InfomapIteratorPhysical_swigregister = _infomap.InfomapIteratorPhysical_swigregister
InfomapIteratorPhysical_swigregister(InfomapIteratorPhysical)

class InfomapLeafIteratorPhysical(InfomapIteratorPhysical):
    __swig_setmethods__ = {}
    for _s in [InfomapIteratorPhysical]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapLeafIteratorPhysical, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapIteratorPhysical]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapLeafIteratorPhysical, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapLeafIteratorPhysical(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def init(self):
        return _infomap.InfomapLeafIteratorPhysical_init(self)

    def __iter__(self):
    	self._firstYielded = False
    	return self

    def __next__(self):
    	if not self._firstYielded:
    		self._firstYielded = True
    	else:
    		self.stepForward()

    	if self.isEnd():
    		raise StopIteration

    	return self

    __swig_destroy__ = _infomap.delete_InfomapLeafIteratorPhysical
    __del__ = lambda self: None
InfomapLeafIteratorPhysical_swigregister = _infomap.InfomapLeafIteratorPhysical_swigregister
InfomapLeafIteratorPhysical_swigregister(InfomapLeafIteratorPhysical)

class InfomapParentIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapParentIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapParentIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapParentIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfomapParentIterator
    __del__ = lambda self: None

    def current(self, *args):
        return _infomap.InfomapParentIterator_current(self, *args)

    def __ref__(self, *args):
        return _infomap.InfomapParentIterator___ref__(self, *args)

    def __deref__(self, *args):
        return _infomap.InfomapParentIterator___deref__(self, *args)

    def __eq__(self, other):
        return _infomap.InfomapParentIterator___eq__(self, other)

    def __ne__(self, other):
        return _infomap.InfomapParentIterator___ne__(self, other)

    def stepForward(self):
        return _infomap.InfomapParentIterator_stepForward(self)

    def isEnd(self):
        return _infomap.InfomapParentIterator_isEnd(self)
    __swig_setmethods__["data"] = _infomap.InfomapParentIterator_data_set
    __swig_getmethods__["data"] = _infomap.InfomapParentIterator_data_get
    if _newclass:
        data = _swig_property(_infomap.InfomapParentIterator_data_get, _infomap.InfomapParentIterator_data_set)
    __swig_setmethods__["index"] = _infomap.InfomapParentIterator_index_set
    __swig_getmethods__["index"] = _infomap.InfomapParentIterator_index_get
    if _newclass:
        index = _swig_property(_infomap.InfomapParentIterator_index_get, _infomap.InfomapParentIterator_index_set)
    __swig_setmethods__["stateId"] = _infomap.InfomapParentIterator_stateId_set
    __swig_getmethods__["stateId"] = _infomap.InfomapParentIterator_stateId_get
    if _newclass:
        stateId = _swig_property(_infomap.InfomapParentIterator_stateId_get, _infomap.InfomapParentIterator_stateId_set)
    __swig_setmethods__["physicalId"] = _infomap.InfomapParentIterator_physicalId_set
    __swig_getmethods__["physicalId"] = _infomap.InfomapParentIterator_physicalId_get
    if _newclass:
        physicalId = _swig_property(_infomap.InfomapParentIterator_physicalId_get, _infomap.InfomapParentIterator_physicalId_set)
    __swig_setmethods__["layerId"] = _infomap.InfomapParentIterator_layerId_set
    __swig_getmethods__["layerId"] = _infomap.InfomapParentIterator_layerId_get
    if _newclass:
        layerId = _swig_property(_infomap.InfomapParentIterator_layerId_get, _infomap.InfomapParentIterator_layerId_set)
    __swig_setmethods__["owner"] = _infomap.InfomapParentIterator_owner_set
    __swig_getmethods__["owner"] = _infomap.InfomapParentIterator_owner_get
    if _newclass:
        owner = _swig_property(_infomap.InfomapParentIterator_owner_get, _infomap.InfomapParentIterator_owner_set)
    __swig_setmethods__["parent"] = _infomap.InfomapParentIterator_parent_set
    __swig_getmethods__["parent"] = _infomap.InfomapParentIterator_parent_get
    if _newclass:
        parent = _swig_property(_infomap.InfomapParentIterator_parent_get, _infomap.InfomapParentIterator_parent_set)
    __swig_setmethods__["previous"] = _infomap.InfomapParentIterator_previous_set
    __swig_getmethods__["previous"] = _infomap.InfomapParentIterator_previous_get
    if _newclass:
        previous = _swig_property(_infomap.InfomapParentIterator_previous_get, _infomap.InfomapParentIterator_previous_set)
    __swig_setmethods__["next"] = _infomap.InfomapParentIterator_next_set
    __swig_getmethods__["next"] = _infomap.InfomapParentIterator_next_get
    if _newclass:
        next = _swig_property(_infomap.InfomapParentIterator_next_get, _infomap.InfomapParentIterator_next_set)
    __swig_setmethods__["firstChild"] = _infomap.InfomapParentIterator_firstChild_set
    __swig_getmethods__["firstChild"] = _infomap.InfomapParentIterator_firstChild_get
    if _newclass:
        firstChild = _swig_property(_infomap.InfomapParentIterator_firstChild_get, _infomap.InfomapParentIterator_firstChild_set)
    __swig_setmethods__["lastChild"] = _infomap.InfomapParentIterator_lastChild_set
    __swig_getmethods__["lastChild"] = _infomap.InfomapParentIterator_lastChild_get
    if _newclass:
        lastChild = _swig_property(_infomap.InfomapParentIterator_lastChild_get, _infomap.InfomapParentIterator_lastChild_set)
    __swig_setmethods__["collapsedFirstChild"] = _infomap.InfomapParentIterator_collapsedFirstChild_set
    __swig_getmethods__["collapsedFirstChild"] = _infomap.InfomapParentIterator_collapsedFirstChild_get
    if _newclass:
        collapsedFirstChild = _swig_property(_infomap.InfomapParentIterator_collapsedFirstChild_get, _infomap.InfomapParentIterator_collapsedFirstChild_set)
    __swig_setmethods__["collapsedLastChild"] = _infomap.InfomapParentIterator_collapsedLastChild_set
    __swig_getmethods__["collapsedLastChild"] = _infomap.InfomapParentIterator_collapsedLastChild_get
    if _newclass:
        collapsedLastChild = _swig_property(_infomap.InfomapParentIterator_collapsedLastChild_get, _infomap.InfomapParentIterator_collapsedLastChild_set)
    __swig_setmethods__["codelength"] = _infomap.InfomapParentIterator_codelength_set
    __swig_getmethods__["codelength"] = _infomap.InfomapParentIterator_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.InfomapParentIterator_codelength_get, _infomap.InfomapParentIterator_codelength_set)
    __swig_setmethods__["dirty"] = _infomap.InfomapParentIterator_dirty_set
    __swig_getmethods__["dirty"] = _infomap.InfomapParentIterator_dirty_get
    if _newclass:
        dirty = _swig_property(_infomap.InfomapParentIterator_dirty_get, _infomap.InfomapParentIterator_dirty_set)
    __swig_setmethods__["physicalNodes"] = _infomap.InfomapParentIterator_physicalNodes_set
    __swig_getmethods__["physicalNodes"] = _infomap.InfomapParentIterator_physicalNodes_get
    if _newclass:
        physicalNodes = _swig_property(_infomap.InfomapParentIterator_physicalNodes_get, _infomap.InfomapParentIterator_physicalNodes_set)
    __swig_setmethods__["stateNodes"] = _infomap.InfomapParentIterator_stateNodes_set
    __swig_getmethods__["stateNodes"] = _infomap.InfomapParentIterator_stateNodes_get
    if _newclass:
        stateNodes = _swig_property(_infomap.InfomapParentIterator_stateNodes_get, _infomap.InfomapParentIterator_stateNodes_set)

    def getInfomap(self):
        return _infomap.InfomapParentIterator_getInfomap(self)

    def setInfomap(self, arg2):
        return _infomap.InfomapParentIterator_setInfomap(self, arg2)

    def getInfomapRoot(self, *args):
        return _infomap.InfomapParentIterator_getInfomapRoot(self, *args)

    def disposeInfomap(self):
        return _infomap.InfomapParentIterator_disposeInfomap(self)

    def numPhysicalNodes(self):
        return _infomap.InfomapParentIterator_numPhysicalNodes(self)

    def begin(self, *args):
        return _infomap.InfomapParentIterator_begin(self, *args)

    def end(self, *args):
        return _infomap.InfomapParentIterator_end(self, *args)

    def begin_child(self, *args):
        return _infomap.InfomapParentIterator_begin_child(self, *args)

    def end_child(self, *args):
        return _infomap.InfomapParentIterator_end_child(self, *args)

    def children(self, *args):
        return _infomap.InfomapParentIterator_children(self, *args)

    def infomap_children(self, *args):
        return _infomap.InfomapParentIterator_infomap_children(self, *args)

    def begin_tree(self, *args):
        return _infomap.InfomapParentIterator_begin_tree(self, *args)

    def end_tree(self, *args):
        return _infomap.InfomapParentIterator_end_tree(self, *args)

    def infomapTree(self, *args):
        return _infomap.InfomapParentIterator_infomapTree(self, *args)

    def begin_outEdge(self):
        return _infomap.InfomapParentIterator_begin_outEdge(self)

    def end_outEdge(self):
        return _infomap.InfomapParentIterator_end_outEdge(self)

    def begin_inEdge(self):
        return _infomap.InfomapParentIterator_begin_inEdge(self)

    def end_inEdge(self):
        return _infomap.InfomapParentIterator_end_inEdge(self)

    def outEdges(self):
        return _infomap.InfomapParentIterator_outEdges(self)

    def inEdges(self):
        return _infomap.InfomapParentIterator_inEdges(self)

    def childDegree(self):
        return _infomap.InfomapParentIterator_childDegree(self)

    def isLeaf(self):
        return _infomap.InfomapParentIterator_isLeaf(self)

    def isLeafModule(self):
        return _infomap.InfomapParentIterator_isLeafModule(self)

    def isRoot(self):
        return _infomap.InfomapParentIterator_isRoot(self)

    def depth(self):
        return _infomap.InfomapParentIterator_depth(self)

    def firstDepthBelow(self):
        return _infomap.InfomapParentIterator_firstDepthBelow(self)

    def numLeafMembers(self):
        return _infomap.InfomapParentIterator_numLeafMembers(self)

    def isDangling(self):
        return _infomap.InfomapParentIterator_isDangling(self)

    def outDegree(self):
        return _infomap.InfomapParentIterator_outDegree(self)

    def inDegree(self):
        return _infomap.InfomapParentIterator_inDegree(self)

    def degree(self):
        return _infomap.InfomapParentIterator_degree(self)

    def isFirst(self):
        return _infomap.InfomapParentIterator_isFirst(self)

    def isLast(self):
        return _infomap.InfomapParentIterator_isLast(self)

    def childIndex(self):
        return _infomap.InfomapParentIterator_childIndex(self)

    def calculatePath(self):
        return _infomap.InfomapParentIterator_calculatePath(self)

    def infomapChildDegree(self):
        return _infomap.InfomapParentIterator_infomapChildDegree(self)

    def initClean(self):
        return _infomap.InfomapParentIterator_initClean(self)

    def collapseChildren(self):
        return _infomap.InfomapParentIterator_collapseChildren(self)

    def expandChildren(self):
        return _infomap.InfomapParentIterator_expandChildren(self)

    def setChildDegree(self, value):
        return _infomap.InfomapParentIterator_setChildDegree(self, value)

    def setNumLeafNodes(self, value):
        return _infomap.InfomapParentIterator_setNumLeafNodes(self, value)

    def addChild(self, child):
        return _infomap.InfomapParentIterator_addChild(self, child)

    def releaseChildren(self):
        return _infomap.InfomapParentIterator_releaseChildren(self)

    def replaceChildrenWithOneNode(self):
        return _infomap.InfomapParentIterator_replaceChildrenWithOneNode(self)

    def replaceWithChildren(self):
        return _infomap.InfomapParentIterator_replaceWithChildren(self)

    def replaceWithChildrenDebug(self):
        return _infomap.InfomapParentIterator_replaceWithChildrenDebug(self)

    def replaceChildrenWithGrandChildren(self):
        return _infomap.InfomapParentIterator_replaceChildrenWithGrandChildren(self)

    def replaceChildrenWithGrandChildrenDebug(self):
        return _infomap.InfomapParentIterator_replaceChildrenWithGrandChildrenDebug(self)

    def remove(self, removeChildren):
        return _infomap.InfomapParentIterator_remove(self, removeChildren)

    def deleteChildren(self):
        return _infomap.InfomapParentIterator_deleteChildren(self)

    def addOutEdge(self, target, weight, flow=0.0):
        return _infomap.InfomapParentIterator_addOutEdge(self, target, weight, flow)
InfomapParentIterator_swigregister = _infomap.InfomapParentIterator_swigregister
InfomapParentIterator_swigregister(InfomapParentIterator)

class vector_uint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_uint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_uint, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.vector_uint_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.vector_uint___nonzero__(self)

    def __bool__(self):
        return _infomap.vector_uint___bool__(self)

    def __len__(self):
        return _infomap.vector_uint___len__(self)

    def __getslice__(self, i, j):
        return _infomap.vector_uint___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _infomap.vector_uint___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _infomap.vector_uint___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _infomap.vector_uint___delitem__(self, *args)

    def __getitem__(self, *args):
        return _infomap.vector_uint___getitem__(self, *args)

    def __setitem__(self, *args):
        return _infomap.vector_uint___setitem__(self, *args)

    def pop(self):
        return _infomap.vector_uint_pop(self)

    def append(self, x):
        return _infomap.vector_uint_append(self, x)

    def empty(self):
        return _infomap.vector_uint_empty(self)

    def size(self):
        return _infomap.vector_uint_size(self)

    def swap(self, v):
        return _infomap.vector_uint_swap(self, v)

    def begin(self):
        return _infomap.vector_uint_begin(self)

    def end(self):
        return _infomap.vector_uint_end(self)

    def rbegin(self):
        return _infomap.vector_uint_rbegin(self)

    def rend(self):
        return _infomap.vector_uint_rend(self)

    def clear(self):
        return _infomap.vector_uint_clear(self)

    def get_allocator(self):
        return _infomap.vector_uint_get_allocator(self)

    def pop_back(self):
        return _infomap.vector_uint_pop_back(self)

    def erase(self, *args):
        return _infomap.vector_uint_erase(self, *args)

    def __init__(self, *args):
        this = _infomap.new_vector_uint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _infomap.vector_uint_push_back(self, x)

    def front(self):
        return _infomap.vector_uint_front(self)

    def back(self):
        return _infomap.vector_uint_back(self)

    def assign(self, n, x):
        return _infomap.vector_uint_assign(self, n, x)

    def resize(self, *args):
        return _infomap.vector_uint_resize(self, *args)

    def insert(self, *args):
        return _infomap.vector_uint_insert(self, *args)

    def reserve(self, n):
        return _infomap.vector_uint_reserve(self, n)

    def capacity(self):
        return _infomap.vector_uint_capacity(self)
    __swig_destroy__ = _infomap.delete_vector_uint
    __del__ = lambda self: None
vector_uint_swigregister = _infomap.vector_uint_swigregister
vector_uint_swigregister(vector_uint)

class StateNetwork(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StateNetwork, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StateNetwork, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_StateNetwork(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_StateNetwork
    __del__ = lambda self: None

    def setConfig(self, config):
        return _infomap.StateNetwork_setConfig(self, config)

    def getConfig(self):
        return _infomap.StateNetwork_getConfig(self)

    def addStateNode(self, *args):
        return _infomap.StateNetwork_addStateNode(self, *args)

    def addNode(self, *args):
        return _infomap.StateNetwork_addNode(self, *args)

    def addPhysicalNode(self, *args):
        return _infomap.StateNetwork_addPhysicalNode(self, *args)

    def addName(self, id, arg3):
        return _infomap.StateNetwork_addName(self, id, arg3)

    def addLink(self, sourceId, targetId, weight=1.0):
        return _infomap.StateNetwork_addLink(self, sourceId, targetId, weight)

    def addPath(self, nodes, markovOrder, weight=1.0):
        return _infomap.StateNetwork_addPath(self, nodes, markovOrder, weight)

    def calculateFlow(self):
        return _infomap.StateNetwork_calculateFlow(self)

    def dispose(self):
        return _infomap.StateNetwork_dispose(self)

    def nodes(self):
        return _infomap.StateNetwork_nodes(self)

    def numNodes(self):
        return _infomap.StateNetwork_numNodes(self)

    def numPhysicalNodes(self):
        return _infomap.StateNetwork_numPhysicalNodes(self)

    def nodeLinkMap(self, *args):
        return _infomap.StateNetwork_nodeLinkMap(self, *args)

    def numLinks(self):
        return _infomap.StateNetwork_numLinks(self)

    def sumLinkWeight(self):
        return _infomap.StateNetwork_sumLinkWeight(self)

    def sumSelfLinkWeight(self):
        return _infomap.StateNetwork_sumSelfLinkWeight(self)

    def outWeights(self):
        return _infomap.StateNetwork_outWeights(self)

    def names(self, *args):
        return _infomap.StateNetwork_names(self, *args)

    def haveDirectedInput(self):
        return _infomap.StateNetwork_haveDirectedInput(self)

    def haveMemoryInput(self):
        return _infomap.StateNetwork_haveMemoryInput(self)

    def writeStateNetwork(self, filename):
        return _infomap.StateNetwork_writeStateNetwork(self, filename)

    def writePajekNetwork(self, filename):
        return _infomap.StateNetwork_writePajekNetwork(self, filename)
StateNetwork_swigregister = _infomap.StateNetwork_swigregister
StateNetwork_swigregister(StateNetwork)

class Network(StateNetwork):
    __swig_setmethods__ = {}
    for _s in [StateNetwork]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Network, name, value)
    __swig_getmethods__ = {}
    for _s in [StateNetwork]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Network, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Network(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_Network
    __del__ = lambda self: None

    def readInputData(self, *args):
        return _infomap.Network_readInputData(self, *args)

    def generateStateNetworkFromMultilayer(self):
        return _infomap.Network_generateStateNetworkFromMultilayer(self)

    def generateStateNetworkFromMultilayerWithInterLinks(self):
        return _infomap.Network_generateStateNetworkFromMultilayerWithInterLinks(self)

    def generateStateNetworkFromMultilayerWithSimulatedInterLinks(self):
        return _infomap.Network_generateStateNetworkFromMultilayerWithSimulatedInterLinks(self)

    def simulateInterLayerLinks(self):
        return _infomap.Network_simulateInterLayerLinks(self)

    def addMultilayerLink(self, layer1, n1, layer2, n2, weight):
        return _infomap.Network_addMultilayerLink(self, layer1, n1, layer2, n2, weight)

    def addMultilayerIntraLink(self, layer, n1, n2, weight):
        return _infomap.Network_addMultilayerIntraLink(self, layer, n1, n2, weight)

    def addMultilayerInterLink(self, layer1, n, layer2, interWeight):
        return _infomap.Network_addMultilayerInterLink(self, layer1, n, layer2, interWeight)
Network_swigregister = _infomap.Network_swigregister
Network_swigregister(Network)

class LayerNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayerNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LayerNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["layer"] = _infomap.LayerNode_layer_set
    __swig_getmethods__["layer"] = _infomap.LayerNode_layer_get
    if _newclass:
        layer = _swig_property(_infomap.LayerNode_layer_get, _infomap.LayerNode_layer_set)
    __swig_setmethods__["node"] = _infomap.LayerNode_node_set
    __swig_getmethods__["node"] = _infomap.LayerNode_node_get
    if _newclass:
        node = _swig_property(_infomap.LayerNode_node_get, _infomap.LayerNode_node_set)

    def __init__(self, layer=0, node=0):
        this = _infomap.new_LayerNode(layer, node)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __lt__(self, other):
        return _infomap.LayerNode___lt__(self, other)
    __swig_destroy__ = _infomap.delete_LayerNode
    __del__ = lambda self: None
LayerNode_swigregister = _infomap.LayerNode_swigregister
LayerNode_swigregister(LayerNode)

class Bigram(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bigram, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bigram, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _infomap.Bigram_first_set
    __swig_getmethods__["first"] = _infomap.Bigram_first_get
    if _newclass:
        first = _swig_property(_infomap.Bigram_first_get, _infomap.Bigram_first_set)
    __swig_setmethods__["second"] = _infomap.Bigram_second_set
    __swig_getmethods__["second"] = _infomap.Bigram_second_get
    if _newclass:
        second = _swig_property(_infomap.Bigram_second_get, _infomap.Bigram_second_set)

    def __init__(self, first=0, second=0):
        this = _infomap.new_Bigram(first, second)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __lt__(self, other):
        return _infomap.Bigram___lt__(self, other)
    __swig_destroy__ = _infomap.delete_Bigram
    __del__ = lambda self: None
Bigram_swigregister = _infomap.Bigram_swigregister
Bigram_swigregister(Bigram)

class BipartiteLink(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BipartiteLink, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BipartiteLink, name)
    __repr__ = _swig_repr
    __swig_setmethods__["featureNode"] = _infomap.BipartiteLink_featureNode_set
    __swig_getmethods__["featureNode"] = _infomap.BipartiteLink_featureNode_get
    if _newclass:
        featureNode = _swig_property(_infomap.BipartiteLink_featureNode_get, _infomap.BipartiteLink_featureNode_set)
    __swig_setmethods__["node"] = _infomap.BipartiteLink_node_set
    __swig_getmethods__["node"] = _infomap.BipartiteLink_node_get
    if _newclass:
        node = _swig_property(_infomap.BipartiteLink_node_get, _infomap.BipartiteLink_node_set)
    __swig_setmethods__["swapOrder"] = _infomap.BipartiteLink_swapOrder_set
    __swig_getmethods__["swapOrder"] = _infomap.BipartiteLink_swapOrder_get
    if _newclass:
        swapOrder = _swig_property(_infomap.BipartiteLink_swapOrder_get, _infomap.BipartiteLink_swapOrder_set)

    def __init__(self, featureNode=0, node=0, swapOrder=False):
        this = _infomap.new_BipartiteLink(featureNode, node, swapOrder)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __lt__(self, other):
        return _infomap.BipartiteLink___lt__(self, other)
    __swig_destroy__ = _infomap.delete_BipartiteLink
    __del__ = lambda self: None
BipartiteLink_swigregister = _infomap.BipartiteLink_swigregister
BipartiteLink_swigregister(BipartiteLink)

class Weight(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Weight, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Weight, name)
    __repr__ = _swig_repr
    __swig_setmethods__["weight"] = _infomap.Weight_weight_set
    __swig_getmethods__["weight"] = _infomap.Weight_weight_get
    if _newclass:
        weight = _swig_property(_infomap.Weight_weight_get, _infomap.Weight_weight_set)

    def __init__(self, weight=0):
        this = _infomap.new_Weight(weight)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iadd__(self, w):
        return _infomap.Weight___iadd__(self, w)
    __swig_destroy__ = _infomap.delete_Weight
    __del__ = lambda self: None
Weight_swigregister = _infomap.Weight_swigregister
Weight_swigregister(Weight)

class Triple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Triple, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Triple(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_Triple
    __del__ = lambda self: None

    def __lt__(self, other):
        return _infomap.Triple___lt__(self, other)

    def __eq__(self, other):
        return _infomap.Triple___eq__(self, other)
    __swig_setmethods__["n1"] = _infomap.Triple_n1_set
    __swig_getmethods__["n1"] = _infomap.Triple_n1_get
    if _newclass:
        n1 = _swig_property(_infomap.Triple_n1_get, _infomap.Triple_n1_set)
    __swig_setmethods__["n2"] = _infomap.Triple_n2_set
    __swig_getmethods__["n2"] = _infomap.Triple_n2_get
    if _newclass:
        n2 = _swig_property(_infomap.Triple_n2_get, _infomap.Triple_n2_set)
    __swig_setmethods__["n3"] = _infomap.Triple_n3_set
    __swig_getmethods__["n3"] = _infomap.Triple_n3_get
    if _newclass:
        n3 = _swig_property(_infomap.Triple_n3_get, _infomap.Triple_n3_set)
Triple_swigregister = _infomap.Triple_swigregister
Triple_swigregister(Triple)

class InfomapConfigInfomapBase(Config):
    __swig_setmethods__ = {}
    for _s in [Config]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapConfigInfomapBase, name, value)
    __swig_getmethods__ = {}
    for _s in [Config]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapConfigInfomapBase, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapConfigInfomapBase(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfomapConfigInfomapBase
    __del__ = lambda self: None

    def getConfig(self):
        return _infomap.InfomapConfigInfomapBase_getConfig(self)

    def setConfig(self, conf):
        return _infomap.InfomapConfigInfomapBase_setConfig(self, conf)

    def setNonMainConfig(self, conf):
        return _infomap.InfomapConfigInfomapBase_setNonMainConfig(self, conf)

    def setNumTrials(self, N):
        return _infomap.InfomapConfigInfomapBase_setNumTrials(self, N)

    def setTwoLevel(self, value):
        return _infomap.InfomapConfigInfomapBase_setTwoLevel(self, value)

    def setTuneIterationLimit(self, value):
        return _infomap.InfomapConfigInfomapBase_setTuneIterationLimit(self, value)

    def setFastHierarchicalSolution(self, level):
        return _infomap.InfomapConfigInfomapBase_setFastHierarchicalSolution(self, level)

    def setOnlySuperModules(self, value):
        return _infomap.InfomapConfigInfomapBase_setOnlySuperModules(self, value)

    def setNoCoarseTune(self, value):
        return _infomap.InfomapConfigInfomapBase_setNoCoarseTune(self, value)

    def setMarkovTime(self, codeRate):
        return _infomap.InfomapConfigInfomapBase_setMarkovTime(self, codeRate)

    def reseed(self, seed):
        return _infomap.InfomapConfigInfomapBase_reseed(self, seed)
InfomapConfigInfomapBase_swigregister = _infomap.InfomapConfigInfomapBase_swigregister
InfomapConfigInfomapBase_swigregister(InfomapConfigInfomapBase)

class InfomapBase(InfomapConfigInfomapBase):
    __swig_setmethods__ = {}
    for _s in [InfomapConfigInfomapBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapBase, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapConfigInfomapBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _infomap.delete_InfomapBase
    __del__ = lambda self: None

    def network(self, *args):
        return _infomap.InfomapBase_network(self, *args)

    def root(self, *args):
        return _infomap.InfomapBase_root(self, *args)

    def iterTree(self, *args):
        return _infomap.InfomapBase_iterTree(self, *args)

    def iterTreePhysical(self, *args):
        return _infomap.InfomapBase_iterTreePhysical(self, *args)

    def iterModules(self, *args):
        return _infomap.InfomapBase_iterModules(self, *args)

    def iterLeafModules(self, *args):
        return _infomap.InfomapBase_iterLeafModules(self, *args)

    def iterLeafNodes(self, *args):
        return _infomap.InfomapBase_iterLeafNodes(self, *args)

    def iterLeafNodesPhysical(self, *args):
        return _infomap.InfomapBase_iterLeafNodesPhysical(self, *args)

    def begin(self, *args):
        return _infomap.InfomapBase_begin(self, *args)

    def end(self):
        return _infomap.InfomapBase_end(self)

    def numLeafNodes(self):
        return _infomap.InfomapBase_numLeafNodes(self)

    def leafNodes(self):
        return _infomap.InfomapBase_leafNodes(self)

    def numTopModules(self):
        return _infomap.InfomapBase_numTopModules(self)

    def numActiveModules(self):
        return _infomap.InfomapBase_numActiveModules(self)

    def numNonTrivialTopModules(self):
        return _infomap.InfomapBase_numNonTrivialTopModules(self)

    def haveModules(self):
        return _infomap.InfomapBase_haveModules(self)

    def haveNonTrivialModules(self):
        return _infomap.InfomapBase_haveNonTrivialModules(self)

    def numLevels(self):
        return _infomap.InfomapBase_numLevels(self)

    def maxTreeDepth(self):
        return _infomap.InfomapBase_maxTreeDepth(self)

    def getCodelength(self):
        return _infomap.InfomapBase_getCodelength(self)

    def codelength(self):
        return _infomap.InfomapBase_codelength(self)

    def getIndexCodelength(self):
        return _infomap.InfomapBase_getIndexCodelength(self)

    def getModuleCodelength(self):
        return _infomap.InfomapBase_getModuleCodelength(self)

    def getHierarchicalCodelength(self):
        return _infomap.InfomapBase_getHierarchicalCodelength(self)

    def getOneLevelCodelength(self):
        return _infomap.InfomapBase_getOneLevelCodelength(self)

    def isFullNetwork(self):
        return _infomap.InfomapBase_isFullNetwork(self)

    def isFirstLoop(self):
        return _infomap.InfomapBase_isFirstLoop(self)

    def getNewInfomapInstance(self):
        return _infomap.InfomapBase_getNewInfomapInstance(self)

    def getNewInfomapInstanceWithoutMemory(self):
        return _infomap.InfomapBase_getNewInfomapInstanceWithoutMemory(self)

    def getSubInfomap(self, node):
        return _infomap.InfomapBase_getSubInfomap(self, node)

    def getSuperInfomap(self, node):
        return _infomap.InfomapBase_getSuperInfomap(self, node)

    def setIsMain(self, isMain):
        return _infomap.InfomapBase_setIsMain(self, isMain)

    def setSubLevel(self, level):
        return _infomap.InfomapBase_setSubLevel(self, level)

    def isTopLevel(self):
        return _infomap.InfomapBase_isTopLevel(self)

    def isSuperLevelOnTopLevel(self):
        return _infomap.InfomapBase_isSuperLevelOnTopLevel(self)

    def isMainInfomap(self):
        return _infomap.InfomapBase_isMainInfomap(self)

    def haveMemory(self):
        return _infomap.InfomapBase_haveMemory(self)

    def haveHardPartition(self):
        return _infomap.InfomapBase_haveHardPartition(self)

    def activeNetwork(self):
        return _infomap.InfomapBase_activeNetwork(self)

    def toString(self, out):
        return _infomap.InfomapBase_toString(self, out)

    def run(self, *args):
        return _infomap.InfomapBase_run(self, *args)

    def generateSubNetwork(self, *args):
        return _infomap.InfomapBase_generateSubNetwork(self, *args)

    def init(self):
        return _infomap.InfomapBase_init(self)

    def runPartition(self):
        return _infomap.InfomapBase_runPartition(self)

    def restoreHardPartition(self):
        return _infomap.InfomapBase_restoreHardPartition(self)

    def writeResult(self):
        return _infomap.InfomapBase_writeResult(self)

    def hierarchicalPartition(self):
        return _infomap.InfomapBase_hierarchicalPartition(self)

    def partition(self):
        return _infomap.InfomapBase_partition(self)

    def initEnterExitFlow(self):
        return _infomap.InfomapBase_initEnterExitFlow(self)

    def initNetwork(self, *args):
        return _infomap.InfomapBase_initNetwork(self, *args)

    def initSuperNetwork(self):
        return _infomap.InfomapBase_initSuperNetwork(self)

    def calcCodelength(self, parent):
        return _infomap.InfomapBase_calcCodelength(self, parent)

    def calcCodelengthOnTree(self, includeRoot=True):
        return _infomap.InfomapBase_calcCodelengthOnTree(self, includeRoot)

    def setActiveNetworkFromLeafs(self):
        return _infomap.InfomapBase_setActiveNetworkFromLeafs(self)

    def setActiveNetworkFromChildrenOfRoot(self):
        return _infomap.InfomapBase_setActiveNetworkFromChildrenOfRoot(self)

    def initPartition(self, *args):
        return _infomap.InfomapBase_initPartition(self, *args)

    def findTopModulesRepeatedly(self, maxLevels):
        return _infomap.InfomapBase_findTopModulesRepeatedly(self, maxLevels)

    def fineTune(self):
        return _infomap.InfomapBase_fineTune(self)

    def coarseTune(self):
        return _infomap.InfomapBase_coarseTune(self)

    def optimizeActiveNetwork(self):
        return _infomap.InfomapBase_optimizeActiveNetwork(self)

    def moveActiveNodesToPredifinedModules(self, modules):
        return _infomap.InfomapBase_moveActiveNodesToPredifinedModules(self, modules)

    def consolidateModules(self, replaceExistingModules=True):
        return _infomap.InfomapBase_consolidateModules(self, replaceExistingModules)

    def calculateNumNonTrivialTopModules(self):
        return _infomap.InfomapBase_calculateNumNonTrivialTopModules(self)

    def calculateMaxDepth(self):
        return _infomap.InfomapBase_calculateMaxDepth(self)

    def restoreConsolidatedOptimizationPointIfNoImprovement(self, forceRestore=False):
        return _infomap.InfomapBase_restoreConsolidatedOptimizationPointIfNoImprovement(self, forceRestore)

    def findHierarchicalSuperModules(self, *args):
        return _infomap.InfomapBase_findHierarchicalSuperModules(self, *args)

    def findHierarchicalSuperModulesFast(self, *args):
        return _infomap.InfomapBase_findHierarchicalSuperModulesFast(self, *args)

    def transformNodeFlowToEnterFlow(self, parent):
        return _infomap.InfomapBase_transformNodeFlowToEnterFlow(self, parent)

    def resetFlowOnModules(self):
        return _infomap.InfomapBase_resetFlowOnModules(self)

    def removeModules(self):
        return _infomap.InfomapBase_removeModules(self)

    def removeSubModules(self, recalculateCodelengthOnTree):
        return _infomap.InfomapBase_removeSubModules(self, recalculateCodelengthOnTree)

    def recursivePartition(self):
        return _infomap.InfomapBase_recursivePartition(self)

    def queueTopModules(self, partitionQueue):
        return _infomap.InfomapBase_queueTopModules(self, partitionQueue)

    def queueLeafModules(self, partitionQueue):
        return _infomap.InfomapBase_queueLeafModules(self, partitionQueue)

    def processPartitionQueue(self, queue, nextLevel):
        return _infomap.InfomapBase_processPartitionQueue(self, queue, nextLevel)

    def writeTree(self, *args):
        return _infomap.InfomapBase_writeTree(self, *args)

    def writeFlowTree(self, *args):
        return _infomap.InfomapBase_writeFlowTree(self, *args)

    def writeClu(self, *args):
        return _infomap.InfomapBase_writeClu(self, *args)

    def writeMap(self, *args):
        return _infomap.InfomapBase_writeMap(self, *args)

    def printPerLevelCodelength(self, out):
        return _infomap.InfomapBase_printPerLevelCodelength(self, out)

    def aggregatePerLevelCodelength(self, *args):
        return _infomap.InfomapBase_aggregatePerLevelCodelength(self, *args)

    def printDebug(self):
        return _infomap.InfomapBase_printDebug(self)

    def printRSS(self, minVerboseLevel=0):
        return _infomap.InfomapBase_printRSS(self, minVerboseLevel)
InfomapBase_swigregister = _infomap.InfomapBase_swigregister
InfomapBase_swigregister(InfomapBase)

class PerLevelStat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PerLevelStat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PerLevelStat, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _infomap.new_PerLevelStat()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def codelength(self):
        return _infomap.PerLevelStat_codelength(self)

    def numNodes(self):
        return _infomap.PerLevelStat_numNodes(self)
    __swig_setmethods__["numModules"] = _infomap.PerLevelStat_numModules_set
    __swig_getmethods__["numModules"] = _infomap.PerLevelStat_numModules_get
    if _newclass:
        numModules = _swig_property(_infomap.PerLevelStat_numModules_get, _infomap.PerLevelStat_numModules_set)
    __swig_setmethods__["numLeafNodes"] = _infomap.PerLevelStat_numLeafNodes_set
    __swig_getmethods__["numLeafNodes"] = _infomap.PerLevelStat_numLeafNodes_get
    if _newclass:
        numLeafNodes = _swig_property(_infomap.PerLevelStat_numLeafNodes_get, _infomap.PerLevelStat_numLeafNodes_set)
    __swig_setmethods__["indexLength"] = _infomap.PerLevelStat_indexLength_set
    __swig_getmethods__["indexLength"] = _infomap.PerLevelStat_indexLength_get
    if _newclass:
        indexLength = _swig_property(_infomap.PerLevelStat_indexLength_get, _infomap.PerLevelStat_indexLength_set)
    __swig_setmethods__["leafLength"] = _infomap.PerLevelStat_leafLength_set
    __swig_getmethods__["leafLength"] = _infomap.PerLevelStat_leafLength_get
    if _newclass:
        leafLength = _swig_property(_infomap.PerLevelStat_leafLength_get, _infomap.PerLevelStat_leafLength_set)
    __swig_destroy__ = _infomap.delete_PerLevelStat
    __del__ = lambda self: None
PerLevelStat_swigregister = _infomap.PerLevelStat_swigregister
PerLevelStat_swigregister(PerLevelStat)

class PerIterationStats(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PerIterationStats, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PerIterationStats, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _infomap.new_PerIterationStats()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["iterationIndex"] = _infomap.PerIterationStats_iterationIndex_set
    __swig_getmethods__["iterationIndex"] = _infomap.PerIterationStats_iterationIndex_get
    if _newclass:
        iterationIndex = _swig_property(_infomap.PerIterationStats_iterationIndex_get, _infomap.PerIterationStats_iterationIndex_set)
    __swig_setmethods__["numTopModules"] = _infomap.PerIterationStats_numTopModules_set
    __swig_getmethods__["numTopModules"] = _infomap.PerIterationStats_numTopModules_get
    if _newclass:
        numTopModules = _swig_property(_infomap.PerIterationStats_numTopModules_get, _infomap.PerIterationStats_numTopModules_set)
    __swig_setmethods__["numBottomModules"] = _infomap.PerIterationStats_numBottomModules_set
    __swig_getmethods__["numBottomModules"] = _infomap.PerIterationStats_numBottomModules_get
    if _newclass:
        numBottomModules = _swig_property(_infomap.PerIterationStats_numBottomModules_get, _infomap.PerIterationStats_numBottomModules_set)
    __swig_setmethods__["topPerplexity"] = _infomap.PerIterationStats_topPerplexity_set
    __swig_getmethods__["topPerplexity"] = _infomap.PerIterationStats_topPerplexity_get
    if _newclass:
        topPerplexity = _swig_property(_infomap.PerIterationStats_topPerplexity_get, _infomap.PerIterationStats_topPerplexity_set)
    __swig_setmethods__["bottomPerplexity"] = _infomap.PerIterationStats_bottomPerplexity_set
    __swig_getmethods__["bottomPerplexity"] = _infomap.PerIterationStats_bottomPerplexity_get
    if _newclass:
        bottomPerplexity = _swig_property(_infomap.PerIterationStats_bottomPerplexity_get, _infomap.PerIterationStats_bottomPerplexity_set)
    __swig_setmethods__["topOverlap"] = _infomap.PerIterationStats_topOverlap_set
    __swig_getmethods__["topOverlap"] = _infomap.PerIterationStats_topOverlap_get
    if _newclass:
        topOverlap = _swig_property(_infomap.PerIterationStats_topOverlap_get, _infomap.PerIterationStats_topOverlap_set)
    __swig_setmethods__["bottomOverlap"] = _infomap.PerIterationStats_bottomOverlap_set
    __swig_getmethods__["bottomOverlap"] = _infomap.PerIterationStats_bottomOverlap_get
    if _newclass:
        bottomOverlap = _swig_property(_infomap.PerIterationStats_bottomOverlap_get, _infomap.PerIterationStats_bottomOverlap_set)
    __swig_setmethods__["codelength"] = _infomap.PerIterationStats_codelength_set
    __swig_getmethods__["codelength"] = _infomap.PerIterationStats_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.PerIterationStats_codelength_get, _infomap.PerIterationStats_codelength_set)
    __swig_setmethods__["maxDepth"] = _infomap.PerIterationStats_maxDepth_set
    __swig_getmethods__["maxDepth"] = _infomap.PerIterationStats_maxDepth_get
    if _newclass:
        maxDepth = _swig_property(_infomap.PerIterationStats_maxDepth_get, _infomap.PerIterationStats_maxDepth_set)
    __swig_setmethods__["weightedDepth"] = _infomap.PerIterationStats_weightedDepth_set
    __swig_getmethods__["weightedDepth"] = _infomap.PerIterationStats_weightedDepth_get
    if _newclass:
        weightedDepth = _swig_property(_infomap.PerIterationStats_weightedDepth_get, _infomap.PerIterationStats_weightedDepth_set)
    __swig_setmethods__["seconds"] = _infomap.PerIterationStats_seconds_set
    __swig_getmethods__["seconds"] = _infomap.PerIterationStats_seconds_get
    if _newclass:
        seconds = _swig_property(_infomap.PerIterationStats_seconds_get, _infomap.PerIterationStats_seconds_set)
    __swig_setmethods__["isMinimum"] = _infomap.PerIterationStats_isMinimum_set
    __swig_getmethods__["isMinimum"] = _infomap.PerIterationStats_isMinimum_get
    if _newclass:
        isMinimum = _swig_property(_infomap.PerIterationStats_isMinimum_get, _infomap.PerIterationStats_isMinimum_set)
    __swig_destroy__ = _infomap.delete_PerIterationStats
    __del__ = lambda self: None
PerIterationStats_swigregister = _infomap.PerIterationStats_swigregister
PerIterationStats_swigregister(PerIterationStats)

class MapEquation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapEquation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapEquation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_MapEquation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_MapEquation
    __del__ = lambda self: None
    if _newclass:
        haveMemory = staticmethod(_infomap.MapEquation_haveMemory)
    else:
        haveMemory = _infomap.MapEquation_haveMemory

    def _print(self, arg2):
        return _infomap.MapEquation__print(self, arg2)

    def initNetwork(self, root):
        return _infomap.MapEquation_initNetwork(self, root)

    def initSuperNetwork(self, root):
        return _infomap.MapEquation_initSuperNetwork(self, root)

    def initSubNetwork(self, root):
        return _infomap.MapEquation_initSubNetwork(self, root)

    def initPartition(self, nodes):
        return _infomap.MapEquation_initPartition(self, nodes)

    def calcCodelength(self, parent):
        return _infomap.MapEquation_calcCodelength(self, parent)

    def addMemoryContributions(self, *args):
        return _infomap.MapEquation_addMemoryContributions(self, *args)

    def getDeltaCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData):
        return _infomap.MapEquation_getDeltaCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData)

    def updateCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData):
        return _infomap.MapEquation_updateCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData)

    def consolidateModules(self, modules):
        return _infomap.MapEquation_consolidateModules(self, modules)

    def printDebug(self):
        return _infomap.MapEquation_printDebug(self)
    __swig_setmethods__["codelength"] = _infomap.MapEquation_codelength_set
    __swig_getmethods__["codelength"] = _infomap.MapEquation_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.MapEquation_codelength_get, _infomap.MapEquation_codelength_set)
    __swig_setmethods__["indexCodelength"] = _infomap.MapEquation_indexCodelength_set
    __swig_getmethods__["indexCodelength"] = _infomap.MapEquation_indexCodelength_get
    if _newclass:
        indexCodelength = _swig_property(_infomap.MapEquation_indexCodelength_get, _infomap.MapEquation_indexCodelength_set)
    __swig_setmethods__["moduleCodelength"] = _infomap.MapEquation_moduleCodelength_set
    __swig_getmethods__["moduleCodelength"] = _infomap.MapEquation_moduleCodelength_get
    if _newclass:
        moduleCodelength = _swig_property(_infomap.MapEquation_moduleCodelength_get, _infomap.MapEquation_moduleCodelength_set)
MapEquation_swigregister = _infomap.MapEquation_swigregister
MapEquation_swigregister(MapEquation)

def MapEquation_haveMemory():
    return _infomap.MapEquation_haveMemory()
MapEquation_haveMemory = _infomap.MapEquation_haveMemory

class MemMapEquation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MemMapEquation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MemMapEquation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_MemMapEquation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_MemMapEquation
    __del__ = lambda self: None
    if _newclass:
        haveMemory = staticmethod(_infomap.MemMapEquation_haveMemory)
    else:
        haveMemory = _infomap.MemMapEquation_haveMemory

    def _print(self, out):
        return _infomap.MemMapEquation__print(self, out)

    def initNetwork(self, root):
        return _infomap.MemMapEquation_initNetwork(self, root)

    def initSuperNetwork(self, root):
        return _infomap.MemMapEquation_initSuperNetwork(self, root)

    def initSubNetwork(self, root):
        return _infomap.MemMapEquation_initSubNetwork(self, root)

    def initPartition(self, nodes):
        return _infomap.MemMapEquation_initPartition(self, nodes)

    def calcCodelength(self, parent):
        return _infomap.MemMapEquation_calcCodelength(self, parent)

    def addMemoryContributions(self, current, oldModuleDelta, moduleDeltaFlow):
        return _infomap.MemMapEquation_addMemoryContributions(self, current, oldModuleDelta, moduleDeltaFlow)

    def getDeltaCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData):
        return _infomap.MemMapEquation_getDeltaCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData)

    def updateCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData):
        return _infomap.MemMapEquation_updateCodelengthOnMovingNode(self, current, oldModuleDelta, newModuleDelta, moduleFlowData)

    def consolidateModules(self, modules):
        return _infomap.MemMapEquation_consolidateModules(self, modules)

    def printDebug(self):
        return _infomap.MemMapEquation_printDebug(self)
    __swig_setmethods__["codelength"] = _infomap.MemMapEquation_codelength_set
    __swig_getmethods__["codelength"] = _infomap.MemMapEquation_codelength_get
    if _newclass:
        codelength = _swig_property(_infomap.MemMapEquation_codelength_get, _infomap.MemMapEquation_codelength_set)
    __swig_setmethods__["indexCodelength"] = _infomap.MemMapEquation_indexCodelength_set
    __swig_getmethods__["indexCodelength"] = _infomap.MemMapEquation_indexCodelength_get
    if _newclass:
        indexCodelength = _swig_property(_infomap.MemMapEquation_indexCodelength_get, _infomap.MemMapEquation_indexCodelength_set)
    __swig_setmethods__["moduleCodelength"] = _infomap.MemMapEquation_moduleCodelength_set
    __swig_getmethods__["moduleCodelength"] = _infomap.MemMapEquation_moduleCodelength_get
    if _newclass:
        moduleCodelength = _swig_property(_infomap.MemMapEquation_moduleCodelength_get, _infomap.MemMapEquation_moduleCodelength_set)
MemMapEquation_swigregister = _infomap.MemMapEquation_swigregister
MemMapEquation_swigregister(MemMapEquation)

def MemMapEquation_haveMemory():
    return _infomap.MemMapEquation_haveMemory()
MemMapEquation_haveMemory = _infomap.MemMapEquation_haveMemory

class MemNodeSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MemNodeSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MemNodeSet, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_MemNodeSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["numMemNodes"] = _infomap.MemNodeSet_numMemNodes_set
    __swig_getmethods__["numMemNodes"] = _infomap.MemNodeSet_numMemNodes_get
    if _newclass:
        numMemNodes = _swig_property(_infomap.MemNodeSet_numMemNodes_get, _infomap.MemNodeSet_numMemNodes_set)
    __swig_setmethods__["sumFlow"] = _infomap.MemNodeSet_sumFlow_set
    __swig_getmethods__["sumFlow"] = _infomap.MemNodeSet_sumFlow_get
    if _newclass:
        sumFlow = _swig_property(_infomap.MemNodeSet_sumFlow_get, _infomap.MemNodeSet_sumFlow_set)
    __swig_destroy__ = _infomap.delete_MemNodeSet
    __del__ = lambda self: None
MemNodeSet_swigregister = _infomap.MemNodeSet_swigregister
MemNodeSet_swigregister(MemNodeSet)

class InfomapCore(InfomapBase):
    __swig_setmethods__ = {}
    for _s in [InfomapBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfomapCore, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfomapCore, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_InfomapCore(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_InfomapCore
    __del__ = lambda self: None

    def toString(self, out):
        return _infomap.InfomapCore_toString(self, out)

    def getCodelength(self):
        return _infomap.InfomapCore_getCodelength(self)

    def getIndexCodelength(self):
        return _infomap.InfomapCore_getIndexCodelength(self)

    def getModuleCodelength(self):
        return _infomap.InfomapCore_getModuleCodelength(self)
InfomapCore_swigregister = _infomap.InfomapCore_swigregister
InfomapCore_swigregister(InfomapCore)

class map_uint_uint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, map_uint_uint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, map_uint_uint, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.map_uint_uint_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.map_uint_uint___nonzero__(self)

    def __bool__(self):
        return _infomap.map_uint_uint___bool__(self)

    def __len__(self):
        return _infomap.map_uint_uint___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _infomap.map_uint_uint___getitem__(self, key)

    def __delitem__(self, key):
        return _infomap.map_uint_uint___delitem__(self, key)

    def has_key(self, key):
        return _infomap.map_uint_uint_has_key(self, key)

    def keys(self):
        return _infomap.map_uint_uint_keys(self)

    def values(self):
        return _infomap.map_uint_uint_values(self)

    def items(self):
        return _infomap.map_uint_uint_items(self)

    def __contains__(self, key):
        return _infomap.map_uint_uint___contains__(self, key)

    def key_iterator(self):
        return _infomap.map_uint_uint_key_iterator(self)

    def value_iterator(self):
        return _infomap.map_uint_uint_value_iterator(self)

    def __setitem__(self, *args):
        return _infomap.map_uint_uint___setitem__(self, *args)

    def asdict(self):
        return _infomap.map_uint_uint_asdict(self)

    def __init__(self, *args):
        this = _infomap.new_map_uint_uint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _infomap.map_uint_uint_empty(self)

    def size(self):
        return _infomap.map_uint_uint_size(self)

    def swap(self, v):
        return _infomap.map_uint_uint_swap(self, v)

    def begin(self):
        return _infomap.map_uint_uint_begin(self)

    def end(self):
        return _infomap.map_uint_uint_end(self)

    def rbegin(self):
        return _infomap.map_uint_uint_rbegin(self)

    def rend(self):
        return _infomap.map_uint_uint_rend(self)

    def clear(self):
        return _infomap.map_uint_uint_clear(self)

    def get_allocator(self):
        return _infomap.map_uint_uint_get_allocator(self)

    def count(self, x):
        return _infomap.map_uint_uint_count(self, x)

    def erase(self, *args):
        return _infomap.map_uint_uint_erase(self, *args)

    def find(self, x):
        return _infomap.map_uint_uint_find(self, x)

    def lower_bound(self, x):
        return _infomap.map_uint_uint_lower_bound(self, x)

    def upper_bound(self, x):
        return _infomap.map_uint_uint_upper_bound(self, x)
    __swig_destroy__ = _infomap.delete_map_uint_uint
    __del__ = lambda self: None
map_uint_uint_swigregister = _infomap.map_uint_uint_swigregister
map_uint_uint_swigregister(map_uint_uint)

class map_uint_vector_uint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, map_uint_vector_uint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, map_uint_vector_uint, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _infomap.map_uint_vector_uint_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _infomap.map_uint_vector_uint___nonzero__(self)

    def __bool__(self):
        return _infomap.map_uint_vector_uint___bool__(self)

    def __len__(self):
        return _infomap.map_uint_vector_uint___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _infomap.map_uint_vector_uint___getitem__(self, key)

    def __delitem__(self, key):
        return _infomap.map_uint_vector_uint___delitem__(self, key)

    def has_key(self, key):
        return _infomap.map_uint_vector_uint_has_key(self, key)

    def keys(self):
        return _infomap.map_uint_vector_uint_keys(self)

    def values(self):
        return _infomap.map_uint_vector_uint_values(self)

    def items(self):
        return _infomap.map_uint_vector_uint_items(self)

    def __contains__(self, key):
        return _infomap.map_uint_vector_uint___contains__(self, key)

    def key_iterator(self):
        return _infomap.map_uint_vector_uint_key_iterator(self)

    def value_iterator(self):
        return _infomap.map_uint_vector_uint_value_iterator(self)

    def __setitem__(self, *args):
        return _infomap.map_uint_vector_uint___setitem__(self, *args)

    def asdict(self):
        return _infomap.map_uint_vector_uint_asdict(self)

    def __init__(self, *args):
        this = _infomap.new_map_uint_vector_uint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _infomap.map_uint_vector_uint_empty(self)

    def size(self):
        return _infomap.map_uint_vector_uint_size(self)

    def swap(self, v):
        return _infomap.map_uint_vector_uint_swap(self, v)

    def begin(self):
        return _infomap.map_uint_vector_uint_begin(self)

    def end(self):
        return _infomap.map_uint_vector_uint_end(self)

    def rbegin(self):
        return _infomap.map_uint_vector_uint_rbegin(self)

    def rend(self):
        return _infomap.map_uint_vector_uint_rend(self)

    def clear(self):
        return _infomap.map_uint_vector_uint_clear(self)

    def get_allocator(self):
        return _infomap.map_uint_vector_uint_get_allocator(self)

    def count(self, x):
        return _infomap.map_uint_vector_uint_count(self, x)

    def erase(self, *args):
        return _infomap.map_uint_vector_uint_erase(self, *args)

    def find(self, x):
        return _infomap.map_uint_vector_uint_find(self, x)

    def lower_bound(self, x):
        return _infomap.map_uint_vector_uint_lower_bound(self, x)

    def upper_bound(self, x):
        return _infomap.map_uint_vector_uint_upper_bound(self, x)
    __swig_destroy__ = _infomap.delete_map_uint_vector_uint
    __del__ = lambda self: None
map_uint_vector_uint_swigregister = _infomap.map_uint_vector_uint_swigregister
map_uint_vector_uint_swigregister(map_uint_vector_uint)

class Infomap(InfomapCore):
    __swig_setmethods__ = {}
    for _s in [InfomapCore]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Infomap, name, value)
    __swig_getmethods__ = {}
    for _s in [InfomapCore]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Infomap, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _infomap.new_Infomap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _infomap.delete_Infomap
    __del__ = lambda self: None

    def addNode(self, *args):
        return _infomap.Infomap_addNode(self, *args)

    def addName(self, id, name):
        return _infomap.Infomap_addName(self, id, name)

    def addPhysicalNode(self, *args):
        return _infomap.Infomap_addPhysicalNode(self, *args)

    def addStateNode(self, id, physId):
        return _infomap.Infomap_addStateNode(self, id, physId)

    def addLink(self, sourceId, targetId, weight=1.0):
        return _infomap.Infomap_addLink(self, sourceId, targetId, weight)

    def addMultilayerLink(self, layer1, n1, layer2, n2, weight=1.0):
        return _infomap.Infomap_addMultilayerLink(self, layer1, n1, layer2, n2, weight)

    def addPath(self, nodes, markovOrder, weight=1.0):
        return _infomap.Infomap_addPath(self, nodes, markovOrder, weight)

    def getModules(self, level=1, states=False):
        return _infomap.Infomap_getModules(self, level, states)

    def getMultilevelModules(self, states=False):
        return _infomap.Infomap_getMultilevelModules(self, states)
Infomap_swigregister = _infomap.Infomap_swigregister
Infomap_swigregister(Infomap)

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



def main():
  import sys
  import infomap as im
  args = " ".join(sys.argv[1:])
  infomap = im.Infomap(im.Config(args, True))
  infomap.run()

if __name__ == '__main__':
  main()
