statistics/__init__.py

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

# This wrapper is part of IMP,
# Copyright 2007-2021 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




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):
        object.__setattr__(self, 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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x):
        """distance(IMP_STATISTICS_SwigPyIterator self, IMP_STATISTICS_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_distance(self, x)


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


    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, n):
        """advance(IMP_STATISTICS_SwigPyIterator self, ptrdiff_t n) -> IMP_STATISTICS_SwigPyIterator"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_advance(self, n)


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


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


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


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


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


    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_statistics.IMP_DEBUG_swigconstant(_IMP_statistics)
IMP_DEBUG = _IMP_statistics.IMP_DEBUG

_IMP_statistics.IMP_RELEASE_swigconstant(_IMP_statistics)
IMP_RELEASE = _IMP_statistics.IMP_RELEASE

_IMP_statistics.IMP_SILENT_swigconstant(_IMP_statistics)
IMP_SILENT = _IMP_statistics.IMP_SILENT

_IMP_statistics.IMP_PROGRESS_swigconstant(_IMP_statistics)
IMP_PROGRESS = _IMP_statistics.IMP_PROGRESS

_IMP_statistics.IMP_TERSE_swigconstant(_IMP_statistics)
IMP_TERSE = _IMP_statistics.IMP_TERSE

_IMP_statistics.IMP_VERBOSE_swigconstant(_IMP_statistics)
IMP_VERBOSE = _IMP_statistics.IMP_VERBOSE

_IMP_statistics.IMP_MEMORY_swigconstant(_IMP_statistics)
IMP_MEMORY = _IMP_statistics.IMP_MEMORY

_IMP_statistics.IMP_NONE_swigconstant(_IMP_statistics)
IMP_NONE = _IMP_statistics.IMP_NONE

_IMP_statistics.IMP_USAGE_swigconstant(_IMP_statistics)
IMP_USAGE = _IMP_statistics.IMP_USAGE

_IMP_statistics.IMP_INTERNAL_swigconstant(_IMP_statistics)
IMP_INTERNAL = _IMP_statistics.IMP_INTERNAL

_IMP_statistics.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_LOG4CXX = _IMP_statistics.IMP_KERNEL_HAS_LOG4CXX

_IMP_statistics.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_statistics)
IMP_COMPILER_HAS_AUTO = _IMP_statistics.IMP_COMPILER_HAS_AUTO

_IMP_statistics.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_statistics)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_statistics.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_statistics.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_statistics)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_statistics.IMP_COMPILER_HAS_UNIQUE_PTR

_IMP_statistics.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_statistics.IMP_KERNEL_HAS_NUMPY_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_NUMPY = _IMP_statistics.IMP_KERNEL_HAS_NUMPY

_IMP_statistics.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_statistics.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_statistics)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_statistics.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_statistics)
IMPKERNEL_SHOW_WARNINGS = _IMP_statistics.IMPKERNEL_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]
# Do in two steps so the references are kept until the end of the
# function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_statistics._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_statistics._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_statistics.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_statistics)
IMP_COMPILER_HAS_OVERRIDE = _IMP_statistics.IMP_COMPILER_HAS_OVERRIDE

_IMP_statistics.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_statistics)
IMP_COMPILER_HAS_FINAL = _IMP_statistics.IMP_COMPILER_HAS_FINAL

_IMP_statistics.IMP_HAS_NOEXCEPT_swigconstant(_IMP_statistics)
IMP_HAS_NOEXCEPT = _IMP_statistics.IMP_HAS_NOEXCEPT

_IMP_statistics.IMP_C_OPEN_BINARY_swigconstant(_IMP_statistics)
IMP_C_OPEN_BINARY = _IMP_statistics.IMP_C_OPEN_BINARY
import IMP

_IMP_statistics.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_statistics)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_statistics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_statistics)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_statistics.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_statistics)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_statistics.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_statistics)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_statistics.IMP_CGAL_HAS_NUMPY_swigconstant(_IMP_statistics)
IMP_CGAL_HAS_NUMPY = _IMP_statistics.IMP_CGAL_HAS_NUMPY

