statistics/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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-2024 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import



from sys import version_info as _swig_python_version_info
import _IMP_statistics

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IMP_STATISTICS_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_STATISTICS_SwigPyIterator class."""

    thisown = 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

    def value(self):
        r"""value(IMP_STATISTICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_statistics.IMP_STATISTICS_SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register IMP_STATISTICS_SwigPyIterator in _IMP_statistics:
_IMP_statistics.IMP_STATISTICS_SwigPyIterator_swigregister(IMP_STATISTICS_SwigPyIterator)

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

IMP_DEBUG = _IMP_statistics.IMP_DEBUG

IMP_RELEASE = _IMP_statistics.IMP_RELEASE

IMP_SILENT = _IMP_statistics.IMP_SILENT

IMP_PROGRESS = _IMP_statistics.IMP_PROGRESS

IMP_TERSE = _IMP_statistics.IMP_TERSE

IMP_VERBOSE = _IMP_statistics.IMP_VERBOSE

IMP_MEMORY = _IMP_statistics.IMP_MEMORY

IMP_NONE = _IMP_statistics.IMP_NONE

IMP_USAGE = _IMP_statistics.IMP_USAGE

IMP_INTERNAL = _IMP_statistics.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_statistics.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_statistics.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_statistics.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_statistics.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_statistics.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_statistics.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_statistics.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_statistics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

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):
    r"""Proxy of C++ std::ostream class."""

    thisown = 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):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_statistics._ostream_write(self, osa_buf)

# Register _ostream in _IMP_statistics:
_IMP_statistics._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_statistics.IMP_C_OPEN_BINARY

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_statistics.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_statistics.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_statistics.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_statistics.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_statistics.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_statistics.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_statistics.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_statistics.IMP_STATISTICS_HAS_BOOST_SYSTEM

IMP_STATISTICS_HAS_CGAL = _IMP_statistics.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_statistics.IMP_STATISTICS_HAS_NUMPY

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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_ChiSquareMetric(Object o) -> ChiSquareMetric"""
    return _IMP_statistics._object_cast_to_ChiSquareMetric(o)
class PartitionalClustering(IMP.Object):
    r"""Proxy of C++ IMP::statistics::PartitionalClustering class."""

    thisown = 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):
        r"""get_number_of_clusters(PartitionalClustering self) -> unsigned int"""
        return _IMP_statistics.PartitionalClustering_get_number_of_clusters(self)

    def get_cluster(self, cluster_index):
        r"""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):
        r"""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

    def __str__(self):
        r"""__str__(PartitionalClustering self) -> std::string"""
        return _IMP_statistics.PartitionalClustering___str__(self)

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

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


# Register PartitionalClustering in _IMP_statistics:
_IMP_statistics.PartitionalClustering_swigregister(PartitionalClustering)

def validate_partitional_clustering(pc, n):
    r"""validate_partitional_clustering(PartitionalClustering pc, unsigned int n)"""
    return _IMP_statistics.validate_partitional_clustering(pc, n)
class Embedding(IMP.Object):
    r"""Proxy of C++ IMP::statistics::Embedding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, name):
        r"""__init__(Embedding self, std::string name) -> Embedding"""
        if self.__class__ == Embedding:
            _self = None
        else:
            _self = self
        _IMP_statistics.Embedding_swiginit(self, _IMP_statistics.new_Embedding(_self, name))

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




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

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

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

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

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

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

    def __repr__(self):
        r"""__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
    def __disown__(self):
        self.this.disown()
        _IMP_statistics.disown_Embedding(self)
        return weakref.proxy(self)

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

# Register Embedding in _IMP_statistics:
_IMP_statistics.Embedding_swigregister(Embedding)
class Metric(IMP.Object):
    r"""Proxy of C++ IMP::statistics::Metric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, name):
        r"""__init__(Metric self, std::string name) -> Metric"""
        if self.__class__ == Metric:
            _self = None
        else:
            _self = self
        _IMP_statistics.Metric_swiginit(self, _IMP_statistics.new_Metric(_self, name))

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




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

    def get_distance(self, i, j):
        r"""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):
        r"""get_weight(Metric self, unsigned int i) -> double"""
        return _IMP_statistics.Metric_get_weight(self, i)

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

    def __str__(self):
        r"""__str__(Metric self) -> std::string"""
        return _IMP_statistics.Metric___str__(self)

    def __repr__(self):
        r"""__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):
        r"""do_destroy(Metric self)"""
        return _IMP_statistics.Metric_do_destroy(self)

