statistics/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.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
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_statistics', [dirname(__file__)])
        except ImportError:
            import _IMP_statistics
            return _IMP_statistics
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_statistics', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_statistics = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_statistics
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


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

    def incr(self, n=1):
        """
        incr(IMP_STATISTICS_SwigPyIterator self, size_t n=1) -> IMP_STATISTICS_SwigPyIterator
        incr(IMP_STATISTICS_SwigPyIterator self) -> IMP_STATISTICS_SwigPyIterator
        """
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_STATISTICS_SwigPyIterator self, size_t n=1) -> IMP_STATISTICS_SwigPyIterator
        decr(IMP_STATISTICS_SwigPyIterator self) -> IMP_STATISTICS_SwigPyIterator
        """
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> bool"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_STATISTICS_SwigPyIterator self) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_STATISTICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_STATISTICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_STATISTICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> bool"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> bool"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator
        __sub__(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_STATISTICS_SwigPyIterator_swigregister = _IMP_statistics.IMP_STATISTICS_SwigPyIterator_swigregister
IMP_STATISTICS_SwigPyIterator_swigregister(IMP_STATISTICS_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_DEBUG = _IMP_statistics.IMP_DEBUG
IMP_RELEASE = _IMP_statistics.IMP_RELEASE
IMP_SILENT = _IMP_statistics.IMP_SILENT
IMP_PROGRESS = _IMP_statistics.IMP_PROGRESS
IMP_TERSE = _IMP_statistics.IMP_TERSE
IMP_VERBOSE = _IMP_statistics.IMP_VERBOSE
IMP_MEMORY = _IMP_statistics.IMP_MEMORY
IMP_NONE = _IMP_statistics.IMP_NONE
IMP_USAGE = _IMP_statistics.IMP_USAGE
IMP_INTERNAL = _IMP_statistics.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_statistics.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_statistics.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_statistics.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_statistics.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_statistics.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_statistics.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_statistics.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_statistics.IMPBASE_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_statistics.DEFAULT_CHECK
NONE = _IMP_statistics.NONE
USAGE = _IMP_statistics.USAGE
USAGE_AND_INTERNAL = _IMP_statistics.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_statistics.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_statistics.get_check_level()
class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_statistics._ostream_write(self, *args)

_ostream_swigregister = _IMP_statistics._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_statistics.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_statistics.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_statistics.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_statistics.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_statistics.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_statistics.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_statistics.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_statistics.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_statistics.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_STATISTICS_HAS_IMP_BASE = _IMP_statistics.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_CGAL
IMPSTATISTICS_SHOW_WARNINGS = _IMP_statistics.IMPSTATISTICS_SHOW_WARNINGS
Histogram1Ds=list
_plural_types.append("Histogram1Ds")
_value_types.append("Histogram1D")

Histogram2Ds=list
_plural_types.append("Histogram2Ds")
_value_types.append("Histogram2D")

Histogram3Ds=list
_plural_types.append("Histogram3Ds")
_value_types.append("Histogram3D")

Histogram4Ds=list
_plural_types.append("Histogram4Ds")
_value_types.append("Histogram4D")

Histogram5Ds=list
_plural_types.append("Histogram5Ds")
_value_types.append("Histogram5D")

Histogram6Ds=list
_plural_types.append("Histogram6Ds")
_value_types.append("Histogram6D")

Histogram1Ds=list
_plural_types.append("Histogram1Ds")
_value_types.append("HistogramD<1>")

Histogram2Ds=list
_plural_types.append("Histogram2Ds")
_value_types.append("HistogramD<2>")

Histogram3Ds=list
_plural_types.append("Histogram3Ds")
_value_types.append("HistogramD<3>")

Histogram4Ds=list
_plural_types.append("Histogram4Ds")
_value_types.append("HistogramD<4>")

Histogram5Ds=list
_plural_types.append("Histogram5Ds")
_value_types.append("HistogramD<5>")

Histogram6Ds=list
_plural_types.append("Histogram6Ds")
_value_types.append("HistogramD<6>")

HistogramKDs=list
_plural_types.append("HistogramKDs")
_value_types.append("HistogramKD")

HistogramKDs=list
_plural_types.append("HistogramKDs")
_value_types.append("HistogramD<-1>")

_object_types.append("PartitionalClustering")


def _object_cast_to_PartitionalClustering(*args):
  """_object_cast_to_PartitionalClustering(Object o) -> PartitionalClustering"""
  return _IMP_statistics._object_cast_to_PartitionalClustering(*args)
_object_types.append("PartitionalClusteringWithCenter")


def _object_cast_to_PartitionalClusteringWithCenter(*args):
  """_object_cast_to_PartitionalClusteringWithCenter(Object o) -> PartitionalClusteringWithCenter"""
  return _IMP_statistics._object_cast_to_PartitionalClusteringWithCenter(*args)
_object_types.append("Embedding")


def _object_cast_to_Embedding(*args):
  """_object_cast_to_Embedding(Object o) -> Embedding"""
  return _IMP_statistics._object_cast_to_Embedding(*args)
_object_types.append("ConfigurationSetXYZEmbedding")


def _object_cast_to_ConfigurationSetXYZEmbedding(*args):
  """_object_cast_to_ConfigurationSetXYZEmbedding(Object o) -> ConfigurationSetXYZEmbedding"""
  return _IMP_statistics._object_cast_to_ConfigurationSetXYZEmbedding(*args)
_object_types.append("VectorDEmbedding")


def _object_cast_to_VectorDEmbedding(*args):
  """_object_cast_to_VectorDEmbedding(Object o) -> VectorDEmbedding"""
  return _IMP_statistics._object_cast_to_VectorDEmbedding(*args)
_object_types.append("ParticleEmbedding")


def _object_cast_to_ParticleEmbedding(*args):
  """_object_cast_to_ParticleEmbedding(Object o) -> ParticleEmbedding"""
  return _IMP_statistics._object_cast_to_ParticleEmbedding(*args)
_object_types.append("Metric")


def _object_cast_to_Metric(*args):
  """_object_cast_to_Metric(Object o) -> Metric"""
  return _IMP_statistics._object_cast_to_Metric(*args)
_object_types.append("EuclideanMetric")


def _object_cast_to_EuclideanMetric(*args):
  """_object_cast_to_EuclideanMetric(Object o) -> EuclideanMetric"""
  return _IMP_statistics._object_cast_to_EuclideanMetric(*args)
_object_types.append("ConfigurationSetRMSDMetric")


def _object_cast_to_ConfigurationSetRMSDMetric(*args):
  """_object_cast_to_ConfigurationSetRMSDMetric(Object o) -> ConfigurationSetRMSDMetric"""
  return _IMP_statistics._object_cast_to_ConfigurationSetRMSDMetric(*args)
_object_types.append("RecursivePartitionalClusteringMetric")


def _object_cast_to_RecursivePartitionalClusteringMetric(*args):
  """_object_cast_to_RecursivePartitionalClusteringMetric(Object o) -> RecursivePartitionalClusteringMetric"""
  return _IMP_statistics._object_cast_to_RecursivePartitionalClusteringMetric(*args)
_object_types.append("RecursivePartitionalClusteringEmbedding")


def _object_cast_to_RecursivePartitionalClusteringEmbedding(*args):
  """_object_cast_to_RecursivePartitionalClusteringEmbedding(Object o) -> RecursivePartitionalClusteringEmbedding"""
  return _IMP_statistics._object_cast_to_RecursivePartitionalClusteringEmbedding(*args)
_object_types.append("ChiSquareMetric")


def _object_cast_to_ChiSquareMetric(*args):
  """_object_cast_to_ChiSquareMetric(Object o) -> ChiSquareMetric"""
  return _IMP_statistics._object_cast_to_ChiSquareMetric(*args)
class PartitionalClustering(IMP.base.Object):
    """Proxy of C++ IMP::statistics::PartitionalClustering class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PartitionalClustering, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PartitionalClustering, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def get_number_of_clusters(self):
        """get_number_of_clusters(PartitionalClustering self) -> unsigned int"""
        return _IMP_statistics.PartitionalClustering_get_number_of_clusters(self)

    def get_cluster(self, *args):
        """get_cluster(PartitionalClustering self, unsigned int cluster_index) -> IMP::Ints const &"""
        return _IMP_statistics.PartitionalClustering_get_cluster(self, *args)

    def get_cluster_representative(self, *args):
        """get_cluster_representative(PartitionalClustering self, unsigned int cluster_index) -> int"""
        return _IMP_statistics.PartitionalClustering_get_cluster_representative(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_PartitionalClustering
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PartitionalClustering self) -> std::string"""
        return _IMP_statistics.PartitionalClustering___str__(self)

    def __repr__(self):
        """__repr__(PartitionalClustering self) -> std::string"""
        return _IMP_statistics.PartitionalClustering___repr__(self)

    def get_from(o):
       return _object_cast_to_PartitionalClustering(o)
    get_from = staticmethod(get_from)

PartitionalClustering_swigregister = _IMP_statistics.PartitionalClustering_swigregister
PartitionalClustering_swigregister(PartitionalClustering)


def validate_partitional_clustering(*args):
  """validate_partitional_clustering(PartitionalClustering pc, unsigned int n)"""
  return _IMP_statistics.validate_partitional_clustering(*args)
class Embedding(IMP.base.Object):
    """Proxy of C++ IMP::statistics::Embedding class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Embedding, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Embedding, name)
    def __init__(self, *args): 
        """__init__(IMP::statistics::Embedding self, std::string name) -> Embedding"""
        if self.__class__ == Embedding:
            _self = None
        else:
            _self = self
        this = _IMP_statistics.new_Embedding(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Embedding:
            import IMP.base
            IMP.base._director_objects.register(self)



    def do_get_weight(self, *args):
        """do_get_weight(Embedding self, unsigned int i) -> double"""
        return _IMP_statistics.Embedding_do_get_weight(self, *args)

    def get_point(self, *args):
        """get_point(Embedding self, unsigned int i) -> VectorKD"""
        return _IMP_statistics.Embedding_get_point(self, *args)

    def get_number_of_items(self):
        """get_number_of_items(Embedding self) -> unsigned int"""
        return _IMP_statistics.Embedding_get_number_of_items(self)

    def get_weight(self, *args):
        """get_weight(Embedding self, unsigned int i) -> double"""
        return _IMP_statistics.Embedding_get_weight(self, *args)

    def get_points(self):
        """get_points(Embedding self) -> IMP::algebra::VectorKDs"""
        return _IMP_statistics.Embedding_get_points(self)

    def __str__(self):
        """__str__(Embedding self) -> std::string"""
        return _IMP_statistics.Embedding___str__(self)

    def __repr__(self):
        """__repr__(Embedding self) -> std::string"""
        return _IMP_statistics.Embedding___repr__(self)

    def get_from(o):
       return _object_cast_to_Embedding(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::statistics" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Embedding(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_statistics.delete_Embedding
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_statistics.disown_Embedding(self)
        return weakref_proxy(self)
Embedding_swigregister = _IMP_statistics.Embedding_swigregister
Embedding_swigregister(Embedding)

class Metric(IMP.base.Object):
    """Proxy of C++ IMP::statistics::Metric class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Metric, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Metric, name)
    def __init__(self, *args): 
        """__init__(IMP::statistics::Metric self, std::string name) -> Metric"""
        if self.__class__ == Metric:
            _self = None
        else:
            _self = self
        this = _IMP_statistics.new_Metric(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Metric:
            import IMP.base
            IMP.base._director_objects.register(self)



    def do_get_weight(self, *args):
        """do_get_weight(Metric self, unsigned int i) -> double"""
        return _IMP_statistics.Metric_do_get_weight(self, *args)

    def get_distance(self, *args):
        """get_distance(Metric self, unsigned int i, unsigned int j) -> double"""
        return _IMP_statistics.Metric_get_distance(self, *args)

    def get_weight(self, *args):
        """get_weight(Metric self, unsigned int i) -> double"""
        return _IMP_statistics.Metric_get_weight(self, *args)

    def get_number_of_items(self):
        """get_number_of_items(Metric self) -> unsigned int"""
        return _IMP_statistics.Metric_get_number_of_items(self)

    __swig_destroy__ = _IMP_statistics.delete_Metric
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Metric self) -> std::string"""
        return _IMP_statistics.Metric___str__(self)

    def __repr__(self):
        """__repr__(Metric self) -> std::string"""
        return _IMP_statistics.Metric___repr__(self)

    def get_from(o):
       return _object_cast_to_Metric(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::statistics" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Metric(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_statistics.disown_Metric(self)
        return weakref_proxy(self)
Metric_swigregister = _IMP_statistics.Metric_swigregister
Metric_swigregister(Metric)

class ChiSquareMetric(Metric):
    """Proxy of C++ IMP::statistics::ChiSquareMetric class"""
    __swig_setmethods__ = {}
    for _s in [Metric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiSquareMetric, name, value)
    __swig_getmethods__ = {}
    for _s in [Metric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChiSquareMetric, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::ChiSquareMetric self, IMP::Floats data_exp, int constr_type=0) -> ChiSquareMetric
        __init__(IMP::statistics::ChiSquareMetric self, IMP::Floats data_exp) -> ChiSquareMetric
        """
        this = _IMP_statistics.new_ChiSquareMetric(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_configuration(self, *args):
        """
        add_configuration(ChiSquareMetric self, IMP::Floats data, IMP::Floats stddev, double weight=1.0)
        add_configuration(ChiSquareMetric self, IMP::Floats data, IMP::Floats stddev)
        """
        return _IMP_statistics.ChiSquareMetric_add_configuration(self, *args)

    def get_data(self, *args):
        """get_data(ChiSquareMetric self, unsigned int i) -> IMP::Floats"""
        return _IMP_statistics.ChiSquareMetric_get_data(self, *args)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(ChiSquareMetric self, unsigned int i) -> IMP::Floats"""
        return _IMP_statistics.ChiSquareMetric_get_standard_deviation(self, *args)

    def do_get_weight(self, *args):
        """do_get_weight(ChiSquareMetric self, unsigned int i) -> double"""
        return _IMP_statistics.ChiSquareMetric_do_get_weight(self, *args)

    def get_chi_square_experimental(self, *args):
        """get_chi_square_experimental(ChiSquareMetric self, unsigned int i) -> double"""
        return _IMP_statistics.ChiSquareMetric_get_chi_square_experimental(self, *args)

    def get_version_info(self):
        """get_version_info(ChiSquareMetric self) -> VersionInfo"""
        return _IMP_statistics.ChiSquareMetric_get_version_info(self)

    def __str__(self):
        """__str__(ChiSquareMetric self) -> std::string"""
        return _IMP_statistics.ChiSquareMetric___str__(self)

    def __repr__(self):
        """__repr__(ChiSquareMetric self) -> std::string"""
        return _IMP_statistics.ChiSquareMetric___repr__(self)

    def get_from(o):
       return _object_cast_to_ChiSquareMetric(o)
    get_from = staticmethod(get_from)

ChiSquareMetric_swigregister = _IMP_statistics.ChiSquareMetric_swigregister
ChiSquareMetric_swigregister(ChiSquareMetric)

class PartitionalClusteringWithCenter(PartitionalClustering):
    """Proxy of C++ IMP::statistics::PartitionalClusteringWithCenter class"""
    __swig_setmethods__ = {}
    for _s in [PartitionalClustering]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PartitionalClusteringWithCenter, name, value)
    __swig_getmethods__ = {}
    for _s in [PartitionalClustering]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PartitionalClusteringWithCenter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    def get_cluster_center(self, *args):
        """get_cluster_center(PartitionalClusteringWithCenter self, unsigned int i) -> VectorKD"""
        return _IMP_statistics.PartitionalClusteringWithCenter_get_cluster_center(self, *args)

    def get_version_info(self):
        """get_version_info(PartitionalClusteringWithCenter self) -> VersionInfo"""
        return _IMP_statistics.PartitionalClusteringWithCenter_get_version_info(self)

    def __str__(self):
        """__str__(PartitionalClusteringWithCenter self) -> std::string"""
        return _IMP_statistics.PartitionalClusteringWithCenter___str__(self)

    def __repr__(self):
        """__repr__(PartitionalClusteringWithCenter self) -> std::string"""
        return _IMP_statistics.PartitionalClusteringWithCenter___repr__(self)

    def get_from(o):
       return _object_cast_to_PartitionalClusteringWithCenter(o)
    get_from = staticmethod(get_from)

PartitionalClusteringWithCenter_swigregister = _IMP_statistics.PartitionalClusteringWithCenter_swigregister
PartitionalClusteringWithCenter_swigregister(PartitionalClusteringWithCenter)

class ConfigurationSetXYZEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::ConfigurationSetXYZEmbedding class"""
    __swig_setmethods__ = {}
    for _s in [Embedding]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigurationSetXYZEmbedding, name, value)
    __swig_getmethods__ = {}
    for _s in [Embedding]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigurationSetXYZEmbedding, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::ConfigurationSetXYZEmbedding self, ConfigurationSet cs, _SingletonContainerAdaptor pi, bool align=False) -> ConfigurationSetXYZEmbedding
        __init__(IMP::statistics::ConfigurationSetXYZEmbedding self, ConfigurationSet cs, _SingletonContainerAdaptor pi) -> ConfigurationSetXYZEmbedding
        """
        this = _IMP_statistics.new_ConfigurationSetXYZEmbedding(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ConfigurationSetXYZEmbedding self) -> VersionInfo"""
        return _IMP_statistics.ConfigurationSetXYZEmbedding_get_version_info(self)

    def __str__(self):
        """__str__(ConfigurationSetXYZEmbedding self) -> std::string"""
        return _IMP_statistics.ConfigurationSetXYZEmbedding___str__(self)

    def __repr__(self):
        """__repr__(ConfigurationSetXYZEmbedding self) -> std::string"""
        return _IMP_statistics.ConfigurationSetXYZEmbedding___repr__(self)

    def get_from(o):
       return _object_cast_to_ConfigurationSetXYZEmbedding(o)
    get_from = staticmethod(get_from)

ConfigurationSetXYZEmbedding_swigregister = _IMP_statistics.ConfigurationSetXYZEmbedding_swigregister
ConfigurationSetXYZEmbedding_swigregister(ConfigurationSetXYZEmbedding)

class ParticleEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::ParticleEmbedding class"""
    __swig_setmethods__ = {}
    for _s in [Embedding]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleEmbedding, name, value)
    __swig_getmethods__ = {}
    for _s in [Embedding]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleEmbedding, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::ParticleEmbedding self, IMP::kernel::ParticlesTemp const & ps, IMP::kernel::FloatKeys const & ks=IMP::kernel::FloatKeys(
                                                                 IMP::kernel::internal::
                                                                     xyzr_keys,
                                                                 IMP::kernel::internal::
                                                                         xyzr_keys +
                                                                     3), 
            bool rescale=False) -> ParticleEmbedding
        __init__(IMP::statistics::ParticleEmbedding self, IMP::kernel::ParticlesTemp const & ps, IMP::kernel::FloatKeys const & ks=IMP::kernel::FloatKeys(
                                                                 IMP::kernel::internal::
                                                                     xyzr_keys,
                                                                 IMP::kernel::internal::
                                                                         xyzr_keys +
                                                                     3)) -> ParticleEmbedding
        __init__(IMP::statistics::ParticleEmbedding self, IMP::kernel::ParticlesTemp const & ps) -> ParticleEmbedding
        """
        this = _IMP_statistics.new_ParticleEmbedding(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ParticleEmbedding self) -> VersionInfo"""
        return _IMP_statistics.ParticleEmbedding_get_version_info(self)

    def __str__(self):
        """__str__(ParticleEmbedding self) -> std::string"""
        return _IMP_statistics.ParticleEmbedding___str__(self)

    def __repr__(self):
        """__repr__(ParticleEmbedding self) -> std::string"""
        return _IMP_statistics.ParticleEmbedding___repr__(self)

    def get_from(o):
       return _object_cast_to_ParticleEmbedding(o)
    get_from = staticmethod(get_from)