_IMP_statistics.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_statistics)
IMPCGAL_SHOW_WARNINGS = _IMP_statistics.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_statistics.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_statistics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_statistics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_statistics.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_statistics.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_statistics.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_CGAL

_IMP_statistics.IMP_ALGEBRA_HAS_NUMPY_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_NUMPY = _IMP_statistics.IMP_ALGEBRA_HAS_NUMPY

_IMP_statistics.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_statistics)
IMP_ALGEBRA_HAS_ANN = _IMP_statistics.IMP_ALGEBRA_HAS_ANN

_IMP_statistics.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_statistics)
IMPALGEBRA_SHOW_WARNINGS = _IMP_statistics.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_statistics.IMP_STATISTICS_HAS_IMP_CGAL_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_IMP_CGAL

_IMP_statistics.IMP_STATISTICS_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

_IMP_statistics.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

_IMP_statistics.IMP_STATISTICS_HAS_BOOST_RANDOM_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_RANDOM

_IMP_statistics.IMP_STATISTICS_HAS_BOOST_SYSTEM_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_SYSTEM

_IMP_statistics.IMP_STATISTICS_HAS_CGAL_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_CGAL

_IMP_statistics.IMP_STATISTICS_HAS_NUMPY_swigconstant(_IMP_statistics)
IMP_STATISTICS_HAS_NUMPY = _IMP_statistics.IMP_STATISTICS_HAS_NUMPY

_IMP_statistics.IMPSTATISTICS_SHOW_WARNINGS_swigconstant(_IMP_statistics)
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(o):
    """_object_cast_to_PartitionalClustering(Object o) -> PartitionalClustering"""
    return _IMP_statistics._object_cast_to_PartitionalClustering(o)

_object_types.append("PartitionalClusteringWithCenter")


def _object_cast_to_PartitionalClusteringWithCenter(o):
    """_object_cast_to_PartitionalClusteringWithCenter(Object o) -> PartitionalClusteringWithCenter"""
    return _IMP_statistics._object_cast_to_PartitionalClusteringWithCenter(o)

_object_types.append("Embedding")


def _object_cast_to_Embedding(o):
    """_object_cast_to_Embedding(Object o) -> Embedding"""
    return _IMP_statistics._object_cast_to_Embedding(o)

_object_types.append("ConfigurationSetXYZEmbedding")


def _object_cast_to_ConfigurationSetXYZEmbedding(o):
    """_object_cast_to_ConfigurationSetXYZEmbedding(Object o) -> ConfigurationSetXYZEmbedding"""
    return _IMP_statistics._object_cast_to_ConfigurationSetXYZEmbedding(o)

_object_types.append("VectorDEmbedding")


def _object_cast_to_VectorDEmbedding(o):
    """_object_cast_to_VectorDEmbedding(Object o) -> VectorDEmbedding"""
    return _IMP_statistics._object_cast_to_VectorDEmbedding(o)

_object_types.append("ParticleEmbedding")


def _object_cast_to_ParticleEmbedding(o):
    """_object_cast_to_ParticleEmbedding(Object o) -> ParticleEmbedding"""
    return _IMP_statistics._object_cast_to_ParticleEmbedding(o)

_object_types.append("Metric")


def _object_cast_to_Metric(o):
    """_object_cast_to_Metric(Object o) -> Metric"""
    return _IMP_statistics._object_cast_to_Metric(o)

_object_types.append("EuclideanMetric")


def _object_cast_to_EuclideanMetric(o):
    """_object_cast_to_EuclideanMetric(Object o) -> EuclideanMetric"""
    return _IMP_statistics._object_cast_to_EuclideanMetric(o)

_object_types.append("ConfigurationSetRMSDMetric")


def _object_cast_to_ConfigurationSetRMSDMetric(o):
    """_object_cast_to_ConfigurationSetRMSDMetric(Object o) -> ConfigurationSetRMSDMetric"""
    return _IMP_statistics._object_cast_to_ConfigurationSetRMSDMetric(o)

_object_types.append("RecursivePartitionalClusteringMetric")