# Register Metric in _IMP_statistics:
_IMP_statistics.Metric_swigregister(Metric)
class ChiSquareMetric(Metric):
    r"""Proxy of C++ IMP::statistics::ChiSquareMetric class."""

    thisown = 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):
        r"""__init__(ChiSquareMetric self, IMP::Floats data_exp, int constr_type=0) -> ChiSquareMetric"""
        _IMP_statistics.ChiSquareMetric_swiginit(self, _IMP_statistics.new_ChiSquareMetric(data_exp, constr_type))

    def add_configuration(self, data, stddev, weight=1.0):
        r"""add_configuration(ChiSquareMetric self, IMP::Floats data, IMP::Floats stddev, double weight=1.0)"""
        return _IMP_statistics.ChiSquareMetric_add_configuration(self, data, stddev, weight)

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

    def get_standard_deviation(self, i):
        r"""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):
        r"""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):
        r"""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):
        r"""get_version_info(ChiSquareMetric self) -> VersionInfo"""
        return _IMP_statistics.ChiSquareMetric_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_ChiSquareMetric

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

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

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


# Register ChiSquareMetric in _IMP_statistics:
_IMP_statistics.ChiSquareMetric_swigregister(ChiSquareMetric)
class PartitionalClusteringWithCenter(PartitionalClustering):
    r"""Proxy of C++ IMP::statistics::PartitionalClusteringWithCenter class."""

    thisown = 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):
        r"""get_cluster_center(PartitionalClusteringWithCenter self, unsigned int i) -> VectorKD"""
        return _IMP_statistics.PartitionalClusteringWithCenter_get_cluster_center(self, i)

    def get_version_info(self):
        r"""get_version_info(PartitionalClusteringWithCenter self) -> VersionInfo"""
        return _IMP_statistics.PartitionalClusteringWithCenter_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_PartitionalClusteringWithCenter

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

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

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


# Register PartitionalClusteringWithCenter in _IMP_statistics:
_IMP_statistics.PartitionalClusteringWithCenter_swigregister(PartitionalClusteringWithCenter)
class ConfigurationSetXYZEmbedding(Embedding):
    r"""Proxy of C++ IMP::statistics::ConfigurationSetXYZEmbedding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, cs, pi, align=False):
        r"""__init__(ConfigurationSetXYZEmbedding self, ConfigurationSet cs, _SingletonContainerAdaptor pi, bool align=False) -> ConfigurationSetXYZEmbedding"""
        _IMP_statistics.ConfigurationSetXYZEmbedding_swiginit(self, _IMP_statistics.new_ConfigurationSetXYZEmbedding(cs, pi, align))

    def get_version_info(self):
        r"""get_version_info(ConfigurationSetXYZEmbedding self) -> VersionInfo"""
        return _IMP_statistics.ConfigurationSetXYZEmbedding_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_ConfigurationSetXYZEmbedding

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

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

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


# Register ConfigurationSetXYZEmbedding in _IMP_statistics:
_IMP_statistics.ConfigurationSetXYZEmbedding_swigregister(ConfigurationSetXYZEmbedding)
class ParticleEmbedding(Embedding):
    r"""Proxy of C++ IMP::statistics::ParticleEmbedding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ParticleEmbedding self, IMP::ParticlesTemp const & ps, IMP::FloatKeys const & ks=IMP::FloatKeys(
                                                                 IMP::internal::
                                                                     xyzr_keys,
                                                                 IMP::internal::
                                                                         xyzr_keys +
                                                                     3), bool rescale=False) -> ParticleEmbedding
        """
        _IMP_statistics.ParticleEmbedding_swiginit(self, _IMP_statistics.new_ParticleEmbedding(*args))

    def get_version_info(self):
        r"""get_version_info(ParticleEmbedding self) -> VersionInfo"""
        return _IMP_statistics.ParticleEmbedding_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_ParticleEmbedding

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

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

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


# Register ParticleEmbedding in _IMP_statistics:
_IMP_statistics.ParticleEmbedding_swigregister(ParticleEmbedding)
class VectorDEmbedding(Embedding):
    r"""Proxy of C++ IMP::statistics::VectorDEmbedding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(VectorDEmbedding self, IMP::algebra::VectorKDs const & vs) -> VectorDEmbedding
        __init__(VectorDEmbedding self, IMP::algebra::Vector2Ds const & vs) -> VectorDEmbedding
        __init__(VectorDEmbedding self, IMP::algebra::Vector3Ds const & vs) -> VectorDEmbedding
        __init__(VectorDEmbedding self, IMP::algebra::Vector4Ds const & vs) -> VectorDEmbedding
        __init__(VectorDEmbedding self, IMP::algebra::Vector5Ds const & vs) -> VectorDEmbedding
        __init__(VectorDEmbedding self, IMP::algebra::Vector6Ds const & vs) -> VectorDEmbedding
        """
        _IMP_statistics.VectorDEmbedding_swiginit(self, _IMP_statistics.new_VectorDEmbedding(*args))

    def get_version_info(self):
        r"""get_version_info(VectorDEmbedding self) -> VersionInfo"""
        return _IMP_statistics.VectorDEmbedding_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_VectorDEmbedding

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

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

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