ParticleEmbedding_swigregister = _IMP_statistics.ParticleEmbedding_swigregister
ParticleEmbedding_swigregister(ParticleEmbedding)

class VectorDEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::VectorDEmbedding class"""
    __swig_setmethods__ = {}
    for _s in [Embedding]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorDEmbedding, name, value)
    __swig_getmethods__ = {}
    for _s in [Embedding]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VectorDEmbedding, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::VectorKDs const & vs) -> VectorDEmbedding
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::Vector2Ds const & vs) -> VectorDEmbedding
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::Vector3Ds const & vs) -> VectorDEmbedding
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::Vector4Ds const & vs) -> VectorDEmbedding
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::Vector5Ds const & vs) -> VectorDEmbedding
        __init__(IMP::statistics::VectorDEmbedding self, IMP::algebra::Vector6Ds const & vs) -> VectorDEmbedding
        """
        this = _IMP_statistics.new_VectorDEmbedding(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(VectorDEmbedding self) -> VersionInfo"""
        return _IMP_statistics.VectorDEmbedding_get_version_info(self)

    def __str__(self):
        """__str__(VectorDEmbedding self) -> std::string"""
        return _IMP_statistics.VectorDEmbedding___str__(self)

    def __repr__(self):
        """__repr__(VectorDEmbedding self) -> std::string"""
        return _IMP_statistics.VectorDEmbedding___repr__(self)

    def get_from(o):
       return _object_cast_to_VectorDEmbedding(o)
    get_from = staticmethod(get_from)

VectorDEmbedding_swigregister = _IMP_statistics.VectorDEmbedding_swigregister
VectorDEmbedding_swigregister(VectorDEmbedding)

class EuclideanMetric(Metric):
    """Proxy of C++ IMP::statistics::EuclideanMetric class"""
    __swig_setmethods__ = {}
    for _s in [Metric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EuclideanMetric, name, value)
    __swig_getmethods__ = {}
    for _s in [Metric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EuclideanMetric, name)
    def __init__(self, *args): 
        """__init__(IMP::statistics::EuclideanMetric self, Embedding em) -> EuclideanMetric"""
        this = _IMP_statistics.new_EuclideanMetric(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EuclideanMetric self) -> VersionInfo"""
        return _IMP_statistics.EuclideanMetric_get_version_info(self)

    def __str__(self):
        """__str__(EuclideanMetric self) -> std::string"""
        return _IMP_statistics.EuclideanMetric___str__(self)

    def __repr__(self):
        """__repr__(EuclideanMetric self) -> std::string"""
        return _IMP_statistics.EuclideanMetric___repr__(self)

    def get_from(o):
       return _object_cast_to_EuclideanMetric(o)
    get_from = staticmethod(get_from)

EuclideanMetric_swigregister = _IMP_statistics.EuclideanMetric_swigregister
EuclideanMetric_swigregister(EuclideanMetric)

class ConfigurationSetRMSDMetric(Metric):
    """Proxy of C++ IMP::statistics::ConfigurationSetRMSDMetric class"""
    __swig_setmethods__ = {}
    for _s in [Metric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigurationSetRMSDMetric, name, value)
    __swig_getmethods__ = {}
    for _s in [Metric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigurationSetRMSDMetric, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::ConfigurationSetRMSDMetric self, ConfigurationSet cs, SingletonContainer sc, bool align=False) -> ConfigurationSetRMSDMetric
        __init__(IMP::statistics::ConfigurationSetRMSDMetric self, ConfigurationSet cs, SingletonContainer sc) -> ConfigurationSetRMSDMetric
        """
        this = _IMP_statistics.new_ConfigurationSetRMSDMetric(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ConfigurationSetRMSDMetric self) -> VersionInfo"""
        return _IMP_statistics.ConfigurationSetRMSDMetric_get_version_info(self)

    def __str__(self):
        """__str__(ConfigurationSetRMSDMetric self) -> std::string"""
        return _IMP_statistics.ConfigurationSetRMSDMetric___str__(self)

    def __repr__(self):
        """__repr__(ConfigurationSetRMSDMetric self) -> std::string"""
        return _IMP_statistics.ConfigurationSetRMSDMetric___repr__(self)

    def get_from(o):
       return _object_cast_to_ConfigurationSetRMSDMetric(o)
    get_from = staticmethod(get_from)

ConfigurationSetRMSDMetric_swigregister = _IMP_statistics.ConfigurationSetRMSDMetric_swigregister
ConfigurationSetRMSDMetric_swigregister(ConfigurationSetRMSDMetric)


def create_lloyds_kmeans(*args):
  """create_lloyds_kmeans(Embedding embedding, unsigned int k, unsigned int iterations) -> PartitionalClusteringWithCenter"""
  return _IMP_statistics.create_lloyds_kmeans(*args)

def create_bin_based_clustering(*args):
  """create_bin_based_clustering(Embedding embed, double side) -> PartitionalClusteringWithCenter"""
  return _IMP_statistics.create_bin_based_clustering(*args)

def create_centrality_clustering(*args):
  """
    create_centrality_clustering(Embedding d, double far, int k) -> PartitionalClustering
    create_centrality_clustering(Metric d, double far, int k) -> PartitionalClustering
    """
  return _IMP_statistics.create_centrality_clustering(*args)

def create_diameter_clustering(*args):
  """create_diameter_clustering(Metric d, double maximum_diameter) -> PartitionalClustering"""
  return _IMP_statistics.create_diameter_clustering(*args)

def create_connectivity_clustering(*args):
  """
    create_connectivity_clustering(Embedding embed, double dist) -> PartitionalClusteringWithCenter
    create_connectivity_clustering(Metric metric, double dist) -> PartitionalClustering
    """
  return _IMP_statistics.create_connectivity_clustering(*args)

def create_gromos_clustering(*args):
  """create_gromos_clustering(Metric d, double cutoff) -> PartitionalClustering"""
  return _IMP_statistics.create_gromos_clustering(*args)

def get_quantile(*args):
  """get_quantile(Histogram1D h, double fraction) -> double"""
  return _IMP_statistics.get_quantile(*args)

def get_centroids(*args):
  """get_centroids(Embedding d, PartitionalClustering pc) -> IMP::algebra::VectorKDs"""
  return _IMP_statistics.get_centroids(*args)

def get_representatives(*args):
  """get_representatives(Embedding d, PartitionalClustering pc) -> IMP::Ints"""
  return _IMP_statistics.get_representatives(*args)
class RecursivePartitionalClusteringEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::RecursivePartitionalClusteringEmbedding class"""
    __swig_setmethods__ = {}
    for _s in [Embedding]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RecursivePartitionalClusteringEmbedding, name, value)
    __swig_getmethods__ = {}
    for _s in [Embedding]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RecursivePartitionalClusteringEmbedding, name)
    def __init__(self, *args): 
        """__init__(IMP::statistics::RecursivePartitionalClusteringEmbedding self, Embedding metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringEmbedding"""
        this = _IMP_statistics.new_RecursivePartitionalClusteringEmbedding(*args)
        try: self.this.append(this)
        except: self.this = this
    def create_full_clustering(self, *args):
        """create_full_clustering(RecursivePartitionalClusteringEmbedding self, PartitionalClustering center_cluster) -> PartitionalClustering"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding_create_full_clustering(self, *args)

    def get_version_info(self):
        """get_version_info(RecursivePartitionalClusteringEmbedding self) -> VersionInfo"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding_get_version_info(self)

    def __str__(self):
        """__str__(RecursivePartitionalClusteringEmbedding self) -> std::string"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding___str__(self)

    def __repr__(self):
        """__repr__(RecursivePartitionalClusteringEmbedding self) -> std::string"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding___repr__(self)

    def get_from(o):
       return _object_cast_to_RecursivePartitionalClusteringEmbedding(o)
    get_from = staticmethod(get_from)

RecursivePartitionalClusteringEmbedding_swigregister = _IMP_statistics.RecursivePartitionalClusteringEmbedding_swigregister
RecursivePartitionalClusteringEmbedding_swigregister(RecursivePartitionalClusteringEmbedding)

class RecursivePartitionalClusteringMetric(Metric):
    """Proxy of C++ IMP::statistics::RecursivePartitionalClusteringMetric class"""
    __swig_setmethods__ = {}
    for _s in [Metric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RecursivePartitionalClusteringMetric, name, value)
    __swig_getmethods__ = {}
    for _s in [Metric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RecursivePartitionalClusteringMetric, name)
    def __init__(self, *args): 
        """__init__(IMP::statistics::RecursivePartitionalClusteringMetric self, Metric metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringMetric"""
        this = _IMP_statistics.new_RecursivePartitionalClusteringMetric(*args)
        try: self.this.append(this)
        except: self.this = this
    def create_full_clustering(self, *args):
        """create_full_clustering(RecursivePartitionalClusteringMetric self, PartitionalClustering center_cluster) -> PartitionalClustering"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric_create_full_clustering(self, *args)

    def get_version_info(self):
        """get_version_info(RecursivePartitionalClusteringMetric self) -> VersionInfo"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric_get_version_info(self)

    def __str__(self):
        """__str__(RecursivePartitionalClusteringMetric self) -> std::string"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric___str__(self)

    def __repr__(self):
        """__repr__(RecursivePartitionalClusteringMetric self) -> std::string"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric___repr__(self)

    def get_from(o):
       return _object_cast_to_RecursivePartitionalClusteringMetric(o)
    get_from = staticmethod(get_from)

RecursivePartitionalClusteringMetric_swigregister = _IMP_statistics.RecursivePartitionalClusteringMetric_swigregister
RecursivePartitionalClusteringMetric_swigregister(RecursivePartitionalClusteringMetric)

class Histogram1D(IMP.algebra._GeometricPrimitive1D):
    """Proxy of C++ IMP::statistics::HistogramD<(1)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram1D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram1D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(1)> self) -> Histogram1D
        __init__(IMP::statistics::HistogramD<(1)> self, double voxel_size, BoundingBox1D bb) -> Histogram1D
        """
        this = _IMP_statistics.new_Histogram1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram1D self, Vector1D x, double weight=1)
        add(Histogram1D self, Vector1D x)
        """
        return _IMP_statistics.Histogram1D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram1D self) -> double"""
        return _IMP_statistics.Histogram1D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram1D self) -> Histogram1D"""
        return _IMP_statistics.Histogram1D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram1D self) -> Histogram1D"""
        return _IMP_statistics.Histogram1D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram1D self) -> _HistogramCountsGrid1D"""
        return _IMP_statistics.Histogram1D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram1D self) -> Vector1D"""
        return _IMP_statistics.Histogram1D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram1D self) -> unsigned int"""
        return _IMP_statistics.Histogram1D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram1D self, Vector1D mean) -> Vector1D"""
        return _IMP_statistics.Histogram1D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram1D self) -> BoundingBox1D"""
        return _IMP_statistics.Histogram1D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram1D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram1D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram1D self, _ostream out=std::cout)
        show(Histogram1D self)
        """
        return _IMP_statistics.Histogram1D_show(self, *args)

    def __str__(self):
        """__str__(Histogram1D self) -> std::string"""
        return _IMP_statistics.Histogram1D___str__(self)

    def __repr__(self):
        """__repr__(Histogram1D self) -> std::string"""
        return _IMP_statistics.Histogram1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram1D self, Histogram1D arg2) -> int"""
        return _IMP_statistics.Histogram1D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram1D
    __del__ = lambda self : None;