def _object_cast_to_RecursivePartitionalClusteringMetric(o):
    """_object_cast_to_RecursivePartitionalClusteringMetric(Object o) -> RecursivePartitionalClusteringMetric"""
    return _IMP_statistics._object_cast_to_RecursivePartitionalClusteringMetric(o)

_object_types.append("RecursivePartitionalClusteringEmbedding")


def _object_cast_to_RecursivePartitionalClusteringEmbedding(o):
    """_object_cast_to_RecursivePartitionalClusteringEmbedding(Object o) -> RecursivePartitionalClusteringEmbedding"""
    return _IMP_statistics._object_cast_to_RecursivePartitionalClusteringEmbedding(o)

_object_types.append("ChiSquareMetric")


def _object_cast_to_ChiSquareMetric(o):
    """_object_cast_to_ChiSquareMetric(Object o) -> ChiSquareMetric"""
    return _IMP_statistics._object_cast_to_ChiSquareMetric(o)
class PartitionalClustering(IMP.Object):
    """Proxy of C++ IMP::statistics::PartitionalClustering class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, cluster_index):
        """get_cluster(PartitionalClustering self, unsigned int cluster_index) -> IMP::Ints const &"""
        return _IMP_statistics.PartitionalClustering_get_cluster(self, cluster_index)


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

    __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)


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

PartitionalClustering_swigregister = _IMP_statistics.PartitionalClustering_swigregister
PartitionalClustering_swigregister(PartitionalClustering)


def validate_partitional_clustering(pc, n):
    """validate_partitional_clustering(PartitionalClustering pc, unsigned int n)"""
    return _IMP_statistics.validate_partitional_clustering(pc, n)
class Embedding(IMP.Object):
    """Proxy of C++ IMP::statistics::Embedding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, name):
        """__init__(IMP::statistics::Embedding self, std::string name) -> Embedding"""
        if self.__class__ == Embedding:
            _self = None
        else:
            _self = self
        this = _IMP_statistics.new_Embedding(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Embedding:
            _director_objects.register(self)




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


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


    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, i):
        """get_weight(Embedding self, unsigned int i) -> double"""
        return _IMP_statistics.Embedding_get_weight(self, i)


    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)


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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Embedding(o)

    __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)

    def do_destroy(self):
        """do_destroy(Embedding self)"""
        return _IMP_statistics.Embedding_do_destroy(self)

Embedding_swigregister = _IMP_statistics.Embedding_swigregister
Embedding_swigregister(Embedding)

class Metric(IMP.Object):
    """Proxy of C++ IMP::statistics::Metric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, name):
        """__init__(IMP::statistics::Metric self, std::string name) -> Metric"""
        if self.__class__ == Metric:
            _self = None
        else:
            _self = self
        this = _IMP_statistics.new_Metric(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Metric:
            _director_objects.register(self)




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


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


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


    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)


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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Metric(o)

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

    def do_destroy(self):
        """do_destroy(Metric self)"""
        return _IMP_statistics.Metric_do_destroy(self)

Metric_swigregister = _IMP_statistics.Metric_swigregister
Metric_swigregister(Metric)

class ChiSquareMetric(Metric):
    """Proxy of C++ IMP::statistics::ChiSquareMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, data_exp, constr_type=0):
        """
        __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(data_exp, constr_type)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_configuration(self, data, stddev, weight=1.0):
        """
        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, data, stddev, weight)


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


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


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


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


    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)


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

ChiSquareMetric_swigregister = _IMP_statistics.ChiSquareMetric_swigregister
ChiSquareMetric_swigregister(ChiSquareMetric)

class PartitionalClusteringWithCenter(PartitionalClustering):
    """Proxy of C++ IMP::statistics::PartitionalClusteringWithCenter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

    def get_cluster_center(self, i):
        """get_cluster_center(PartitionalClusteringWithCenter self, unsigned int i) -> VectorKD"""
        return _IMP_statistics.PartitionalClusteringWithCenter_get_cluster_center(self, i)


    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)


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

PartitionalClusteringWithCenter_swigregister = _IMP_statistics.PartitionalClusteringWithCenter_swigregister
PartitionalClusteringWithCenter_swigregister(PartitionalClusteringWithCenter)

class ConfigurationSetXYZEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::ConfigurationSetXYZEmbedding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, cs, pi, align=False):
        """
        __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(cs, pi, align)
        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)


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