# Register VectorDEmbedding in _IMP_statistics:
_IMP_statistics.VectorDEmbedding_swigregister(VectorDEmbedding)
class EuclideanMetric(Metric):
    r"""Proxy of C++ IMP::statistics::EuclideanMetric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, em):
        r"""__init__(EuclideanMetric self, Embedding em) -> EuclideanMetric"""
        _IMP_statistics.EuclideanMetric_swiginit(self, _IMP_statistics.new_EuclideanMetric(em))

    def get_version_info(self):
        r"""get_version_info(EuclideanMetric self) -> VersionInfo"""
        return _IMP_statistics.EuclideanMetric_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_EuclideanMetric

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

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

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


# Register EuclideanMetric in _IMP_statistics:
_IMP_statistics.EuclideanMetric_swigregister(EuclideanMetric)
class ConfigurationSetRMSDMetric(Metric):
    r"""Proxy of C++ IMP::statistics::ConfigurationSetRMSDMetric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, cs, sc, align=False):
        r"""__init__(ConfigurationSetRMSDMetric self, ConfigurationSet cs, SingletonContainer sc, bool align=False) -> ConfigurationSetRMSDMetric"""
        _IMP_statistics.ConfigurationSetRMSDMetric_swiginit(self, _IMP_statistics.new_ConfigurationSetRMSDMetric(cs, sc, align))

    def get_version_info(self):
        r"""get_version_info(ConfigurationSetRMSDMetric self) -> VersionInfo"""
        return _IMP_statistics.ConfigurationSetRMSDMetric_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_ConfigurationSetRMSDMetric

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

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

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


# Register ConfigurationSetRMSDMetric in _IMP_statistics:
_IMP_statistics.ConfigurationSetRMSDMetric_swigregister(ConfigurationSetRMSDMetric)

def create_lloyds_kmeans(embedding, k, iterations):
    r"""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):
    r"""create_bin_based_clustering(Embedding embed, double side) -> PartitionalClusteringWithCenter"""
    return _IMP_statistics.create_bin_based_clustering(embed, side)

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

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

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

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

def get_representatives(d, pc):
    r"""get_representatives(Embedding d, PartitionalClustering pc) -> IMP::Ints"""
    return _IMP_statistics.get_representatives(d, pc)
class RecursivePartitionalClusteringEmbedding(Embedding):
    r"""Proxy of C++ IMP::statistics::RecursivePartitionalClusteringEmbedding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, metric, clustering):
        r"""__init__(RecursivePartitionalClusteringEmbedding self, Embedding metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringEmbedding"""
        _IMP_statistics.RecursivePartitionalClusteringEmbedding_swiginit(self, _IMP_statistics.new_RecursivePartitionalClusteringEmbedding(metric, clustering))

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

    def get_version_info(self):
        r"""get_version_info(RecursivePartitionalClusteringEmbedding self) -> VersionInfo"""
        return _IMP_statistics.RecursivePartitionalClusteringEmbedding_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_RecursivePartitionalClusteringEmbedding

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

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

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