Histogram1D_swigregister = _IMP_statistics.Histogram1D_swigregister
Histogram1D_swigregister(Histogram1D)

class Histogram2D(IMP.algebra._GeometricPrimitive2D):
    """Proxy of C++ IMP::statistics::HistogramD<(2)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive2D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram2D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive2D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram2D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(2)> self) -> Histogram2D
        __init__(IMP::statistics::HistogramD<(2)> self, double voxel_size, BoundingBox2D bb) -> Histogram2D
        """
        this = _IMP_statistics.new_Histogram2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram2D self, Vector2D x, double weight=1)
        add(Histogram2D self, Vector2D x)
        """
        return _IMP_statistics.Histogram2D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram2D self) -> double"""
        return _IMP_statistics.Histogram2D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram2D self) -> Histogram2D"""
        return _IMP_statistics.Histogram2D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram2D self) -> Histogram2D"""
        return _IMP_statistics.Histogram2D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram2D self) -> _HistogramCountsGrid2D"""
        return _IMP_statistics.Histogram2D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram2D self) -> Vector2D"""
        return _IMP_statistics.Histogram2D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram2D self) -> unsigned int"""
        return _IMP_statistics.Histogram2D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram2D self, Vector2D mean) -> Vector2D"""
        return _IMP_statistics.Histogram2D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram2D self) -> BoundingBox2D"""
        return _IMP_statistics.Histogram2D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram2D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram2D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram2D self, _ostream out=std::cout)
        show(Histogram2D self)
        """
        return _IMP_statistics.Histogram2D_show(self, *args)

    def __str__(self):
        """__str__(Histogram2D self) -> std::string"""
        return _IMP_statistics.Histogram2D___str__(self)

    def __repr__(self):
        """__repr__(Histogram2D self) -> std::string"""
        return _IMP_statistics.Histogram2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram2D self, Histogram2D arg2) -> int"""
        return _IMP_statistics.Histogram2D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram2D
    __del__ = lambda self : None;
Histogram2D_swigregister = _IMP_statistics.Histogram2D_swigregister
Histogram2D_swigregister(Histogram2D)

class Histogram3D(IMP.algebra._GeometricPrimitive3D):
    """Proxy of C++ IMP::statistics::HistogramD<(3)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive3D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram3D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive3D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram3D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(3)> self) -> Histogram3D
        __init__(IMP::statistics::HistogramD<(3)> self, double voxel_size, BoundingBox3D bb) -> Histogram3D
        """
        this = _IMP_statistics.new_Histogram3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram3D self, Vector3D x, double weight=1)
        add(Histogram3D self, Vector3D x)
        """
        return _IMP_statistics.Histogram3D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram3D self) -> double"""
        return _IMP_statistics.Histogram3D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram3D self) -> Histogram3D"""
        return _IMP_statistics.Histogram3D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram3D self) -> Histogram3D"""
        return _IMP_statistics.Histogram3D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram3D self) -> _HistogramCountsGrid3D"""
        return _IMP_statistics.Histogram3D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram3D self) -> Vector3D"""
        return _IMP_statistics.Histogram3D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram3D self) -> unsigned int"""
        return _IMP_statistics.Histogram3D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram3D self, Vector3D mean) -> Vector3D"""
        return _IMP_statistics.Histogram3D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram3D self) -> BoundingBox3D"""
        return _IMP_statistics.Histogram3D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram3D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram3D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram3D self, _ostream out=std::cout)
        show(Histogram3D self)
        """
        return _IMP_statistics.Histogram3D_show(self, *args)

    def __str__(self):
        """__str__(Histogram3D self) -> std::string"""
        return _IMP_statistics.Histogram3D___str__(self)

    def __repr__(self):
        """__repr__(Histogram3D self) -> std::string"""
        return _IMP_statistics.Histogram3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram3D self, Histogram3D arg2) -> int"""
        return _IMP_statistics.Histogram3D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram3D
    __del__ = lambda self : None;