ConfigurationSetXYZEmbedding_swigregister = _IMP_statistics.ConfigurationSetXYZEmbedding_swigregister
ConfigurationSetXYZEmbedding_swigregister(ConfigurationSetXYZEmbedding)

class ParticleEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::ParticleEmbedding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::statistics::ParticleEmbedding self, IMP::ParticlesTemp const & ps, IMP::FloatKeys const & ks, bool rescale=False) -> ParticleEmbedding
        __init__(IMP::statistics::ParticleEmbedding self, IMP::ParticlesTemp const & ps, IMP::FloatKeys const & ks) -> ParticleEmbedding
        __init__(IMP::statistics::ParticleEmbedding self, IMP::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)


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

ParticleEmbedding_swigregister = _IMP_statistics.ParticleEmbedding_swigregister
ParticleEmbedding_swigregister(ParticleEmbedding)

class VectorDEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::VectorDEmbedding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

VectorDEmbedding_swigregister = _IMP_statistics.VectorDEmbedding_swigregister
VectorDEmbedding_swigregister(VectorDEmbedding)

class EuclideanMetric(Metric):
    """Proxy of C++ IMP::statistics::EuclideanMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, em):
        """__init__(IMP::statistics::EuclideanMetric self, Embedding em) -> EuclideanMetric"""
        this = _IMP_statistics.new_EuclideanMetric(em)
        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)


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

EuclideanMetric_swigregister = _IMP_statistics.EuclideanMetric_swigregister
EuclideanMetric_swigregister(EuclideanMetric)

class ConfigurationSetRMSDMetric(Metric):
    """Proxy of C++ IMP::statistics::ConfigurationSetRMSDMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, cs, sc, align=False):
        """
        __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(cs, sc, align)
        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)


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

ConfigurationSetRMSDMetric_swigregister = _IMP_statistics.ConfigurationSetRMSDMetric_swigregister
ConfigurationSetRMSDMetric_swigregister(ConfigurationSetRMSDMetric)


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

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

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(d, maximum_diameter):
    """create_diameter_clustering(Metric d, double maximum_diameter) -> PartitionalClustering"""
    return _IMP_statistics.create_diameter_clustering(d, maximum_diameter)

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(d, cutoff):
    """create_gromos_clustering(Metric d, double cutoff) -> PartitionalClustering"""
    return _IMP_statistics.create_gromos_clustering(d, cutoff)

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

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

def get_representatives(d, pc):
    """get_representatives(Embedding d, PartitionalClustering pc) -> IMP::Ints"""
    return _IMP_statistics.get_representatives(d, pc)
class RecursivePartitionalClusteringEmbedding(Embedding):
    """Proxy of C++ IMP::statistics::RecursivePartitionalClusteringEmbedding class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, metric, clustering):
        """__init__(IMP::statistics::RecursivePartitionalClusteringEmbedding self, Embedding metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringEmbedding"""
        this = _IMP_statistics.new_RecursivePartitionalClusteringEmbedding(metric, clustering)
        try:
            self.this.append(this)
        except:
            self.this = this

    def create_full_clustering(self, center_cluster):
        """create_full_clustering(RecursivePartitionalClusteringEmbedding self, PartitionalClustering center_cluster) -> PartitionalClustering"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding_create_full_clustering(self, center_cluster)


    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)


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

RecursivePartitionalClusteringEmbedding_swigregister = _IMP_statistics.RecursivePartitionalClusteringEmbedding_swigregister
RecursivePartitionalClusteringEmbedding_swigregister(RecursivePartitionalClusteringEmbedding)

class RecursivePartitionalClusteringMetric(Metric):
    """Proxy of C++ IMP::statistics::RecursivePartitionalClusteringMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, metric, clustering):
        """__init__(IMP::statistics::RecursivePartitionalClusteringMetric self, Metric metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringMetric"""
        this = _IMP_statistics.new_RecursivePartitionalClusteringMetric(metric, clustering)
        try:
            self.this.append(this)
        except:
            self.this = this

    def create_full_clustering(self, center_cluster):
        """create_full_clustering(RecursivePartitionalClusteringMetric self, PartitionalClustering center_cluster) -> PartitionalClustering"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric_create_full_clustering(self, center_cluster)


    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)


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

RecursivePartitionalClusteringMetric_swigregister = _IMP_statistics.RecursivePartitionalClusteringMetric_swigregister
RecursivePartitionalClusteringMetric_swigregister(RecursivePartitionalClusteringMetric)

class Histogram1D(IMP.algebra._GeometricPrimitive1D):
    """Proxy of C++ IMP::statistics::HistogramD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram1D self, Vector1D x, double weight=1)
        add(Histogram1D self, Vector1D x)
        """
        return _IMP_statistics.Histogram1D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram1D self, Vector1D mean) -> Vector1D"""
        return _IMP_statistics.Histogram1D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram1D self, Histogram1D arg2) -> int"""
        return _IMP_statistics.Histogram1D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram1D self, Histogram1D arg2) -> bool"""
        return _IMP_statistics.Histogram1D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram2D self, Vector2D x, double weight=1)
        add(Histogram2D self, Vector2D x)
        """
        return _IMP_statistics.Histogram2D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram2D self, Vector2D mean) -> Vector2D"""
        return _IMP_statistics.Histogram2D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram2D self, Histogram2D arg2) -> int"""
        return _IMP_statistics.Histogram2D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram2D self, Histogram2D arg2) -> bool"""
        return _IMP_statistics.Histogram2D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram3D self, Vector3D x, double weight=1)
        add(Histogram3D self, Vector3D x)
        """
        return _IMP_statistics.Histogram3D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram3D self, Vector3D mean) -> Vector3D"""
        return _IMP_statistics.Histogram3D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram3D self, Histogram3D arg2) -> int"""
        return _IMP_statistics.Histogram3D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram3D self, Histogram3D arg2) -> bool"""
        return _IMP_statistics.Histogram3D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram4D self, Vector4D x, double weight=1)
        add(Histogram4D self, Vector4D x)
        """
        return _IMP_statistics.Histogram4D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram4D self, Vector4D mean) -> Vector4D"""
        return _IMP_statistics.Histogram4D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram4D self, Histogram4D arg2) -> int"""
        return _IMP_statistics.Histogram4D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram4D self, Histogram4D arg2) -> bool"""
        return _IMP_statistics.Histogram4D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram5D self, Vector5D x, double weight=1)
        add(Histogram5D self, Vector5D x)
        """
        return _IMP_statistics.Histogram5D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram5D self, Vector5D mean) -> Vector5D"""
        return _IMP_statistics.Histogram5D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram5D self, Histogram5D arg2) -> int"""
        return _IMP_statistics.Histogram5D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram5D self, Histogram5D arg2) -> bool"""
        return _IMP_statistics.Histogram5D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(Histogram6D self, Vector6D x, double weight=1)
        add(Histogram6D self, Vector6D x)
        """
        return _IMP_statistics.Histogram6D_add(self, x, weight)


    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, mean):
        """get_standard_deviation(Histogram6D self, Vector6D mean) -> Vector6D"""
        return _IMP_statistics.Histogram6D_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(Histogram6D self, Histogram6D arg2) -> int"""
        return _IMP_statistics.Histogram6D___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(Histogram6D self, Histogram6D arg2) -> bool"""
        return _IMP_statistics.Histogram6D___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x, weight=1):
        """
        add(HistogramKD self, VectorKD x, double weight=1)
        add(HistogramKD self, VectorKD x)
        """
        return _IMP_statistics.HistogramKD_add(self, x, weight)


    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, mean):
        """get_standard_deviation(HistogramKD self, VectorKD mean) -> VectorKD"""
        return _IMP_statistics.HistogramKD_get_standard_deviation(self, mean)


    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)
        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, arg2):
        """__cmp__(HistogramKD self, HistogramKD arg2) -> int"""
        return _IMP_statistics.HistogramKD___cmp__(self, arg2)


    def __eq__(self, arg2):
        """__eq__(HistogramKD self, HistogramKD arg2) -> bool"""
        return _IMP_statistics.HistogramKD___eq__(self, arg2)

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorageKD self, _ostream out)
        show(_IntDenseGridStorageKD self)
        """
        return _IMP_statistics._IntDenseGridStorageKD_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorageKD self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorageKD
        __init__(IMP::algebra::DenseGridStorageD<(-1,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorageKD self, _ostream out)
        show(_FloatDenseGridStorageKD self)
        """
        return _IMP_statistics._FloatDenseGridStorageKD_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorageKD self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, VectorKD sides, BoundingBoxKD bb, double const & default_value) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, VectorKD sides, 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) -> _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, VectorKD sides, VectorKD origin, double const & default_value) -> _HistogramCountsGridKD
        __init__(IMP::algebra::GridD<(-1,IMP::algebra::DenseGridStorageD<(-1,double)>,double,IMP::algebra::DefaultEmbeddingD<(-1)>)> self, VectorKD sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGridKD self, VectorKD pt, double const & vt) -> GridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGridKD self, BoundingBoxKD bb3)"""
        return _IMP_statistics._HistogramCountsGridKD_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage1D self, _ostream out)
        show(_IntDenseGridStorage1D self)
        """
        return _IMP_statistics._IntDenseGridStorage1D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage1D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage1D
        __init__(IMP::algebra::DenseGridStorageD<(1,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage1D self, _ostream out)
        show(_FloatDenseGridStorage1D self)
        """
        return _IMP_statistics._FloatDenseGridStorage1D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage1D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector1D sides, BoundingBox1D bb, double const & default_value) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, Vector1D sides, 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) -> _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, Vector1D sides, Vector1D origin, double const & default_value) -> _HistogramCountsGrid1D
        __init__(IMP::algebra::GridD<(1,IMP::algebra::DenseGridStorageD<(1,double)>,double,IMP::algebra::DefaultEmbeddingD<(1)>)> self, Vector1D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid1D self, Vector1D pt, double const & vt) -> GridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid1D self, BoundingBox1D bb3)"""
        return _IMP_statistics._HistogramCountsGrid1D_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage2D self, _ostream out)
        show(_IntDenseGridStorage2D self)
        """
        return _IMP_statistics._IntDenseGridStorage2D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage2D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage2D
        __init__(IMP::algebra::DenseGridStorageD<(2,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage2D self, _ostream out)
        show(_FloatDenseGridStorage2D self)
        """
        return _IMP_statistics._FloatDenseGridStorage2D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage2D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector2D sides, BoundingBox2D bb, double const & default_value) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, Vector2D sides, 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) -> _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, Vector2D sides, Vector2D origin, double const & default_value) -> _HistogramCountsGrid2D
        __init__(IMP::algebra::GridD<(2,IMP::algebra::DenseGridStorageD<(2,double)>,double,IMP::algebra::DefaultEmbeddingD<(2)>)> self, Vector2D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid2D self, Vector2D pt, double const & vt) -> GridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid2D self, BoundingBox2D bb3)"""
        return _IMP_statistics._HistogramCountsGrid2D_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage3D self, _ostream out)
        show(_IntDenseGridStorage3D self)
        """
        return _IMP_statistics._IntDenseGridStorage3D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage3D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage3D
        __init__(IMP::algebra::DenseGridStorageD<(3,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage3D self, _ostream out)
        show(_FloatDenseGridStorage3D self)
        """
        return _IMP_statistics._FloatDenseGridStorage3D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage3D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector3D sides, BoundingBox3D bb, double const & default_value) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, Vector3D sides, 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) -> _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, Vector3D sides, Vector3D origin, double const & default_value) -> _HistogramCountsGrid3D
        __init__(IMP::algebra::GridD<(3,IMP::algebra::DenseGridStorageD<(3,double)>,double,IMP::algebra::DefaultEmbeddingD<(3)>)> self, Vector3D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid3D self, Vector3D pt, double const & vt) -> GridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid3D self, BoundingBox3D bb3)"""
        return _IMP_statistics._HistogramCountsGrid3D_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage4D self, _ostream out)
        show(_IntDenseGridStorage4D self)
        """
        return _IMP_statistics._IntDenseGridStorage4D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage4D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage4D
        __init__(IMP::algebra::DenseGridStorageD<(4,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage4D self, _ostream out)
        show(_FloatDenseGridStorage4D self)
        """
        return _IMP_statistics._FloatDenseGridStorage4D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage4D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector4D sides, BoundingBox4D bb, double const & default_value) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, Vector4D sides, 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) -> _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, Vector4D sides, Vector4D origin, double const & default_value) -> _HistogramCountsGrid4D
        __init__(IMP::algebra::GridD<(4,IMP::algebra::DenseGridStorageD<(4,double)>,double,IMP::algebra::DefaultEmbeddingD<(4)>)> self, Vector4D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid4D self, Vector4D pt, double const & vt) -> GridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid4D self, BoundingBox4D bb3)"""
        return _IMP_statistics._HistogramCountsGrid4D_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage5D self, _ostream out)
        show(_IntDenseGridStorage5D self)
        """
        return _IMP_statistics._IntDenseGridStorage5D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage5D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage5D
        __init__(IMP::algebra::DenseGridStorageD<(5,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage5D self, _ostream out)
        show(_FloatDenseGridStorage5D self)
        """
        return _IMP_statistics._FloatDenseGridStorage5D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage5D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector5D sides, BoundingBox5D bb, double const & default_value) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, Vector5D sides, 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) -> _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, Vector5D sides, Vector5D origin, double const & default_value) -> _HistogramCountsGrid5D
        __init__(IMP::algebra::GridD<(5,IMP::algebra::DenseGridStorageD<(5,double)>,double,IMP::algebra::DefaultEmbeddingD<(5)>)> self, Vector5D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid5D self, Vector5D pt, double const & vt) -> GridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid5D self, BoundingBox5D bb3)"""
        return _IMP_statistics._HistogramCountsGrid5D_set_bounding_box(self, bb3)


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


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, IMP::Ints const & counts) -> _IntDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,int)> self, int const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_IntDenseGridStorage6D self, _ostream out)
        show(_IntDenseGridStorage6D self)
        """
        return _IMP_statistics._IntDenseGridStorage6D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_IntDenseGridStorage6D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, IMP::Ints const & counts) -> _FloatDenseGridStorage6D
        __init__(IMP::algebra::DenseGridStorageD<(6,double)> self, double const & default_value) -> _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()

    get_is_dense = staticmethod(get_is_dense)

    def show(self, *args):
        """
        show(_FloatDenseGridStorage6D self, _ostream out)
        show(_FloatDenseGridStorage6D self)
        """
        return _IMP_statistics._FloatDenseGridStorage6D_show(self, *args)


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


    def get_all_voxels(self):
        """get_all_voxels(_FloatDenseGridStorage6D self) -> IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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) -> _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) -> _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, Vector6D sides, BoundingBox6D bb, double const & default_value) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, Vector6D sides, 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) -> _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, Vector6D sides, Vector6D origin, double const & default_value) -> _HistogramCountsGrid6D
        __init__(IMP::algebra::GridD<(6,IMP::algebra::DenseGridStorageD<(6,double)>,double,IMP::algebra::DefaultEmbeddingD<(6)>)> self, Vector6D sides, 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)
        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, pt, vt):
        """add_voxel(_HistogramCountsGrid6D self, Vector6D pt, double const & vt) -> GridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_add_voxel(self, pt, vt)


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


    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, bb3):
        """set_bounding_box(_HistogramCountsGrid6D self, BoundingBox6D bb3)"""
        return _IMP_statistics._HistogramCountsGrid6D_set_bounding_box(self, bb3)


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


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

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


from . 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(fname):
    """get_example_path(std::string fname) -> std::string"""
    return _IMP_statistics.get_example_path(fname)

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_statistics.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()