# Register RecursivePartitionalClusteringEmbedding in _IMP_statistics:
_IMP_statistics.RecursivePartitionalClusteringEmbedding_swigregister(RecursivePartitionalClusteringEmbedding)
class RecursivePartitionalClusteringMetric(Metric):
    r"""Proxy of C++ IMP::statistics::RecursivePartitionalClusteringMetric class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, metric, clustering):
        r"""__init__(RecursivePartitionalClusteringMetric self, Metric metric, PartitionalClustering clustering) -> RecursivePartitionalClusteringMetric"""
        _IMP_statistics.RecursivePartitionalClusteringMetric_swiginit(self, _IMP_statistics.new_RecursivePartitionalClusteringMetric(metric, clustering))

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

    def get_version_info(self):
        r"""get_version_info(RecursivePartitionalClusteringMetric self) -> VersionInfo"""
        return _IMP_statistics.RecursivePartitionalClusteringMetric_get_version_info(self)
    __swig_destroy__ = _IMP_statistics.delete_RecursivePartitionalClusteringMetric

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

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

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


# Register RecursivePartitionalClusteringMetric in _IMP_statistics:
_IMP_statistics.RecursivePartitionalClusteringMetric_swigregister(RecursivePartitionalClusteringMetric)
class Histogram1D(IMP.algebra._GeometricPrimitive1D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 1 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram1D self) -> Histogram1D
        __init__(Histogram1D self, double voxel_size, BoundingBox1D bb) -> Histogram1D
        """
        _IMP_statistics.Histogram1D_swiginit(self, _IMP_statistics.new_Histogram1D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram1D self, Vector1D x, double weight=1)"""
        return _IMP_statistics.Histogram1D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram1D in _IMP_statistics:
_IMP_statistics.Histogram1D_swigregister(Histogram1D)
class Histogram2D(IMP.algebra._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 2 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram2D self) -> Histogram2D
        __init__(Histogram2D self, double voxel_size, BoundingBox2D bb) -> Histogram2D
        """
        _IMP_statistics.Histogram2D_swiginit(self, _IMP_statistics.new_Histogram2D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram2D self, Vector2D x, double weight=1)"""
        return _IMP_statistics.Histogram2D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram2D in _IMP_statistics:
_IMP_statistics.Histogram2D_swigregister(Histogram2D)
class Histogram3D(IMP.algebra._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 3 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram3D self) -> Histogram3D
        __init__(Histogram3D self, double voxel_size, BoundingBox3D bb) -> Histogram3D
        """
        _IMP_statistics.Histogram3D_swiginit(self, _IMP_statistics.new_Histogram3D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram3D self, Vector3D x, double weight=1)"""
        return _IMP_statistics.Histogram3D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram3D in _IMP_statistics:
_IMP_statistics.Histogram3D_swigregister(Histogram3D)
class Histogram4D(IMP.algebra._GeometricPrimitive4D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 4 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram4D self) -> Histogram4D
        __init__(Histogram4D self, double voxel_size, BoundingBox4D bb) -> Histogram4D
        """
        _IMP_statistics.Histogram4D_swiginit(self, _IMP_statistics.new_Histogram4D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram4D self, Vector4D x, double weight=1)"""
        return _IMP_statistics.Histogram4D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram4D in _IMP_statistics:
_IMP_statistics.Histogram4D_swigregister(Histogram4D)
class Histogram5D(IMP.algebra._GeometricPrimitive5D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 5 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram5D self) -> Histogram5D
        __init__(Histogram5D self, double voxel_size, BoundingBox5D bb) -> Histogram5D
        """
        _IMP_statistics.Histogram5D_swiginit(self, _IMP_statistics.new_Histogram5D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram5D self, Vector5D x, double weight=1)"""
        return _IMP_statistics.Histogram5D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram5D in _IMP_statistics:
_IMP_statistics.Histogram5D_swigregister(Histogram5D)
class Histogram6D(IMP.algebra._GeometricPrimitive6D):
    r"""Proxy of C++ IMP::statistics::HistogramD< 6 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Histogram6D self) -> Histogram6D
        __init__(Histogram6D self, double voxel_size, BoundingBox6D bb) -> Histogram6D
        """
        _IMP_statistics.Histogram6D_swiginit(self, _IMP_statistics.new_Histogram6D(*args))

    def add(self, x, weight=1):
        r"""add(Histogram6D self, Vector6D x, double weight=1)"""
        return _IMP_statistics.Histogram6D_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Histogram6D in _IMP_statistics:
_IMP_statistics.Histogram6D_swigregister(Histogram6D)
class HistogramKD(IMP.algebra._GeometricPrimitiveKD):
    r"""Proxy of C++ IMP::statistics::HistogramD< -1 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HistogramKD self) -> HistogramKD
        __init__(HistogramKD self, double voxel_size, BoundingBoxKD bb) -> HistogramKD
        """
        _IMP_statistics.HistogramKD_swiginit(self, _IMP_statistics.new_HistogramKD(*args))

    def add(self, x, weight=1):
        r"""add(HistogramKD self, VectorKD x, double weight=1)"""
        return _IMP_statistics.HistogramKD_add(self, x, weight)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register HistogramKD in _IMP_statistics:
_IMP_statistics.HistogramKD_swigregister(HistogramKD)
class _IntDenseGridStorageKD(IMP.algebra.BoundedGridRangeKD):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< -1,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorageKD self, _IntDenseGridStorageKD o) -> _IntDenseGridStorageKD
        __init__(_IntDenseGridStorageKD self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorageKD
        __init__(_IntDenseGridStorageKD self, int const & default_value=int()) -> _IntDenseGridStorageKD
        """
        _IMP_statistics._IntDenseGridStorageKD_swiginit(self, _IMP_statistics.new__IntDenseGridStorageKD(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorageKD_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorageKD self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorageKD_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorageKD

# Register _IntDenseGridStorageKD in _IMP_statistics:
_IMP_statistics._IntDenseGridStorageKD_swigregister(_IntDenseGridStorageKD)
class _FloatDenseGridStorageKD(IMP.algebra.BoundedGridRangeKD):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< -1,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorageKD self, _FloatDenseGridStorageKD o) -> _FloatDenseGridStorageKD
        __init__(_FloatDenseGridStorageKD self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorageKD
        __init__(_FloatDenseGridStorageKD self, double const & default_value=double()) -> _FloatDenseGridStorageKD
        """
        _IMP_statistics._FloatDenseGridStorageKD_swiginit(self, _IMP_statistics.new__FloatDenseGridStorageKD(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorageKD_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorageKD self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorageKD_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorageKD

# Register _FloatDenseGridStorageKD in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorageKD_swigregister(_FloatDenseGridStorageKD)
class _HistogramCountsGridKD(_FloatDenseGridStorageKD, IMP.algebra.DefaultEmbeddingKD, IMP.algebra._GeometricPrimitiveKD):
    r"""Proxy of C++ IMP::algebra::GridD< -1,IMP::algebra::DenseGridStorageD< -1,double >,double,IMP::algebra::DefaultEmbeddingD< -1 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGridKD self, IMP::Ints const counts, BoundingBoxKD bb, double default_value=double()) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self, double side, BoundingBoxKD bb, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self, VectorKD sides, BoundingBoxKD bb, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self, _FloatDenseGridStorageKD storage, DefaultEmbeddingKD embed) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self, double side, VectorKD origin, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self, VectorKD sides, VectorKD origin, double const & default_value=double()) -> _HistogramCountsGridKD
        __init__(_HistogramCountsGridKD self) -> _HistogramCountsGridKD
        """
        _IMP_statistics._HistogramCountsGridKD_swiginit(self, _IMP_statistics.new__HistogramCountsGridKD(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGridKD self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGridKD_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGridKD self, GridIndexKD index) -> ExtendedGridIndexKD"""
        return _IMP_statistics._HistogramCountsGridKD_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGridKD in _IMP_statistics:
_IMP_statistics._HistogramCountsGridKD_swigregister(_HistogramCountsGridKD)
class _IntDenseGridStorage1D(IMP.algebra.BoundedGridRange1D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 1,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage1D self, _IntDenseGridStorage1D o) -> _IntDenseGridStorage1D
        __init__(_IntDenseGridStorage1D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage1D
        __init__(_IntDenseGridStorage1D self, int const & default_value=int()) -> _IntDenseGridStorage1D
        """
        _IMP_statistics._IntDenseGridStorage1D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage1D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage1D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage1D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage1D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage1D

# Register _IntDenseGridStorage1D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage1D_swigregister(_IntDenseGridStorage1D)
class _FloatDenseGridStorage1D(IMP.algebra.BoundedGridRange1D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 1,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage1D self, _FloatDenseGridStorage1D o) -> _FloatDenseGridStorage1D
        __init__(_FloatDenseGridStorage1D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage1D
        __init__(_FloatDenseGridStorage1D self, double const & default_value=double()) -> _FloatDenseGridStorage1D
        """
        _IMP_statistics._FloatDenseGridStorage1D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage1D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage1D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage1D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage1D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage1D

# Register _FloatDenseGridStorage1D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage1D_swigregister(_FloatDenseGridStorage1D)
class _HistogramCountsGrid1D(_FloatDenseGridStorage1D, IMP.algebra.DefaultEmbedding1D, IMP.algebra._GeometricPrimitive1D):
    r"""Proxy of C++ IMP::algebra::GridD< 1,IMP::algebra::DenseGridStorageD< 1,double >,double,IMP::algebra::DefaultEmbeddingD< 1 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid1D self, IMP::Ints const counts, BoundingBox1D bb, double default_value=double()) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self, double side, BoundingBox1D bb, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self, Vector1D sides, BoundingBox1D bb, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self, _FloatDenseGridStorage1D storage, DefaultEmbedding1D embed) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self, double side, Vector1D origin, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self, Vector1D sides, Vector1D origin, double const & default_value=double()) -> _HistogramCountsGrid1D
        __init__(_HistogramCountsGrid1D self) -> _HistogramCountsGrid1D
        """
        _IMP_statistics._HistogramCountsGrid1D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid1D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid1D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid1D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid1D self, GridIndex1D index) -> ExtendedGridIndex1D"""
        return _IMP_statistics._HistogramCountsGrid1D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid1D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid1D_swigregister(_HistogramCountsGrid1D)
class _IntDenseGridStorage2D(IMP.algebra.BoundedGridRange2D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 2,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage2D self, _IntDenseGridStorage2D o) -> _IntDenseGridStorage2D
        __init__(_IntDenseGridStorage2D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage2D
        __init__(_IntDenseGridStorage2D self, int const & default_value=int()) -> _IntDenseGridStorage2D
        """
        _IMP_statistics._IntDenseGridStorage2D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage2D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage2D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage2D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage2D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage2D