Histogram3D_swigregister = _IMP_statistics.Histogram3D_swigregister
Histogram3D_swigregister(Histogram3D)

class Histogram4D(IMP.algebra._GeometricPrimitive4D):
    """Proxy of C++ IMP::statistics::HistogramD<(4)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive4D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram4D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive4D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram4D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(4)> self) -> Histogram4D
        __init__(IMP::statistics::HistogramD<(4)> self, double voxel_size, BoundingBox4D bb) -> Histogram4D
        """
        this = _IMP_statistics.new_Histogram4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram4D self, Vector4D x, double weight=1)
        add(Histogram4D self, Vector4D x)
        """
        return _IMP_statistics.Histogram4D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram4D self) -> double"""
        return _IMP_statistics.Histogram4D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram4D self) -> Histogram4D"""
        return _IMP_statistics.Histogram4D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram4D self) -> Histogram4D"""
        return _IMP_statistics.Histogram4D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram4D self) -> _HistogramCountsGrid4D"""
        return _IMP_statistics.Histogram4D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram4D self) -> Vector4D"""
        return _IMP_statistics.Histogram4D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram4D self) -> unsigned int"""
        return _IMP_statistics.Histogram4D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram4D self, Vector4D mean) -> Vector4D"""
        return _IMP_statistics.Histogram4D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram4D self) -> BoundingBox4D"""
        return _IMP_statistics.Histogram4D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram4D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram4D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram4D self, _ostream out=std::cout)
        show(Histogram4D self)
        """
        return _IMP_statistics.Histogram4D_show(self, *args)

    def __str__(self):
        """__str__(Histogram4D self) -> std::string"""
        return _IMP_statistics.Histogram4D___str__(self)

    def __repr__(self):
        """__repr__(Histogram4D self) -> std::string"""
        return _IMP_statistics.Histogram4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram4D self, Histogram4D arg2) -> int"""
        return _IMP_statistics.Histogram4D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram4D
    __del__ = lambda self : None;
Histogram4D_swigregister = _IMP_statistics.Histogram4D_swigregister
Histogram4D_swigregister(Histogram4D)

class Histogram5D(IMP.algebra._GeometricPrimitive5D):
    """Proxy of C++ IMP::statistics::HistogramD<(5)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive5D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram5D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive5D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram5D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(5)> self) -> Histogram5D
        __init__(IMP::statistics::HistogramD<(5)> self, double voxel_size, BoundingBox5D bb) -> Histogram5D
        """
        this = _IMP_statistics.new_Histogram5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram5D self, Vector5D x, double weight=1)
        add(Histogram5D self, Vector5D x)
        """
        return _IMP_statistics.Histogram5D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram5D self) -> double"""
        return _IMP_statistics.Histogram5D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram5D self) -> Histogram5D"""
        return _IMP_statistics.Histogram5D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram5D self) -> Histogram5D"""
        return _IMP_statistics.Histogram5D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram5D self) -> _HistogramCountsGrid5D"""
        return _IMP_statistics.Histogram5D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram5D self) -> Vector5D"""
        return _IMP_statistics.Histogram5D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram5D self) -> unsigned int"""
        return _IMP_statistics.Histogram5D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram5D self, Vector5D mean) -> Vector5D"""
        return _IMP_statistics.Histogram5D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram5D self) -> BoundingBox5D"""
        return _IMP_statistics.Histogram5D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram5D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram5D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram5D self, _ostream out=std::cout)
        show(Histogram5D self)
        """
        return _IMP_statistics.Histogram5D_show(self, *args)

    def __str__(self):
        """__str__(Histogram5D self) -> std::string"""
        return _IMP_statistics.Histogram5D___str__(self)

    def __repr__(self):
        """__repr__(Histogram5D self) -> std::string"""
        return _IMP_statistics.Histogram5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram5D self, Histogram5D arg2) -> int"""
        return _IMP_statistics.Histogram5D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram5D
    __del__ = lambda self : None;
Histogram5D_swigregister = _IMP_statistics.Histogram5D_swigregister
Histogram5D_swigregister(Histogram5D)