# Register _IntDenseGridStorage2D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage2D_swigregister(_IntDenseGridStorage2D)
class _FloatDenseGridStorage2D(IMP.algebra.BoundedGridRange2D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 2,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage2D self, _FloatDenseGridStorage2D o) -> _FloatDenseGridStorage2D
        __init__(_FloatDenseGridStorage2D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage2D
        __init__(_FloatDenseGridStorage2D self, double const & default_value=double()) -> _FloatDenseGridStorage2D
        """
        _IMP_statistics._FloatDenseGridStorage2D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage2D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage2D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage2D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage2D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage2D

# Register _FloatDenseGridStorage2D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage2D_swigregister(_FloatDenseGridStorage2D)
class _HistogramCountsGrid2D(_FloatDenseGridStorage2D, IMP.algebra.DefaultEmbedding2D, IMP.algebra._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::GridD< 2,IMP::algebra::DenseGridStorageD< 2,double >,double,IMP::algebra::DefaultEmbeddingD< 2 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid2D self, IMP::Ints const counts, BoundingBox2D bb, double default_value=double()) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self, double side, BoundingBox2D bb, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self, Vector2D sides, BoundingBox2D bb, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self, _FloatDenseGridStorage2D storage, DefaultEmbedding2D embed) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self, double side, Vector2D origin, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self, Vector2D sides, Vector2D origin, double const & default_value=double()) -> _HistogramCountsGrid2D
        __init__(_HistogramCountsGrid2D self) -> _HistogramCountsGrid2D
        """
        _IMP_statistics._HistogramCountsGrid2D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid2D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid2D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid2D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid2D self, GridIndex2D index) -> ExtendedGridIndex2D"""
        return _IMP_statistics._HistogramCountsGrid2D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid2D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid2D_swigregister(_HistogramCountsGrid2D)
class _IntDenseGridStorage3D(IMP.algebra.BoundedGridRange3D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 3,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage3D self, _IntDenseGridStorage3D o) -> _IntDenseGridStorage3D
        __init__(_IntDenseGridStorage3D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage3D
        __init__(_IntDenseGridStorage3D self, int const & default_value=int()) -> _IntDenseGridStorage3D
        """
        _IMP_statistics._IntDenseGridStorage3D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage3D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage3D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage3D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage3D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage3D

# Register _IntDenseGridStorage3D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage3D_swigregister(_IntDenseGridStorage3D)
class _FloatDenseGridStorage3D(IMP.algebra.BoundedGridRange3D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 3,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage3D self, _FloatDenseGridStorage3D o) -> _FloatDenseGridStorage3D
        __init__(_FloatDenseGridStorage3D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage3D
        __init__(_FloatDenseGridStorage3D self, double const & default_value=double()) -> _FloatDenseGridStorage3D
        """
        _IMP_statistics._FloatDenseGridStorage3D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage3D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage3D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage3D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage3D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage3D

# Register _FloatDenseGridStorage3D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage3D_swigregister(_FloatDenseGridStorage3D)
class _HistogramCountsGrid3D(_FloatDenseGridStorage3D, IMP.algebra.DefaultEmbedding3D, IMP.algebra._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,double >,double,IMP::algebra::DefaultEmbeddingD< 3 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid3D self, IMP::Ints const counts, BoundingBox3D bb, double default_value=double()) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self, double side, BoundingBox3D bb, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self, Vector3D sides, BoundingBox3D bb, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self, _FloatDenseGridStorage3D storage, DefaultEmbedding3D embed) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self, double side, Vector3D origin, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self, Vector3D sides, Vector3D origin, double const & default_value=double()) -> _HistogramCountsGrid3D
        __init__(_HistogramCountsGrid3D self) -> _HistogramCountsGrid3D
        """
        _IMP_statistics._HistogramCountsGrid3D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid3D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid3D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid3D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid3D self, GridIndex3D index) -> ExtendedGridIndex3D"""
        return _IMP_statistics._HistogramCountsGrid3D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid3D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid3D_swigregister(_HistogramCountsGrid3D)
class _IntDenseGridStorage4D(IMP.algebra.BoundedGridRange4D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 4,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage4D self, _IntDenseGridStorage4D o) -> _IntDenseGridStorage4D
        __init__(_IntDenseGridStorage4D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage4D
        __init__(_IntDenseGridStorage4D self, int const & default_value=int()) -> _IntDenseGridStorage4D
        """
        _IMP_statistics._IntDenseGridStorage4D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage4D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage4D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage4D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage4D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage4D

# Register _IntDenseGridStorage4D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage4D_swigregister(_IntDenseGridStorage4D)
class _FloatDenseGridStorage4D(IMP.algebra.BoundedGridRange4D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 4,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage4D self, _FloatDenseGridStorage4D o) -> _FloatDenseGridStorage4D
        __init__(_FloatDenseGridStorage4D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage4D
        __init__(_FloatDenseGridStorage4D self, double const & default_value=double()) -> _FloatDenseGridStorage4D
        """
        _IMP_statistics._FloatDenseGridStorage4D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage4D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage4D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage4D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage4D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage4D

# Register _FloatDenseGridStorage4D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage4D_swigregister(_FloatDenseGridStorage4D)
class _HistogramCountsGrid4D(_FloatDenseGridStorage4D, IMP.algebra.DefaultEmbedding4D, IMP.algebra._GeometricPrimitive4D):
    r"""Proxy of C++ IMP::algebra::GridD< 4,IMP::algebra::DenseGridStorageD< 4,double >,double,IMP::algebra::DefaultEmbeddingD< 4 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid4D self, IMP::Ints const counts, BoundingBox4D bb, double default_value=double()) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self, double side, BoundingBox4D bb, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self, Vector4D sides, BoundingBox4D bb, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self, _FloatDenseGridStorage4D storage, DefaultEmbedding4D embed) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self, double side, Vector4D origin, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self, Vector4D sides, Vector4D origin, double const & default_value=double()) -> _HistogramCountsGrid4D
        __init__(_HistogramCountsGrid4D self) -> _HistogramCountsGrid4D
        """
        _IMP_statistics._HistogramCountsGrid4D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid4D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid4D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid4D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid4D self, GridIndex4D index) -> ExtendedGridIndex4D"""
        return _IMP_statistics._HistogramCountsGrid4D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid4D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid4D_swigregister(_HistogramCountsGrid4D)