class Histogram6D(IMP.algebra._GeometricPrimitive6D):
    """Proxy of C++ IMP::statistics::HistogramD<(6)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive6D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram6D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitive6D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram6D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(6)> self) -> Histogram6D
        __init__(IMP::statistics::HistogramD<(6)> self, double voxel_size, BoundingBox6D bb) -> Histogram6D
        """
        this = _IMP_statistics.new_Histogram6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(Histogram6D self, Vector6D x, double weight=1)
        add(Histogram6D self, Vector6D x)
        """
        return _IMP_statistics.Histogram6D_add(self, *args)

    def get_total_count(self):
        """get_total_count(Histogram6D self) -> double"""
        return _IMP_statistics.Histogram6D_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(Histogram6D self) -> Histogram6D"""
        return _IMP_statistics.Histogram6D_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(Histogram6D self) -> Histogram6D"""
        return _IMP_statistics.Histogram6D_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(Histogram6D self) -> _HistogramCountsGrid6D"""
        return _IMP_statistics.Histogram6D_get_counts(self)

    def get_mean(self):
        """get_mean(Histogram6D self) -> Vector6D"""
        return _IMP_statistics.Histogram6D_get_mean(self)

    def get_dimension(self):
        """get_dimension(Histogram6D self) -> unsigned int"""
        return _IMP_statistics.Histogram6D_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(Histogram6D self, Vector6D mean) -> Vector6D"""
        return _IMP_statistics.Histogram6D_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(Histogram6D self) -> BoundingBox6D"""
        return _IMP_statistics.Histogram6D_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(Histogram6D self) -> IMP::FloatPair"""
        return _IMP_statistics.Histogram6D_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(Histogram6D self, _ostream out=std::cout)
        show(Histogram6D self)
        """
        return _IMP_statistics.Histogram6D_show(self, *args)

    def __str__(self):
        """__str__(Histogram6D self) -> std::string"""
        return _IMP_statistics.Histogram6D___str__(self)

    def __repr__(self):
        """__repr__(Histogram6D self) -> std::string"""
        return _IMP_statistics.Histogram6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Histogram6D self, Histogram6D arg2) -> int"""
        return _IMP_statistics.Histogram6D___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_Histogram6D
    __del__ = lambda self : None;
Histogram6D_swigregister = _IMP_statistics.Histogram6D_swigregister
Histogram6D_swigregister(Histogram6D)

class HistogramKD(IMP.algebra._GeometricPrimitiveKD):
    """Proxy of C++ IMP::statistics::HistogramD<(-1)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitiveKD]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistogramKD, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra._GeometricPrimitiveKD]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HistogramKD, name)
    def __init__(self, *args): 
        """
        __init__(IMP::statistics::HistogramD<(-1)> self) -> HistogramKD
        __init__(IMP::statistics::HistogramD<(-1)> self, double voxel_size, BoundingBoxKD bb) -> HistogramKD
        """
        this = _IMP_statistics.new_HistogramKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """
        add(HistogramKD self, VectorKD x, double weight=1)
        add(HistogramKD self, VectorKD x)
        """
        return _IMP_statistics.HistogramKD_add(self, *args)

    def get_total_count(self):
        """get_total_count(HistogramKD self) -> double"""
        return _IMP_statistics.HistogramKD_get_total_count(self)

    def get_frequencies(self):
        """get_frequencies(HistogramKD self) -> HistogramKD"""
        return _IMP_statistics.HistogramKD_get_frequencies(self)

    def get_probability_distribution_function(self):
        """get_probability_distribution_function(HistogramKD self) -> HistogramKD"""
        return _IMP_statistics.HistogramKD_get_probability_distribution_function(self)

    def get_counts(self):
        """get_counts(HistogramKD self) -> _HistogramCountsGridKD"""
        return _IMP_statistics.HistogramKD_get_counts(self)

    def get_mean(self):
        """get_mean(HistogramKD self) -> VectorKD"""
        return _IMP_statistics.HistogramKD_get_mean(self)

    def get_dimension(self):
        """get_dimension(HistogramKD self) -> unsigned int"""
        return _IMP_statistics.HistogramKD_get_dimension(self)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(HistogramKD self, VectorKD mean) -> VectorKD"""
        return _IMP_statistics.HistogramKD_get_standard_deviation(self, *args)

    def get_bounding_box(self):
        """get_bounding_box(HistogramKD self) -> BoundingBoxKD"""
        return _IMP_statistics.HistogramKD_get_bounding_box(self)

    def get_minimum_and_maximum(self):
        """get_minimum_and_maximum(HistogramKD self) -> IMP::FloatPair"""
        return _IMP_statistics.HistogramKD_get_minimum_and_maximum(self)

    def show(self, *args):
        """
        show(HistogramKD self, _ostream out=std::cout)
        show(HistogramKD self)
        """
        return _IMP_statistics.HistogramKD_show(self, *args)

    def __str__(self):
        """__str__(HistogramKD self) -> std::string"""
        return _IMP_statistics.HistogramKD___str__(self)

    def __repr__(self):
        """__repr__(HistogramKD self) -> std::string"""
        return _IMP_statistics.HistogramKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(HistogramKD self, HistogramKD arg2) -> int"""
        return _IMP_statistics.HistogramKD___cmp__(self, *args)

    __swig_destroy__ = _IMP_statistics.delete_HistogramKD
    __del__ = lambda self : None;
HistogramKD_swigregister = _IMP_statistics.HistogramKD_swigregister
HistogramKD_swigregister(HistogramKD)

class _IntDenseGridStorageKD(IMP.algebra.BoundedGridRangeKD):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(-1,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRangeKD]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorageKD, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRangeKD]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorageKD, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorageKD self, GridIndexKD i, int const & v)
        __setitem__(_IntDenseGridStorageKD self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorageKD___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorageKD self, GridIndexKD i) -> int const
        __getitem__(_IntDenseGridStorageKD self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorageKD___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, _IntDenseGridStorageKD o) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, int const & default_value=int()) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self) -> _IntDenseGridStorageKD
        """
        this = _IMP_statistics.new__IntDenseGridStorageKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorageKD_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorageKD self, _ostream out=std::cout)
        show(_IntDenseGridStorageKD self)
        """
        return _IMP_statistics._IntDenseGridStorageKD_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorageKD self, ExtendedGridIndexKD arg2, int const & arg3) -> GridIndexKD"""
        return _IMP_statistics._IntDenseGridStorageKD_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorageKD self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorageKD_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorageKD
    __del__ = lambda self : None;
_IntDenseGridStorageKD_swigregister = _IMP_statistics._IntDenseGridStorageKD_swigregister
_IntDenseGridStorageKD_swigregister(_IntDenseGridStorageKD)

def _IntDenseGridStorageKD_get_is_dense():
  """_IntDenseGridStorageKD_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorageKD_get_is_dense()

class _FloatDenseGridStorageKD(IMP.algebra.BoundedGridRangeKD):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(-1,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRangeKD]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorageKD, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRangeKD]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorageKD, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorageKD self, GridIndexKD i, double const & v)
        __setitem__(_FloatDenseGridStorageKD self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorageKD___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorageKD self, GridIndexKD i) -> double const
        __getitem__(_FloatDenseGridStorageKD self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorageKD___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, _FloatDenseGridStorageKD o) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, double const & default_value=double()) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self) -> _FloatDenseGridStorageKD
        """
        this = _IMP_statistics.new__FloatDenseGridStorageKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorageKD_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorageKD self, _ostream out=std::cout)
        show(_FloatDenseGridStorageKD self)
        """
        return _IMP_statistics._FloatDenseGridStorageKD_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorageKD self, ExtendedGridIndexKD arg2, double const & arg3) -> GridIndexKD"""
        return _IMP_statistics._FloatDenseGridStorageKD_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorageKD self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorageKD_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorageKD
    __del__ = lambda self : None;
_FloatDenseGridStorageKD_swigregister = _IMP_statistics._FloatDenseGridStorageKD_swigregister
_FloatDenseGridStorageKD_swigregister(_FloatDenseGridStorageKD)

def _FloatDenseGridStorageKD_get_is_dense():
  """_FloatDenseGridStorageKD_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorageKD_get_is_dense()

class _HistogramCountsGridKD(_FloatDenseGridStorageKD,IMP.algebra.DefaultEmbeddingKD,IMP.algebra._GeometricPrimitiveKD):
    """Proxy of C++ IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorageKD,IMP.algebra.DefaultEmbeddingKD,IMP.algebra._GeometricPrimitiveKD]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGridKD, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorageKD,IMP.algebra.DefaultEmbeddingKD,IMP.algebra._GeometricPrimitiveKD]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGridKD, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, IMP::Ints const counts, BoundingBoxKD bb, double default_value=double()) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, IMP::Ints const counts, BoundingBoxKD bb) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, double side, BoundingBoxKD bb, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, double side, BoundingBoxKD bb) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, _FloatDenseGridStorageKD storage, DefaultEmbeddingKD embed) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, double side, VectorKD origin, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, double side, VectorKD origin) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self) -> _HistogramCountsGridKD
        """
        this = _IMP_statistics.new__HistogramCountsGridKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGridKD self, _ostream out=std::cout)
        show(_HistogramCountsGridKD self)
        """
        return _IMP_statistics._HistogramCountsGridKD_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGridKD self, VectorKD i) -> double const
        __getitem__(_HistogramCountsGridKD self, GridIndexKD i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGridKD___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGridKD self, VectorKD i, double const & v)
        __setitem__(_HistogramCountsGridKD self, GridIndexKD i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGridKD___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGridKD self, VectorKD pt, double const & vt) -> GridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGridKD self, GridIndexKD index) -> ExtendedGridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGridKD self) -> BoundingBoxKD
        get_bounding_box(_HistogramCountsGridKD self, ExtendedGridIndexKD i) -> BoundingBoxKD
        get_bounding_box(_HistogramCountsGridKD self, GridIndexKD i) -> BoundingBoxKD
        """
        return _IMP_statistics._HistogramCountsGridKD_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGridKD self, BoundingBoxKD bb3)"""
        return _IMP_statistics._HistogramCountsGridKD_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGridKD self, VectorKD pt) -> GridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGridKD self, VectorKD pt) -> ExtendedGridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGridKD
    __del__ = lambda self : None;
_HistogramCountsGridKD_swigregister = _IMP_statistics._HistogramCountsGridKD_swigregister
_HistogramCountsGridKD_swigregister(_HistogramCountsGridKD)

class _IntDenseGridStorage1D(IMP.algebra.BoundedGridRange1D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(1,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage1D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage1D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage1D self, GridIndex1D i, int const & v)
        __setitem__(_IntDenseGridStorage1D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage1D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage1D self, GridIndex1D i) -> int const
        __getitem__(_IntDenseGridStorage1D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage1D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, _IntDenseGridStorage1D o) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, int const & default_value=int()) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self) -> _IntDenseGridStorage1D
        """
        this = _IMP_statistics.new__IntDenseGridStorage1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage1D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage1D self, _ostream out=std::cout)
        show(_IntDenseGridStorage1D self)
        """
        return _IMP_statistics._IntDenseGridStorage1D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage1D self, ExtendedGridIndex1D arg2, int const & arg3) -> GridIndex1D"""
        return _IMP_statistics._IntDenseGridStorage1D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage1D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage1D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage1D
    __del__ = lambda self : None;