class _IntDenseGridStorage5D(IMP.algebra.BoundedGridRange5D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 5,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage5D self, _IntDenseGridStorage5D o) -> _IntDenseGridStorage5D
        __init__(_IntDenseGridStorage5D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage5D
        __init__(_IntDenseGridStorage5D self, int const & default_value=int()) -> _IntDenseGridStorage5D
        """
        _IMP_statistics._IntDenseGridStorage5D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage5D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage5D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage5D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage5D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage5D

# Register _IntDenseGridStorage5D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage5D_swigregister(_IntDenseGridStorage5D)
class _FloatDenseGridStorage5D(IMP.algebra.BoundedGridRange5D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 5,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage5D self, _FloatDenseGridStorage5D o) -> _FloatDenseGridStorage5D
        __init__(_FloatDenseGridStorage5D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage5D
        __init__(_FloatDenseGridStorage5D self, double const & default_value=double()) -> _FloatDenseGridStorage5D
        """
        _IMP_statistics._FloatDenseGridStorage5D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage5D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage5D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage5D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage5D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage5D

# Register _FloatDenseGridStorage5D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage5D_swigregister(_FloatDenseGridStorage5D)
class _HistogramCountsGrid5D(_FloatDenseGridStorage5D, IMP.algebra.DefaultEmbedding5D, IMP.algebra._GeometricPrimitive5D):
    r"""Proxy of C++ IMP::algebra::GridD< 5,IMP::algebra::DenseGridStorageD< 5,double >,double,IMP::algebra::DefaultEmbeddingD< 5 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid5D self, IMP::Ints const counts, BoundingBox5D bb, double default_value=double()) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self, double side, BoundingBox5D bb, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self, Vector5D sides, BoundingBox5D bb, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self, _FloatDenseGridStorage5D storage, DefaultEmbedding5D embed) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self, double side, Vector5D origin, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self, Vector5D sides, Vector5D origin, double const & default_value=double()) -> _HistogramCountsGrid5D
        __init__(_HistogramCountsGrid5D self) -> _HistogramCountsGrid5D
        """
        _IMP_statistics._HistogramCountsGrid5D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid5D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid5D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid5D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid5D self, GridIndex5D index) -> ExtendedGridIndex5D"""
        return _IMP_statistics._HistogramCountsGrid5D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid5D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid5D_swigregister(_HistogramCountsGrid5D)
class _IntDenseGridStorage6D(IMP.algebra.BoundedGridRange6D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 6,int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_IntDenseGridStorage6D self, _IntDenseGridStorage6D o) -> _IntDenseGridStorage6D
        __init__(_IntDenseGridStorage6D self, IMP::Ints const & counts, int const & default_value=int()) -> _IntDenseGridStorage6D
        __init__(_IntDenseGridStorage6D self, int const & default_value=int()) -> _IntDenseGridStorage6D
        """
        _IMP_statistics._IntDenseGridStorage6D_swiginit(self, _IMP_statistics.new__IntDenseGridStorage6D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._IntDenseGridStorage6D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_IntDenseGridStorage6D self) -> IMP::Vector< int >"""
        return _IMP_statistics._IntDenseGridStorage6D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__IntDenseGridStorage6D

# Register _IntDenseGridStorage6D in _IMP_statistics:
_IMP_statistics._IntDenseGridStorage6D_swigregister(_IntDenseGridStorage6D)
class _FloatDenseGridStorage6D(IMP.algebra.BoundedGridRange6D):
    r"""Proxy of C++ IMP::algebra::DenseGridStorageD< 6,double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""
        __init__(_FloatDenseGridStorage6D self, _FloatDenseGridStorage6D o) -> _FloatDenseGridStorage6D
        __init__(_FloatDenseGridStorage6D self, IMP::Ints const & counts, double const & default_value=double()) -> _FloatDenseGridStorage6D
        __init__(_FloatDenseGridStorage6D self, double const & default_value=double()) -> _FloatDenseGridStorage6D
        """
        _IMP_statistics._FloatDenseGridStorage6D_swiginit(self, _IMP_statistics.new__FloatDenseGridStorage6D(*args))

    @staticmethod
    def get_is_dense():
        r"""get_is_dense() -> bool"""
        return _IMP_statistics._FloatDenseGridStorage6D_get_is_dense()

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

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

    def get_all_voxels(self):
        r"""get_all_voxels(_FloatDenseGridStorage6D self) -> IMP::Vector< double >"""
        return _IMP_statistics._FloatDenseGridStorage6D_get_all_voxels(self)
    __swig_destroy__ = _IMP_statistics.delete__FloatDenseGridStorage6D

# Register _FloatDenseGridStorage6D in _IMP_statistics:
_IMP_statistics._FloatDenseGridStorage6D_swigregister(_FloatDenseGridStorage6D)
class _HistogramCountsGrid6D(_FloatDenseGridStorage6D, IMP.algebra.DefaultEmbedding6D, IMP.algebra._GeometricPrimitive6D):
    r"""Proxy of C++ IMP::algebra::GridD< 6,IMP::algebra::DenseGridStorageD< 6,double >,double,IMP::algebra::DefaultEmbeddingD< 6 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(_HistogramCountsGrid6D self, IMP::Ints const counts, BoundingBox6D bb, double default_value=double()) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self, double side, BoundingBox6D bb, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self, Vector6D sides, BoundingBox6D bb, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self, _FloatDenseGridStorage6D storage, DefaultEmbedding6D embed) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self, double side, Vector6D origin, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self, Vector6D sides, Vector6D origin, double const & default_value=double()) -> _HistogramCountsGrid6D
        __init__(_HistogramCountsGrid6D self) -> _HistogramCountsGrid6D
        """
        _IMP_statistics._HistogramCountsGrid6D_swiginit(self, _IMP_statistics.new__HistogramCountsGrid6D(*args))

    def show(self, *args):
        r"""show(_HistogramCountsGrid6D self, _ostream out=std::cout)"""
        return _IMP_statistics._HistogramCountsGrid6D_show(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""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):
        r"""get_extended_index(_HistogramCountsGrid6D self, GridIndex6D index) -> ExtendedGridIndex6D"""
        return _IMP_statistics._HistogramCountsGrid6D_get_extended_index(self, index)

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

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

    def get_nearest_extended_index(self, pt):
        r"""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

# Register _HistogramCountsGrid6D in _IMP_statistics:
_IMP_statistics._HistogramCountsGrid6D_swigregister(_HistogramCountsGrid6D)

from . import _histogram
show_histogram= _histogram.show_histogram


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

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

def get_data_path(fname):
    r"""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()