_IntDenseGridStorage1D_swigregister = _IMP_statistics._IntDenseGridStorage1D_swigregister
_IntDenseGridStorage1D_swigregister(_IntDenseGridStorage1D)

def _IntDenseGridStorage1D_get_is_dense():
  """_IntDenseGridStorage1D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage1D_get_is_dense()

class _FloatDenseGridStorage1D(IMP.algebra.BoundedGridRange1D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(1,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage1D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage1D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage1D self, GridIndex1D i, double const & v)
        __setitem__(_FloatDenseGridStorage1D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage1D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage1D self, GridIndex1D i) -> double const
        __getitem__(_FloatDenseGridStorage1D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage1D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, _FloatDenseGridStorage1D o) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self) -> _FloatDenseGridStorage1D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage1D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage1D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage1D self)
        """
        return _IMP_statistics._FloatDenseGridStorage1D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage1D self, ExtendedGridIndex1D arg2, double const & arg3) -> GridIndex1D"""
        return _IMP_statistics._FloatDenseGridStorage1D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage1D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage1D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage1D
    __del__ = lambda self : None;
_FloatDenseGridStorage1D_swigregister = _IMP_statistics._FloatDenseGridStorage1D_swigregister
_FloatDenseGridStorage1D_swigregister(_FloatDenseGridStorage1D)

def _FloatDenseGridStorage1D_get_is_dense():
  """_FloatDenseGridStorage1D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage1D_get_is_dense()

class _HistogramCountsGrid1D(_FloatDenseGridStorage1D,IMP.algebra.DefaultEmbedding1D,IMP.algebra._GeometricPrimitive1D):
    """Proxy of C++ IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage1D,IMP.algebra.DefaultEmbedding1D,IMP.algebra._GeometricPrimitive1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid1D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage1D,IMP.algebra.DefaultEmbedding1D,IMP.algebra._GeometricPrimitive1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, IMP::Ints const counts, BoundingBox1D bb, double default_value=double()) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, IMP::Ints const counts, BoundingBox1D bb) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, double side, BoundingBox1D bb, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, double side, BoundingBox1D bb) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, _FloatDenseGridStorage1D storage, DefaultEmbedding1D embed) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, double side, Vector1D origin, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, double side, Vector1D origin) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self) -> _HistogramCountsGrid1D
        """
        this = _IMP_statistics.new__HistogramCountsGrid1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid1D self, _ostream out=std::cout)
        show(_HistogramCountsGrid1D self)
        """
        return _IMP_statistics._HistogramCountsGrid1D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid1D self, Vector1D i) -> double const
        __getitem__(_HistogramCountsGrid1D self, GridIndex1D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid1D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid1D self, Vector1D i, double const & v)
        __setitem__(_HistogramCountsGrid1D self, GridIndex1D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid1D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid1D self, Vector1D pt, double const & vt) -> GridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid1D self, GridIndex1D index) -> ExtendedGridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid1D self) -> BoundingBox1D
        get_bounding_box(_HistogramCountsGrid1D self, ExtendedGridIndex1D i) -> BoundingBox1D
        get_bounding_box(_HistogramCountsGrid1D self, GridIndex1D i) -> BoundingBox1D
        """
        return _IMP_statistics._HistogramCountsGrid1D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid1D self, BoundingBox1D bb3)"""
        return _IMP_statistics._HistogramCountsGrid1D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid1D self, Vector1D pt) -> GridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid1D self, Vector1D pt) -> ExtendedGridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid1D
    __del__ = lambda self : None;
_HistogramCountsGrid1D_swigregister = _IMP_statistics._HistogramCountsGrid1D_swigregister
_HistogramCountsGrid1D_swigregister(_HistogramCountsGrid1D)

class _IntDenseGridStorage2D(IMP.algebra.BoundedGridRange2D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(2,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange2D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage2D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange2D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage2D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage2D self, GridIndex2D i, int const & v)
        __setitem__(_IntDenseGridStorage2D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage2D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage2D self, GridIndex2D i) -> int const
        __getitem__(_IntDenseGridStorage2D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage2D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, _IntDenseGridStorage2D o) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, int const & default_value=int()) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self) -> _IntDenseGridStorage2D
        """
        this = _IMP_statistics.new__IntDenseGridStorage2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage2D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage2D self, _ostream out=std::cout)
        show(_IntDenseGridStorage2D self)
        """
        return _IMP_statistics._IntDenseGridStorage2D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage2D self, ExtendedGridIndex2D arg2, int const & arg3) -> GridIndex2D"""
        return _IMP_statistics._IntDenseGridStorage2D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage2D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage2D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage2D
    __del__ = lambda self : None;
_IntDenseGridStorage2D_swigregister = _IMP_statistics._IntDenseGridStorage2D_swigregister
_IntDenseGridStorage2D_swigregister(_IntDenseGridStorage2D)

def _IntDenseGridStorage2D_get_is_dense():
  """_IntDenseGridStorage2D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage2D_get_is_dense()

class _FloatDenseGridStorage2D(IMP.algebra.BoundedGridRange2D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(2,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange2D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage2D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange2D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage2D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage2D self, GridIndex2D i, double const & v)
        __setitem__(_FloatDenseGridStorage2D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage2D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage2D self, GridIndex2D i) -> double const
        __getitem__(_FloatDenseGridStorage2D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage2D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, _FloatDenseGridStorage2D o) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self) -> _FloatDenseGridStorage2D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage2D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage2D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage2D self)
        """
        return _IMP_statistics._FloatDenseGridStorage2D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage2D self, ExtendedGridIndex2D arg2, double const & arg3) -> GridIndex2D"""
        return _IMP_statistics._FloatDenseGridStorage2D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage2D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage2D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage2D
    __del__ = lambda self : None;
_FloatDenseGridStorage2D_swigregister = _IMP_statistics._FloatDenseGridStorage2D_swigregister
_FloatDenseGridStorage2D_swigregister(_FloatDenseGridStorage2D)

def _FloatDenseGridStorage2D_get_is_dense():
  """_FloatDenseGridStorage2D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage2D_get_is_dense()

class _HistogramCountsGrid2D(_FloatDenseGridStorage2D,IMP.algebra.DefaultEmbedding2D,IMP.algebra._GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage2D,IMP.algebra.DefaultEmbedding2D,IMP.algebra._GeometricPrimitive2D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid2D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage2D,IMP.algebra.DefaultEmbedding2D,IMP.algebra._GeometricPrimitive2D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, IMP::Ints const counts, BoundingBox2D bb, double default_value=double()) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, IMP::Ints const counts, BoundingBox2D bb) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, double side, BoundingBox2D bb, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, double side, BoundingBox2D bb) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, _FloatDenseGridStorage2D storage, DefaultEmbedding2D embed) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, double side, Vector2D origin, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, double side, Vector2D origin) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self) -> _HistogramCountsGrid2D
        """
        this = _IMP_statistics.new__HistogramCountsGrid2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid2D self, _ostream out=std::cout)
        show(_HistogramCountsGrid2D self)
        """
        return _IMP_statistics._HistogramCountsGrid2D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid2D self, Vector2D i) -> double const
        __getitem__(_HistogramCountsGrid2D self, GridIndex2D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid2D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid2D self, Vector2D i, double const & v)
        __setitem__(_HistogramCountsGrid2D self, GridIndex2D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid2D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid2D self, Vector2D pt, double const & vt) -> GridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid2D self, GridIndex2D index) -> ExtendedGridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid2D self) -> BoundingBox2D
        get_bounding_box(_HistogramCountsGrid2D self, ExtendedGridIndex2D i) -> BoundingBox2D
        get_bounding_box(_HistogramCountsGrid2D self, GridIndex2D i) -> BoundingBox2D
        """
        return _IMP_statistics._HistogramCountsGrid2D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid2D self, BoundingBox2D bb3)"""
        return _IMP_statistics._HistogramCountsGrid2D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid2D self, Vector2D pt) -> GridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid2D self, Vector2D pt) -> ExtendedGridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid2D
    __del__ = lambda self : None;
_HistogramCountsGrid2D_swigregister = _IMP_statistics._HistogramCountsGrid2D_swigregister
_HistogramCountsGrid2D_swigregister(_HistogramCountsGrid2D)

class _IntDenseGridStorage3D(IMP.algebra.BoundedGridRange3D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(3,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange3D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage3D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange3D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage3D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage3D self, GridIndex3D i, int const & v)
        __setitem__(_IntDenseGridStorage3D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage3D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage3D self, GridIndex3D i) -> int const
        __getitem__(_IntDenseGridStorage3D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage3D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, _IntDenseGridStorage3D o) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, int const & default_value=int()) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self) -> _IntDenseGridStorage3D
        """
        this = _IMP_statistics.new__IntDenseGridStorage3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage3D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage3D self, _ostream out=std::cout)
        show(_IntDenseGridStorage3D self)
        """
        return _IMP_statistics._IntDenseGridStorage3D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage3D self, ExtendedGridIndex3D arg2, int const & arg3) -> GridIndex3D"""
        return _IMP_statistics._IntDenseGridStorage3D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage3D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage3D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage3D
    __del__ = lambda self : None;
_IntDenseGridStorage3D_swigregister = _IMP_statistics._IntDenseGridStorage3D_swigregister
_IntDenseGridStorage3D_swigregister(_IntDenseGridStorage3D)

def _IntDenseGridStorage3D_get_is_dense():
  """_IntDenseGridStorage3D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage3D_get_is_dense()

class _FloatDenseGridStorage3D(IMP.algebra.BoundedGridRange3D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(3,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange3D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage3D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange3D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage3D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage3D self, GridIndex3D i, double const & v)
        __setitem__(_FloatDenseGridStorage3D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage3D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage3D self, GridIndex3D i) -> double const
        __getitem__(_FloatDenseGridStorage3D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage3D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, _FloatDenseGridStorage3D o) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self) -> _FloatDenseGridStorage3D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage3D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage3D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage3D self)
        """
        return _IMP_statistics._FloatDenseGridStorage3D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage3D self, ExtendedGridIndex3D arg2, double const & arg3) -> GridIndex3D"""
        return _IMP_statistics._FloatDenseGridStorage3D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage3D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage3D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage3D
    __del__ = lambda self : None;
_FloatDenseGridStorage3D_swigregister = _IMP_statistics._FloatDenseGridStorage3D_swigregister
_FloatDenseGridStorage3D_swigregister(_FloatDenseGridStorage3D)

def _FloatDenseGridStorage3D_get_is_dense():
  """_FloatDenseGridStorage3D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage3D_get_is_dense()

class _HistogramCountsGrid3D(_FloatDenseGridStorage3D,IMP.algebra.DefaultEmbedding3D,IMP.algebra._GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage3D,IMP.algebra.DefaultEmbedding3D,IMP.algebra._GeometricPrimitive3D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid3D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage3D,IMP.algebra.DefaultEmbedding3D,IMP.algebra._GeometricPrimitive3D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid3D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, IMP::Ints const counts, BoundingBox3D bb, double default_value=double()) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, IMP::Ints const counts, BoundingBox3D bb) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, double side, BoundingBox3D bb, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, double side, BoundingBox3D bb) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, _FloatDenseGridStorage3D storage, DefaultEmbedding3D embed) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, double side, Vector3D origin, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, double side, Vector3D origin) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self) -> _HistogramCountsGrid3D
        """
        this = _IMP_statistics.new__HistogramCountsGrid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid3D self, _ostream out=std::cout)
        show(_HistogramCountsGrid3D self)
        """
        return _IMP_statistics._HistogramCountsGrid3D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid3D self, Vector3D i) -> double const
        __getitem__(_HistogramCountsGrid3D self, GridIndex3D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid3D self, Vector3D i, double const & v)
        __setitem__(_HistogramCountsGrid3D self, GridIndex3D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid3D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid3D self, Vector3D pt, double const & vt) -> GridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid3D self, GridIndex3D index) -> ExtendedGridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid3D self) -> BoundingBox3D
        get_bounding_box(_HistogramCountsGrid3D self, ExtendedGridIndex3D i) -> BoundingBox3D
        get_bounding_box(_HistogramCountsGrid3D self, GridIndex3D i) -> BoundingBox3D
        """
        return _IMP_statistics._HistogramCountsGrid3D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid3D self, BoundingBox3D bb3)"""
        return _IMP_statistics._HistogramCountsGrid3D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid3D self, Vector3D pt) -> GridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid3D self, Vector3D pt) -> ExtendedGridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid3D
    __del__ = lambda self : None;
_HistogramCountsGrid3D_swigregister = _IMP_statistics._HistogramCountsGrid3D_swigregister
_HistogramCountsGrid3D_swigregister(_HistogramCountsGrid3D)

class _IntDenseGridStorage4D(IMP.algebra.BoundedGridRange4D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(4,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange4D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage4D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange4D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage4D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage4D self, GridIndex4D i, int const & v)
        __setitem__(_IntDenseGridStorage4D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage4D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage4D self, GridIndex4D i) -> int const
        __getitem__(_IntDenseGridStorage4D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage4D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, _IntDenseGridStorage4D o) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, int const & default_value=int()) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self) -> _IntDenseGridStorage4D
        """
        this = _IMP_statistics.new__IntDenseGridStorage4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage4D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage4D self, _ostream out=std::cout)
        show(_IntDenseGridStorage4D self)
        """
        return _IMP_statistics._IntDenseGridStorage4D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage4D self, ExtendedGridIndex4D arg2, int const & arg3) -> GridIndex4D"""
        return _IMP_statistics._IntDenseGridStorage4D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage4D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage4D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage4D
    __del__ = lambda self : None;
_IntDenseGridStorage4D_swigregister = _IMP_statistics._IntDenseGridStorage4D_swigregister
_IntDenseGridStorage4D_swigregister(_IntDenseGridStorage4D)

def _IntDenseGridStorage4D_get_is_dense():
  """_IntDenseGridStorage4D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage4D_get_is_dense()

class _FloatDenseGridStorage4D(IMP.algebra.BoundedGridRange4D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(4,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange4D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage4D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange4D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage4D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage4D self, GridIndex4D i, double const & v)
        __setitem__(_FloatDenseGridStorage4D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage4D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage4D self, GridIndex4D i) -> double const
        __getitem__(_FloatDenseGridStorage4D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage4D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, _FloatDenseGridStorage4D o) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self) -> _FloatDenseGridStorage4D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage4D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage4D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage4D self)
        """
        return _IMP_statistics._FloatDenseGridStorage4D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage4D self, ExtendedGridIndex4D arg2, double const & arg3) -> GridIndex4D"""
        return _IMP_statistics._FloatDenseGridStorage4D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage4D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage4D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage4D
    __del__ = lambda self : None;
_FloatDenseGridStorage4D_swigregister = _IMP_statistics._FloatDenseGridStorage4D_swigregister
_FloatDenseGridStorage4D_swigregister(_FloatDenseGridStorage4D)

def _FloatDenseGridStorage4D_get_is_dense():
  """_FloatDenseGridStorage4D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage4D_get_is_dense()

class _HistogramCountsGrid4D(_FloatDenseGridStorage4D,IMP.algebra.DefaultEmbedding4D,IMP.algebra._GeometricPrimitive4D):
    """Proxy of C++ IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage4D,IMP.algebra.DefaultEmbedding4D,IMP.algebra._GeometricPrimitive4D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid4D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage4D,IMP.algebra.DefaultEmbedding4D,IMP.algebra._GeometricPrimitive4D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid4D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, IMP::Ints const counts, BoundingBox4D bb, double default_value=double()) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, IMP::Ints const counts, BoundingBox4D bb) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, double side, BoundingBox4D bb, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, double side, BoundingBox4D bb) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, _FloatDenseGridStorage4D storage, DefaultEmbedding4D embed) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, double side, Vector4D origin, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, double side, Vector4D origin) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self) -> _HistogramCountsGrid4D
        """
        this = _IMP_statistics.new__HistogramCountsGrid4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid4D self, _ostream out=std::cout)
        show(_HistogramCountsGrid4D self)
        """
        return _IMP_statistics._HistogramCountsGrid4D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid4D self, Vector4D i) -> double const
        __getitem__(_HistogramCountsGrid4D self, GridIndex4D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid4D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid4D self, Vector4D i, double const & v)
        __setitem__(_HistogramCountsGrid4D self, GridIndex4D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid4D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid4D self, Vector4D pt, double const & vt) -> GridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid4D self, GridIndex4D index) -> ExtendedGridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid4D self) -> BoundingBox4D
        get_bounding_box(_HistogramCountsGrid4D self, ExtendedGridIndex4D i) -> BoundingBox4D
        get_bounding_box(_HistogramCountsGrid4D self, GridIndex4D i) -> BoundingBox4D
        """
        return _IMP_statistics._HistogramCountsGrid4D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid4D self, BoundingBox4D bb3)"""
        return _IMP_statistics._HistogramCountsGrid4D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid4D self, Vector4D pt) -> GridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid4D self, Vector4D pt) -> ExtendedGridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid4D
    __del__ = lambda self : None;
_HistogramCountsGrid4D_swigregister = _IMP_statistics._HistogramCountsGrid4D_swigregister
_HistogramCountsGrid4D_swigregister(_HistogramCountsGrid4D)

class _IntDenseGridStorage5D(IMP.algebra.BoundedGridRange5D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(5,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange5D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage5D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange5D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage5D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage5D self, GridIndex5D i, int const & v)
        __setitem__(_IntDenseGridStorage5D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage5D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage5D self, GridIndex5D i) -> int const
        __getitem__(_IntDenseGridStorage5D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage5D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, _IntDenseGridStorage5D o) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, int const & default_value=int()) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self) -> _IntDenseGridStorage5D
        """
        this = _IMP_statistics.new__IntDenseGridStorage5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage5D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage5D self, _ostream out=std::cout)
        show(_IntDenseGridStorage5D self)
        """
        return _IMP_statistics._IntDenseGridStorage5D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage5D self, ExtendedGridIndex5D arg2, int const & arg3) -> GridIndex5D"""
        return _IMP_statistics._IntDenseGridStorage5D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage5D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage5D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage5D
    __del__ = lambda self : None;
_IntDenseGridStorage5D_swigregister = _IMP_statistics._IntDenseGridStorage5D_swigregister
_IntDenseGridStorage5D_swigregister(_IntDenseGridStorage5D)

def _IntDenseGridStorage5D_get_is_dense():
  """_IntDenseGridStorage5D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage5D_get_is_dense()

class _FloatDenseGridStorage5D(IMP.algebra.BoundedGridRange5D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(5,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange5D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage5D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange5D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage5D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage5D self, GridIndex5D i, double const & v)
        __setitem__(_FloatDenseGridStorage5D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage5D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage5D self, GridIndex5D i) -> double const
        __getitem__(_FloatDenseGridStorage5D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage5D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, _FloatDenseGridStorage5D o) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self) -> _FloatDenseGridStorage5D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage5D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage5D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage5D self)
        """
        return _IMP_statistics._FloatDenseGridStorage5D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage5D self, ExtendedGridIndex5D arg2, double const & arg3) -> GridIndex5D"""
        return _IMP_statistics._FloatDenseGridStorage5D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage5D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage5D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage5D
    __del__ = lambda self : None;
_FloatDenseGridStorage5D_swigregister = _IMP_statistics._FloatDenseGridStorage5D_swigregister
_FloatDenseGridStorage5D_swigregister(_FloatDenseGridStorage5D)

def _FloatDenseGridStorage5D_get_is_dense():
  """_FloatDenseGridStorage5D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage5D_get_is_dense()

class _HistogramCountsGrid5D(_FloatDenseGridStorage5D,IMP.algebra.DefaultEmbedding5D,IMP.algebra._GeometricPrimitive5D):
    """Proxy of C++ IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage5D,IMP.algebra.DefaultEmbedding5D,IMP.algebra._GeometricPrimitive5D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid5D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage5D,IMP.algebra.DefaultEmbedding5D,IMP.algebra._GeometricPrimitive5D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid5D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, IMP::Ints const counts, BoundingBox5D bb, double default_value=double()) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, IMP::Ints const counts, BoundingBox5D bb) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, double side, BoundingBox5D bb, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, double side, BoundingBox5D bb) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, _FloatDenseGridStorage5D storage, DefaultEmbedding5D embed) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, double side, Vector5D origin, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, double side, Vector5D origin) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self) -> _HistogramCountsGrid5D
        """
        this = _IMP_statistics.new__HistogramCountsGrid5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid5D self, _ostream out=std::cout)
        show(_HistogramCountsGrid5D self)
        """
        return _IMP_statistics._HistogramCountsGrid5D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid5D self, Vector5D i) -> double const
        __getitem__(_HistogramCountsGrid5D self, GridIndex5D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid5D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid5D self, Vector5D i, double const & v)
        __setitem__(_HistogramCountsGrid5D self, GridIndex5D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid5D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid5D self, Vector5D pt, double const & vt) -> GridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid5D self, GridIndex5D index) -> ExtendedGridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid5D self) -> BoundingBox5D
        get_bounding_box(_HistogramCountsGrid5D self, ExtendedGridIndex5D i) -> BoundingBox5D
        get_bounding_box(_HistogramCountsGrid5D self, GridIndex5D i) -> BoundingBox5D
        """
        return _IMP_statistics._HistogramCountsGrid5D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid5D self, BoundingBox5D bb3)"""
        return _IMP_statistics._HistogramCountsGrid5D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid5D self, Vector5D pt) -> GridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid5D self, Vector5D pt) -> ExtendedGridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid5D
    __del__ = lambda self : None;
_HistogramCountsGrid5D_swigregister = _IMP_statistics._HistogramCountsGrid5D_swigregister
_HistogramCountsGrid5D_swigregister(_HistogramCountsGrid5D)

class _IntDenseGridStorage6D(IMP.algebra.BoundedGridRange6D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(6,int)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange6D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _IntDenseGridStorage6D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange6D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _IntDenseGridStorage6D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_IntDenseGridStorage6D self, GridIndex6D i, int const & v)
        __setitem__(_IntDenseGridStorage6D self, unsigned int i, int const & v)
        """
        return _IMP_statistics._IntDenseGridStorage6D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_IntDenseGridStorage6D self, GridIndex6D i) -> int const
        __getitem__(_IntDenseGridStorage6D self, unsigned int i) -> int const &
        """
        return _IMP_statistics._IntDenseGridStorage6D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, _IntDenseGridStorage6D o) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, int const & default_value=int()) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self) -> _IntDenseGridStorage6D
        """
        this = _IMP_statistics.new__IntDenseGridStorage6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage6D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_IntDenseGridStorage6D self, _ostream out=std::cout)
        show(_IntDenseGridStorage6D self)
        """
        return _IMP_statistics._IntDenseGridStorage6D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_IntDenseGridStorage6D self, ExtendedGridIndex6D arg2, int const & arg3) -> GridIndex6D"""
        return _IMP_statistics._IntDenseGridStorage6D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage6D self) -> IMP::base::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage6D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage6D
    __del__ = lambda self : None;
_IntDenseGridStorage6D_swigregister = _IMP_statistics._IntDenseGridStorage6D_swigregister
_IntDenseGridStorage6D_swigregister(_IntDenseGridStorage6D)

def _IntDenseGridStorage6D_get_is_dense():
  """_IntDenseGridStorage6D_get_is_dense() -> bool"""
  return _IMP_statistics._IntDenseGridStorage6D_get_is_dense()

class _FloatDenseGridStorage6D(IMP.algebra.BoundedGridRange6D):
    """Proxy of C++ IMP::algebra::DenseGridStorageD<(6,double)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange6D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _FloatDenseGridStorage6D, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.algebra.BoundedGridRange6D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _FloatDenseGridStorage6D, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """
        __setitem__(_FloatDenseGridStorage6D self, GridIndex6D i, double const & v)
        __setitem__(_FloatDenseGridStorage6D self, unsigned int i, double const & v)
        """
        return _IMP_statistics._FloatDenseGridStorage6D___setitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_FloatDenseGridStorage6D self, GridIndex6D i) -> double const
        __getitem__(_FloatDenseGridStorage6D self, unsigned int i) -> double const &
        """
        return _IMP_statistics._FloatDenseGridStorage6D___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, _FloatDenseGridStorage6D o) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, double const & default_value=double()) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self) -> _FloatDenseGridStorage6D
        """
        this = _IMP_statistics.new__FloatDenseGridStorage6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_dense():
        """get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage6D_get_is_dense()

    if _newclass:get_is_dense = staticmethod(get_is_dense)
    __swig_getmethods__["get_is_dense"] = lambda x: get_is_dense
    def show(self, *args):
        """
        show(_FloatDenseGridStorage6D self, _ostream out=std::cout)
        show(_FloatDenseGridStorage6D self)
        """
        return _IMP_statistics._FloatDenseGridStorage6D_show(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_FloatDenseGridStorage6D self, ExtendedGridIndex6D arg2, double const & arg3) -> GridIndex6D"""
        return _IMP_statistics._FloatDenseGridStorage6D_add_voxel(self, *args)

    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage6D self) -> IMP::base::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage6D_get_all_voxels(self)

    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage6D
    __del__ = lambda self : None;
_FloatDenseGridStorage6D_swigregister = _IMP_statistics._FloatDenseGridStorage6D_swigregister
_FloatDenseGridStorage6D_swigregister(_FloatDenseGridStorage6D)

def _FloatDenseGridStorage6D_get_is_dense():
  """_FloatDenseGridStorage6D_get_is_dense() -> bool"""
  return _IMP_statistics._FloatDenseGridStorage6D_get_is_dense()

class _HistogramCountsGrid6D(_FloatDenseGridStorage6D,IMP.algebra.DefaultEmbedding6D,IMP.algebra._GeometricPrimitive6D):
    """Proxy of C++ IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> class"""
    __swig_setmethods__ = {}
    for _s in [_FloatDenseGridStorage6D,IMP.algebra.DefaultEmbedding6D,IMP.algebra._GeometricPrimitive6D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HistogramCountsGrid6D, name, value)
    __swig_getmethods__ = {}
    for _s in [_FloatDenseGridStorage6D,IMP.algebra.DefaultEmbedding6D,IMP.algebra._GeometricPrimitive6D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _HistogramCountsGrid6D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, IMP::Ints const counts, BoundingBox6D bb, double default_value=double()) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, IMP::Ints const counts, BoundingBox6D bb) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, double side, BoundingBox6D bb, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, double side, BoundingBox6D bb) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, _FloatDenseGridStorage6D storage, DefaultEmbedding6D embed) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, double side, Vector6D origin, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, double side, Vector6D origin) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self) -> _HistogramCountsGrid6D
        """
        this = _IMP_statistics.new__HistogramCountsGrid6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_HistogramCountsGrid6D self, _ostream out=std::cout)
        show(_HistogramCountsGrid6D self)
        """
        return _IMP_statistics._HistogramCountsGrid6D_show(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(_HistogramCountsGrid6D self, Vector6D i) -> double const
        __getitem__(_HistogramCountsGrid6D self, GridIndex6D i) -> double const &
        """
        return _IMP_statistics._HistogramCountsGrid6D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(_HistogramCountsGrid6D self, Vector6D i, double const & v)
        __setitem__(_HistogramCountsGrid6D self, GridIndex6D i, double const & vt)
        """
        return _IMP_statistics._HistogramCountsGrid6D___setitem__(self, *args)

    def add_voxel(self, *args):
        """add_voxel(_HistogramCountsGrid6D self, Vector6D pt, double const & vt) -> GridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_add_voxel(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(_HistogramCountsGrid6D self, GridIndex6D index) -> ExtendedGridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_get_extended_index(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(_HistogramCountsGrid6D self) -> BoundingBox6D
        get_bounding_box(_HistogramCountsGrid6D self, ExtendedGridIndex6D i) -> BoundingBox6D
        get_bounding_box(_HistogramCountsGrid6D self, GridIndex6D i) -> BoundingBox6D
        """
        return _IMP_statistics._HistogramCountsGrid6D_get_bounding_box(self, *args)

    def set_bounding_box(self, *args):
        """set_bounding_box(_HistogramCountsGrid6D self, BoundingBox6D bb3)"""
        return _IMP_statistics._HistogramCountsGrid6D_set_bounding_box(self, *args)

    def get_nearest_index(self, *args):
        """get_nearest_index(_HistogramCountsGrid6D self, Vector6D pt) -> GridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_get_nearest_index(self, *args)

    def get_nearest_extended_index(self, *args):
        """get_nearest_extended_index(_HistogramCountsGrid6D self, Vector6D pt) -> ExtendedGridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_get_nearest_extended_index(self, *args)

    __swig_destroy__ = _IMP_statistics.delete__HistogramCountsGrid6D
    __del__ = lambda self : None;
_HistogramCountsGrid6D_swigregister = _IMP_statistics._HistogramCountsGrid6D_swigregister
_HistogramCountsGrid6D_swigregister(_HistogramCountsGrid6D)

import _histogram
show_histogram= _histogram.show_histogram


def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_statistics.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_statistics.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_statistics.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

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