algebra/__init__.py

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





from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_algebra', [dirname(__file__)])
        except ImportError:
            import _IMP_algebra
            return _IMP_algebra
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_algebra', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_algebra = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_algebra
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


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


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


class IMP_ALGEBRA_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_ALGEBRA_SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete_IMP_ALGEBRA_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator
        incr(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator
        """
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator
        decr(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator
        """
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator
        __sub__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_ALGEBRA_SwigPyIterator_swigregister = _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_swigregister
IMP_ALGEBRA_SwigPyIterator_swigregister(IMP_ALGEBRA_SwigPyIterator)

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

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

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_algebra._ostream_write(self, *args)

_ostream_swigregister = _IMP_algebra._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_algebra.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_algebra.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_algebra.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_algebra.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_algebra.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_algebra.IMPALGEBRA_SHOW_WARNINGS
def get_vector(v):
   try:
      return v.get_coordinates()
   except:
      return v
def get_sphere(v):
   try:
      return v.get_sphere()
   except:
      return v

_object_types.append("VectorKDMetric")


def _object_cast_to_VectorKDMetric(*args):
  """_object_cast_to_VectorKDMetric(Object o) -> VectorKDMetric"""
  return _IMP_algebra._object_cast_to_VectorKDMetric(*args)
_object_types.append("EuclideanVectorKDMetric")


def _object_cast_to_EuclideanVectorKDMetric(*args):
  """_object_cast_to_EuclideanVectorKDMetric(Object o) -> EuclideanVectorKDMetric"""
  return _IMP_algebra._object_cast_to_EuclideanVectorKDMetric(*args)
_object_types.append("MaxVectorKDMetric")


def _object_cast_to_MaxVectorKDMetric(*args):
  """_object_cast_to_MaxVectorKDMetric(Object o) -> MaxVectorKDMetric"""
  return _IMP_algebra._object_cast_to_MaxVectorKDMetric(*args)
_object_types.append("DynamicNearestNeighbor3D")


def _object_cast_to_DynamicNearestNeighbor3D(*args):
  """_object_cast_to_DynamicNearestNeighbor3D(Object o) -> DynamicNearestNeighbor3D"""
  return _IMP_algebra._object_cast_to_DynamicNearestNeighbor3D(*args)
Rotation2Ds=list
_plural_types.append("Rotation2Ds")
_value_types.append("Rotation2D")

Rotation3Ds=list
_plural_types.append("Rotation3Ds")
_value_types.append("Rotation3D")

Reflection3Ds=list
_plural_types.append("Reflection3Ds")
_value_types.append("Reflection3D")

Transformation2Ds=list
_plural_types.append("Transformation2Ds")
_value_types.append("Transformation2D")

Transformation3Ds=list
_plural_types.append("Transformation3Ds")
_value_types.append("Transformation3D")

SphericalVector3Ds=list
_plural_types.append("SphericalVector3Ds")
_value_types.append("SphericalVector3D")

Triangle3Ds=list
_plural_types.append("Triangle3Ds")
_value_types.append("Triangle3D")

Cone3Ds=list
_plural_types.append("Cone3Ds")
_value_types.append("Cone3D")

Cylinder3Ds=list
_plural_types.append("Cylinder3Ds")
_value_types.append("Cylinder3D")

Ellipsoid3Ds=list
_plural_types.append("Ellipsoid3Ds")
_value_types.append("Ellipsoid3D")

Plane3Ds=list
_plural_types.append("Plane3Ds")
_value_types.append("Plane3D")

Segment3Ds=list
_plural_types.append("Segment3Ds")
_value_types.append("Segment3D")

SpherePatch3Ds=list
_plural_types.append("SpherePatch3Ds")
_value_types.append("SpherePatch3D")

ConnollySurfacePoints=list
_plural_types.append("ConnollySurfacePoints")
_value_types.append("ConnollySurfacePoint")

Sphere1Ds=list
_plural_types.append("Sphere1Ds")
_value_types.append("Sphere1D")

Sphere2Ds=list
_plural_types.append("Sphere2Ds")
_value_types.append("Sphere2D")

Sphere3Ds=list
_plural_types.append("Sphere3Ds")
_value_types.append("Sphere3D")

Sphere4Ds=list
_plural_types.append("Sphere4Ds")
_value_types.append("Sphere4D")

Sphere5Ds=list
_plural_types.append("Sphere5Ds")
_value_types.append("Sphere5D")

Sphere6Ds=list
_plural_types.append("Sphere6Ds")
_value_types.append("Sphere6D")

Sphere1Ds=list
_plural_types.append("Sphere1Ds")
_value_types.append("SphereD<1>")

Sphere2Ds=list
_plural_types.append("Sphere2Ds")
_value_types.append("SphereD<2>")

Sphere3Ds=list
_plural_types.append("Sphere3Ds")
_value_types.append("SphereD<3>")

Sphere4Ds=list
_plural_types.append("Sphere4Ds")
_value_types.append("SphereD<4>")

Sphere5Ds=list
_plural_types.append("Sphere5Ds")
_value_types.append("SphereD<5>")

Sphere6Ds=list
_plural_types.append("Sphere6Ds")
_value_types.append("SphereD<6>")

SphereKDs=list
_plural_types.append("SphereKDs")
_value_types.append("SphereKD")

SphereKDs=list
_plural_types.append("SphereKDs")
_value_types.append("SphereD<-1>")

BoundingBox1Ds=list
_plural_types.append("BoundingBox1Ds")
_value_types.append("BoundingBox1D")

BoundingBox2Ds=list
_plural_types.append("BoundingBox2Ds")
_value_types.append("BoundingBox2D")

BoundingBox3Ds=list
_plural_types.append("BoundingBox3Ds")
_value_types.append("BoundingBox3D")

BoundingBox4Ds=list
_plural_types.append("BoundingBox4Ds")
_value_types.append("BoundingBox4D")

BoundingBox5Ds=list
_plural_types.append("BoundingBox5Ds")
_value_types.append("BoundingBox5D")

BoundingBox6Ds=list
_plural_types.append("BoundingBox6Ds")
_value_types.append("BoundingBox6D")

BoundingBox1Ds=list
_plural_types.append("BoundingBox1Ds")
_value_types.append("BoundingBoxD<1>")

BoundingBox2Ds=list
_plural_types.append("BoundingBox2Ds")
_value_types.append("BoundingBoxD<2>")

BoundingBox3Ds=list
_plural_types.append("BoundingBox3Ds")
_value_types.append("BoundingBoxD<3>")

BoundingBox4Ds=list
_plural_types.append("BoundingBox4Ds")
_value_types.append("BoundingBoxD<4>")

BoundingBox5Ds=list
_plural_types.append("BoundingBox5Ds")
_value_types.append("BoundingBoxD<5>")

BoundingBox6Ds=list
_plural_types.append("BoundingBox6Ds")
_value_types.append("BoundingBoxD<6>")

BoundingBoxKDs=list
_plural_types.append("BoundingBoxKDs")
_value_types.append("BoundingBoxKD")

BoundingBoxKDs=list
_plural_types.append("BoundingBoxKDs")
_value_types.append("BoundingBoxD<-1>")

PrincipalComponentAnalysis1Ds=list
_plural_types.append("PrincipalComponentAnalysis1Ds")
_value_types.append("PrincipalComponentAnalysis1D")

PrincipalComponentAnalysis2Ds=list
_plural_types.append("PrincipalComponentAnalysis2Ds")
_value_types.append("PrincipalComponentAnalysis2D")

PrincipalComponentAnalysis3Ds=list
_plural_types.append("PrincipalComponentAnalysis3Ds")
_value_types.append("PrincipalComponentAnalysis3D")

PrincipalComponentAnalysis4Ds=list
_plural_types.append("PrincipalComponentAnalysis4Ds")
_value_types.append("PrincipalComponentAnalysis4D")

PrincipalComponentAnalysis5Ds=list
_plural_types.append("PrincipalComponentAnalysis5Ds")
_value_types.append("PrincipalComponentAnalysis5D")

PrincipalComponentAnalysis6Ds=list
_plural_types.append("PrincipalComponentAnalysis6Ds")
_value_types.append("PrincipalComponentAnalysis6D")

PrincipalComponentAnalysis1Ds=list
_plural_types.append("PrincipalComponentAnalysis1Ds")
_value_types.append("PrincipalComponentAnalysisD<1>")

PrincipalComponentAnalysis2Ds=list
_plural_types.append("PrincipalComponentAnalysis2Ds")
_value_types.append("PrincipalComponentAnalysisD<2>")

PrincipalComponentAnalysis3Ds=list
_plural_types.append("PrincipalComponentAnalysis3Ds")
_value_types.append("PrincipalComponentAnalysisD<3>")

PrincipalComponentAnalysis4Ds=list
_plural_types.append("PrincipalComponentAnalysis4Ds")
_value_types.append("PrincipalComponentAnalysisD<4>")

PrincipalComponentAnalysis5Ds=list
_plural_types.append("PrincipalComponentAnalysis5Ds")
_value_types.append("PrincipalComponentAnalysisD<5>")

PrincipalComponentAnalysis6Ds=list
_plural_types.append("PrincipalComponentAnalysis6Ds")
_value_types.append("PrincipalComponentAnalysisD<6>")

PrincipalComponentAnalysisKDs=list
_plural_types.append("PrincipalComponentAnalysisKDs")
_value_types.append("PrincipalComponentAnalysisKD")

PrincipalComponentAnalysisKDs=list
_plural_types.append("PrincipalComponentAnalysisKDs")
_value_types.append("PrincipalComponentAnalysisD<-1>")

_object_types.append("NearestNeighbor1D")


def _object_cast_to_NearestNeighbor1D(*args):
  """_object_cast_to_NearestNeighbor1D(Object o) -> NearestNeighbor1D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor1D(*args)
_object_types.append("NearestNeighbor2D")


def _object_cast_to_NearestNeighbor2D(*args):
  """_object_cast_to_NearestNeighbor2D(Object o) -> NearestNeighbor2D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor2D(*args)
_object_types.append("NearestNeighbor3D")


def _object_cast_to_NearestNeighbor3D(*args):
  """_object_cast_to_NearestNeighbor3D(Object o) -> NearestNeighbor3D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor3D(*args)
_object_types.append("NearestNeighbor4D")


def _object_cast_to_NearestNeighbor4D(*args):
  """_object_cast_to_NearestNeighbor4D(Object o) -> NearestNeighbor4D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor4D(*args)
_object_types.append("NearestNeighbor5D")


def _object_cast_to_NearestNeighbor5D(*args):
  """_object_cast_to_NearestNeighbor5D(Object o) -> NearestNeighbor5D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor5D(*args)
_object_types.append("NearestNeighbor6D")


def _object_cast_to_NearestNeighbor6D(*args):
  """_object_cast_to_NearestNeighbor6D(Object o) -> NearestNeighbor6D"""
  return _IMP_algebra._object_cast_to_NearestNeighbor6D(*args)
_object_types.append("NearestNeighborKD")


def _object_cast_to_NearestNeighborKD(*args):
  """_object_cast_to_NearestNeighborKD(Object o) -> NearestNeighborKD"""
  return _IMP_algebra._object_cast_to_NearestNeighborKD(*args)
ReferenceFrame3Ds=list
_plural_types.append("ReferenceFrame3Ds")
_value_types.append("ReferenceFrame3D")

Gaussian3Ds=list
_plural_types.append("Gaussian3Ds")
_value_types.append("Gaussian3D")

DefaultEmbedding1Ds=list
_plural_types.append("DefaultEmbedding1Ds")
_value_types.append("DefaultEmbedding1D")

DefaultEmbedding2Ds=list
_plural_types.append("DefaultEmbedding2Ds")
_value_types.append("DefaultEmbedding2D")

DefaultEmbedding3Ds=list
_plural_types.append("DefaultEmbedding3Ds")
_value_types.append("DefaultEmbedding3D")

DefaultEmbedding4Ds=list
_plural_types.append("DefaultEmbedding4Ds")
_value_types.append("DefaultEmbedding4D")

DefaultEmbedding5Ds=list
_plural_types.append("DefaultEmbedding5Ds")
_value_types.append("DefaultEmbedding5D")

DefaultEmbedding6Ds=list
_plural_types.append("DefaultEmbedding6Ds")
_value_types.append("DefaultEmbedding6D")

DefaultEmbedding1Ds=list
_plural_types.append("DefaultEmbedding1Ds")
_value_types.append("DefaultEmbeddingD<1>")

DefaultEmbedding2Ds=list
_plural_types.append("DefaultEmbedding2Ds")
_value_types.append("DefaultEmbeddingD<2>")

DefaultEmbedding3Ds=list
_plural_types.append("DefaultEmbedding3Ds")
_value_types.append("DefaultEmbeddingD<3>")

DefaultEmbedding4Ds=list
_plural_types.append("DefaultEmbedding4Ds")
_value_types.append("DefaultEmbeddingD<4>")

DefaultEmbedding5Ds=list
_plural_types.append("DefaultEmbedding5Ds")
_value_types.append("DefaultEmbeddingD<5>")

DefaultEmbedding6Ds=list
_plural_types.append("DefaultEmbedding6Ds")
_value_types.append("DefaultEmbeddingD<6>")

DefaultEmbeddingKDs=list
_plural_types.append("DefaultEmbeddingKDs")
_value_types.append("DefaultEmbeddingKD")

DefaultEmbeddingKDs=list
_plural_types.append("DefaultEmbeddingKDs")
_value_types.append("DefaultEmbeddingD<-1>")

LogEmbedding1Ds=list
_plural_types.append("LogEmbedding1Ds")
_value_types.append("LogEmbedding1D")

LogEmbedding2Ds=list
_plural_types.append("LogEmbedding2Ds")
_value_types.append("LogEmbedding2D")

LogEmbedding3Ds=list
_plural_types.append("LogEmbedding3Ds")
_value_types.append("LogEmbedding3D")

LogEmbedding4Ds=list
_plural_types.append("LogEmbedding4Ds")
_value_types.append("LogEmbedding4D")

LogEmbedding5Ds=list
_plural_types.append("LogEmbedding5Ds")
_value_types.append("LogEmbedding5D")

LogEmbedding6Ds=list
_plural_types.append("LogEmbedding6Ds")
_value_types.append("LogEmbedding6D")

LogEmbedding1Ds=list
_plural_types.append("LogEmbedding1Ds")
_value_types.append("LogEmbeddingD<1>")

LogEmbedding2Ds=list
_plural_types.append("LogEmbedding2Ds")
_value_types.append("LogEmbeddingD<2>")

LogEmbedding3Ds=list
_plural_types.append("LogEmbedding3Ds")
_value_types.append("LogEmbeddingD<3>")

LogEmbedding4Ds=list
_plural_types.append("LogEmbedding4Ds")
_value_types.append("LogEmbeddingD<4>")

LogEmbedding5Ds=list
_plural_types.append("LogEmbedding5Ds")
_value_types.append("LogEmbeddingD<5>")

LogEmbedding6Ds=list
_plural_types.append("LogEmbedding6Ds")
_value_types.append("LogEmbeddingD<6>")

LogEmbeddingKDs=list
_plural_types.append("LogEmbeddingKDs")
_value_types.append("LogEmbeddingKD")

LogEmbeddingKDs=list
_plural_types.append("LogEmbeddingKDs")
_value_types.append("LogEmbeddingD<-1>")

GridIndex1Ds=list
_plural_types.append("GridIndex1Ds")
_value_types.append("GridIndex1D")

GridIndex2Ds=list
_plural_types.append("GridIndex2Ds")
_value_types.append("GridIndex2D")

GridIndex3Ds=list
_plural_types.append("GridIndex3Ds")
_value_types.append("GridIndex3D")

GridIndex4Ds=list
_plural_types.append("GridIndex4Ds")
_value_types.append("GridIndex4D")

GridIndex5Ds=list
_plural_types.append("GridIndex5Ds")
_value_types.append("GridIndex5D")

GridIndex6Ds=list
_plural_types.append("GridIndex6Ds")
_value_types.append("GridIndex6D")

GridIndex1Ds=list
_plural_types.append("GridIndex1Ds")
_value_types.append("GridIndexD<1>")

GridIndex2Ds=list
_plural_types.append("GridIndex2Ds")
_value_types.append("GridIndexD<2>")

GridIndex3Ds=list
_plural_types.append("GridIndex3Ds")
_value_types.append("GridIndexD<3>")

GridIndex4Ds=list
_plural_types.append("GridIndex4Ds")
_value_types.append("GridIndexD<4>")

GridIndex5Ds=list
_plural_types.append("GridIndex5Ds")
_value_types.append("GridIndexD<5>")

GridIndex6Ds=list
_plural_types.append("GridIndex6Ds")
_value_types.append("GridIndexD<6>")

GridIndexKDs=list
_plural_types.append("GridIndexKDs")
_value_types.append("GridIndexKD")

GridIndexKDs=list
_plural_types.append("GridIndexKDs")
_value_types.append("GridIndexD<-1>")

ExtendedGridIndex1Ds=list
_plural_types.append("ExtendedGridIndex1Ds")
_value_types.append("ExtendedGridIndex1D")

ExtendedGridIndex2Ds=list
_plural_types.append("ExtendedGridIndex2Ds")
_value_types.append("ExtendedGridIndex2D")

ExtendedGridIndex3Ds=list
_plural_types.append("ExtendedGridIndex3Ds")
_value_types.append("ExtendedGridIndex3D")

ExtendedGridIndex4Ds=list
_plural_types.append("ExtendedGridIndex4Ds")
_value_types.append("ExtendedGridIndex4D")

ExtendedGridIndex5Ds=list
_plural_types.append("ExtendedGridIndex5Ds")
_value_types.append("ExtendedGridIndex5D")

ExtendedGridIndex6Ds=list
_plural_types.append("ExtendedGridIndex6Ds")
_value_types.append("ExtendedGridIndex6D")

ExtendedGridIndex1Ds=list
_plural_types.append("ExtendedGridIndex1Ds")
_value_types.append("ExtendedGridIndexD<1>")

ExtendedGridIndex2Ds=list
_plural_types.append("ExtendedGridIndex2Ds")
_value_types.append("ExtendedGridIndexD<2>")

ExtendedGridIndex3Ds=list
_plural_types.append("ExtendedGridIndex3Ds")
_value_types.append("ExtendedGridIndexD<3>")

ExtendedGridIndex4Ds=list
_plural_types.append("ExtendedGridIndex4Ds")
_value_types.append("ExtendedGridIndexD<4>")

ExtendedGridIndex5Ds=list
_plural_types.append("ExtendedGridIndex5Ds")
_value_types.append("ExtendedGridIndexD<5>")

ExtendedGridIndex6Ds=list
_plural_types.append("ExtendedGridIndex6Ds")
_value_types.append("ExtendedGridIndexD<6>")

ExtendedGridIndexKDs=list
_plural_types.append("ExtendedGridIndexKDs")
_value_types.append("ExtendedGridIndexKD")

ExtendedGridIndexKDs=list
_plural_types.append("ExtendedGridIndexKDs")
_value_types.append("ExtendedGridIndexD<-1>")

BoundedGridRange1Ds=list
_plural_types.append("BoundedGridRange1Ds")
_value_types.append("BoundedGridRange1D")

BoundedGridRange2Ds=list
_plural_types.append("BoundedGridRange2Ds")
_value_types.append("BoundedGridRange2D")

BoundedGridRange3Ds=list
_plural_types.append("BoundedGridRange3Ds")
_value_types.append("BoundedGridRange3D")

BoundedGridRange4Ds=list
_plural_types.append("BoundedGridRange4Ds")
_value_types.append("BoundedGridRange4D")

BoundedGridRange5Ds=list
_plural_types.append("BoundedGridRange5Ds")
_value_types.append("BoundedGridRange5D")

BoundedGridRange6Ds=list
_plural_types.append("BoundedGridRange6Ds")
_value_types.append("BoundedGridRange6D")

BoundedGridRange1Ds=list
_plural_types.append("BoundedGridRange1Ds")
_value_types.append("BoundedGridRangeD<1>")

BoundedGridRange2Ds=list
_plural_types.append("BoundedGridRange2Ds")
_value_types.append("BoundedGridRangeD<2>")

BoundedGridRange3Ds=list
_plural_types.append("BoundedGridRange3Ds")
_value_types.append("BoundedGridRangeD<3>")

BoundedGridRange4Ds=list
_plural_types.append("BoundedGridRange4Ds")
_value_types.append("BoundedGridRangeD<4>")

BoundedGridRange5Ds=list
_plural_types.append("BoundedGridRange5Ds")
_value_types.append("BoundedGridRangeD<5>")

BoundedGridRange6Ds=list
_plural_types.append("BoundedGridRange6Ds")
_value_types.append("BoundedGridRangeD<6>")

BoundedGridRangeKDs=list
_plural_types.append("BoundedGridRangeKDs")
_value_types.append("BoundedGridRangeKD")

BoundedGridRangeKDs=list
_plural_types.append("BoundedGridRangeKDs")
_value_types.append("BoundedGridRangeD<-1>")

UnboundedGridRange1Ds=list
_plural_types.append("UnboundedGridRange1Ds")
_value_types.append("UnboundedGridRange1D")

UnboundedGridRange2Ds=list
_plural_types.append("UnboundedGridRange2Ds")
_value_types.append("UnboundedGridRange2D")

UnboundedGridRange3Ds=list
_plural_types.append("UnboundedGridRange3Ds")
_value_types.append("UnboundedGridRange3D")

UnboundedGridRange4Ds=list
_plural_types.append("UnboundedGridRange4Ds")
_value_types.append("UnboundedGridRange4D")

UnboundedGridRange5Ds=list
_plural_types.append("UnboundedGridRange5Ds")
_value_types.append("UnboundedGridRange5D")

UnboundedGridRange6Ds=list
_plural_types.append("UnboundedGridRange6Ds")
_value_types.append("UnboundedGridRange6D")

UnboundedGridRange1Ds=list
_plural_types.append("UnboundedGridRange1Ds")
_value_types.append("UnboundedGridRangeD<1>")

UnboundedGridRange2Ds=list
_plural_types.append("UnboundedGridRange2Ds")
_value_types.append("UnboundedGridRangeD<2>")

UnboundedGridRange3Ds=list
_plural_types.append("UnboundedGridRange3Ds")
_value_types.append("UnboundedGridRangeD<3>")

UnboundedGridRange4Ds=list
_plural_types.append("UnboundedGridRange4Ds")
_value_types.append("UnboundedGridRangeD<4>")

UnboundedGridRange5Ds=list
_plural_types.append("UnboundedGridRange5Ds")
_value_types.append("UnboundedGridRangeD<5>")

UnboundedGridRange6Ds=list
_plural_types.append("UnboundedGridRange6Ds")
_value_types.append("UnboundedGridRangeD<6>")

UnboundedGridRangeKDs=list
_plural_types.append("UnboundedGridRangeKDs")
_value_types.append("UnboundedGridRangeKD")

UnboundedGridRangeKDs=list
_plural_types.append("UnboundedGridRangeKDs")
_value_types.append("UnboundedGridRangeD<-1>")

LinearFit2Ds=list
_plural_types.append("LinearFit2Ds")
_value_types.append("LinearFit2D")

ParabolicFit2Ds=list
_plural_types.append("ParabolicFit2Ds")
_value_types.append("ParabolicFit2D")

FixedXYZs=list
_plural_types.append("FixedXYZs")
_value_types.append("FixedXYZ")

class _GeometricPrimitive1D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive1D
    __del__ = lambda self : None;
_GeometricPrimitive1D_swigregister = _IMP_algebra._GeometricPrimitive1D_swigregister
_GeometricPrimitive1D_swigregister(_GeometricPrimitive1D)

class _GeometricPrimitive2D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive2D
    __del__ = lambda self : None;
_GeometricPrimitive2D_swigregister = _IMP_algebra._GeometricPrimitive2D_swigregister
_GeometricPrimitive2D_swigregister(_GeometricPrimitive2D)

class _GeometricPrimitive3D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive3D
    __del__ = lambda self : None;
_GeometricPrimitive3D_swigregister = _IMP_algebra._GeometricPrimitive3D_swigregister
_GeometricPrimitive3D_swigregister(_GeometricPrimitive3D)

class _GeometricPrimitive4D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive4D
    __del__ = lambda self : None;
_GeometricPrimitive4D_swigregister = _IMP_algebra._GeometricPrimitive4D_swigregister
_GeometricPrimitive4D_swigregister(_GeometricPrimitive4D)

class _GeometricPrimitive5D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive5D
    __del__ = lambda self : None;
_GeometricPrimitive5D_swigregister = _IMP_algebra._GeometricPrimitive5D_swigregister
_GeometricPrimitive5D_swigregister(_GeometricPrimitive5D)

class _GeometricPrimitive6D(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive6D
    __del__ = lambda self : None;
_GeometricPrimitive6D_swigregister = _IMP_algebra._GeometricPrimitive6D_swigregister
_GeometricPrimitive6D_swigregister(_GeometricPrimitive6D)

class _GeometricPrimitiveKD(object):
    """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitiveKD
    __del__ = lambda self : None;
_GeometricPrimitiveKD_swigregister = _IMP_algebra._GeometricPrimitiveKD_swigregister
_GeometricPrimitiveKD_swigregister(_GeometricPrimitiveKD)

Vector1Ds=list
_plural_types.append("Vector1Ds")
_value_types.append("Vector1D")

Vector2Ds=list
_plural_types.append("Vector2Ds")
_value_types.append("Vector2D")

Vector3Ds=list
_plural_types.append("Vector3Ds")
_value_types.append("Vector3D")

Vector4Ds=list
_plural_types.append("Vector4Ds")
_value_types.append("Vector4D")

Vector5Ds=list
_plural_types.append("Vector5Ds")
_value_types.append("Vector5D")

Vector6Ds=list
_plural_types.append("Vector6Ds")
_value_types.append("Vector6D")

Vector1Ds=list
_plural_types.append("Vector1Ds")
_value_types.append("VectorD<1>")

Vector2Ds=list
_plural_types.append("Vector2Ds")
_value_types.append("VectorD<2>")

Vector3Ds=list
_plural_types.append("Vector3Ds")
_value_types.append("VectorD<3>")

Vector4Ds=list
_plural_types.append("Vector4Ds")
_value_types.append("VectorD<4>")

Vector5Ds=list
_plural_types.append("Vector5Ds")
_value_types.append("VectorD<5>")

Vector6Ds=list
_plural_types.append("Vector6Ds")
_value_types.append("VectorD<6>")

VectorKDs=list
_plural_types.append("VectorKDs")
_value_types.append("VectorKD")

VectorKDs=list
_plural_types.append("VectorKDs")
_value_types.append("VectorD<-1>")

class _VectorBaseKD(_GeometricPrimitiveKD):
    """Proxy of C++ IMP::algebra::VectorBaseD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(-1)> self) -> _VectorBaseKD"""
        this = _IMP_algebra.new__VectorBaseKD()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBaseKD self, _VectorBaseKD o) -> double"""
        return _IMP_algebra._VectorBaseKD_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBaseKD self) -> double"""
        return _IMP_algebra._VectorBaseKD_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBaseKD self) -> double"""
        return _IMP_algebra._VectorBaseKD_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
        return _IMP_algebra._VectorBaseKD___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
        return _IMP_algebra._VectorBaseKD___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
        return _IMP_algebra._VectorBaseKD___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
        return _IMP_algebra._VectorBaseKD___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
        return _IMP_algebra._VectorBaseKD___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBaseKD self, _ostream out, std::string delim)
        show(_VectorBaseKD self, _ostream out=std::cout)
        show(_VectorBaseKD self)
        """
        return _IMP_algebra._VectorBaseKD_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBaseKD self) -> unsigned int"""
        return _IMP_algebra._VectorBaseKD_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBaseKD
    __del__ = lambda self : None;
_VectorBaseKD_swigregister = _IMP_algebra._VectorBaseKD_swigregister
_VectorBaseKD_swigregister(_VectorBaseKD)

class _VectorBase1D(_GeometricPrimitive1D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(1)> self) -> _VectorBase1D"""
        this = _IMP_algebra.new__VectorBase1D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase1D self, _VectorBase1D o) -> double"""
        return _IMP_algebra._VectorBase1D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase1D self) -> double"""
        return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase1D self) -> double"""
        return _IMP_algebra._VectorBase1D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
        return _IMP_algebra._VectorBase1D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
        return _IMP_algebra._VectorBase1D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
        return _IMP_algebra._VectorBase1D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase1D self, double f) -> _VectorBase1D"""
        return _IMP_algebra._VectorBase1D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
        return _IMP_algebra._VectorBase1D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase1D self, _ostream out, std::string delim)
        show(_VectorBase1D self, _ostream out=std::cout)
        show(_VectorBase1D self)
        """
        return _IMP_algebra._VectorBase1D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase1D self) -> unsigned int"""
        return _IMP_algebra._VectorBase1D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase1D
    __del__ = lambda self : None;
_VectorBase1D_swigregister = _IMP_algebra._VectorBase1D_swigregister
_VectorBase1D_swigregister(_VectorBase1D)

class _VectorBase2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(2)> self) -> _VectorBase2D"""
        this = _IMP_algebra.new__VectorBase2D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase2D self, _VectorBase2D o) -> double"""
        return _IMP_algebra._VectorBase2D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase2D self) -> double"""
        return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase2D self) -> double"""
        return _IMP_algebra._VectorBase2D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
        return _IMP_algebra._VectorBase2D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
        return _IMP_algebra._VectorBase2D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
        return _IMP_algebra._VectorBase2D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase2D self, double f) -> _VectorBase2D"""
        return _IMP_algebra._VectorBase2D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
        return _IMP_algebra._VectorBase2D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase2D self, _ostream out, std::string delim)
        show(_VectorBase2D self, _ostream out=std::cout)
        show(_VectorBase2D self)
        """
        return _IMP_algebra._VectorBase2D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase2D self) -> unsigned int"""
        return _IMP_algebra._VectorBase2D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase2D
    __del__ = lambda self : None;
_VectorBase2D_swigregister = _IMP_algebra._VectorBase2D_swigregister
_VectorBase2D_swigregister(_VectorBase2D)

class _VectorBase3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(3)> self) -> _VectorBase3D"""
        this = _IMP_algebra.new__VectorBase3D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase3D self, _VectorBase3D o) -> double"""
        return _IMP_algebra._VectorBase3D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase3D self) -> double"""
        return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase3D self) -> double"""
        return _IMP_algebra._VectorBase3D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
        return _IMP_algebra._VectorBase3D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
        return _IMP_algebra._VectorBase3D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
        return _IMP_algebra._VectorBase3D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase3D self, double f) -> _VectorBase3D"""
        return _IMP_algebra._VectorBase3D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
        return _IMP_algebra._VectorBase3D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase3D self, _ostream out, std::string delim)
        show(_VectorBase3D self, _ostream out=std::cout)
        show(_VectorBase3D self)
        """
        return _IMP_algebra._VectorBase3D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase3D self) -> unsigned int"""
        return _IMP_algebra._VectorBase3D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase3D
    __del__ = lambda self : None;
_VectorBase3D_swigregister = _IMP_algebra._VectorBase3D_swigregister
_VectorBase3D_swigregister(_VectorBase3D)

class _VectorBase4D(_GeometricPrimitive4D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(4)> self) -> _VectorBase4D"""
        this = _IMP_algebra.new__VectorBase4D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase4D self, _VectorBase4D o) -> double"""
        return _IMP_algebra._VectorBase4D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase4D self) -> double"""
        return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase4D self) -> double"""
        return _IMP_algebra._VectorBase4D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
        return _IMP_algebra._VectorBase4D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
        return _IMP_algebra._VectorBase4D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
        return _IMP_algebra._VectorBase4D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase4D self, double f) -> _VectorBase4D"""
        return _IMP_algebra._VectorBase4D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
        return _IMP_algebra._VectorBase4D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase4D self, _ostream out, std::string delim)
        show(_VectorBase4D self, _ostream out=std::cout)
        show(_VectorBase4D self)
        """
        return _IMP_algebra._VectorBase4D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase4D self) -> unsigned int"""
        return _IMP_algebra._VectorBase4D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase4D
    __del__ = lambda self : None;
_VectorBase4D_swigregister = _IMP_algebra._VectorBase4D_swigregister
_VectorBase4D_swigregister(_VectorBase4D)

class _VectorBase5D(_GeometricPrimitive5D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(5)> self) -> _VectorBase5D"""
        this = _IMP_algebra.new__VectorBase5D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase5D self, _VectorBase5D o) -> double"""
        return _IMP_algebra._VectorBase5D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase5D self) -> double"""
        return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase5D self) -> double"""
        return _IMP_algebra._VectorBase5D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
        return _IMP_algebra._VectorBase5D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
        return _IMP_algebra._VectorBase5D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
        return _IMP_algebra._VectorBase5D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase5D self, double f) -> _VectorBase5D"""
        return _IMP_algebra._VectorBase5D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
        return _IMP_algebra._VectorBase5D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase5D self, _ostream out, std::string delim)
        show(_VectorBase5D self, _ostream out=std::cout)
        show(_VectorBase5D self)
        """
        return _IMP_algebra._VectorBase5D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase5D self) -> unsigned int"""
        return _IMP_algebra._VectorBase5D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase5D
    __del__ = lambda self : None;
_VectorBase5D_swigregister = _IMP_algebra._VectorBase5D_swigregister
_VectorBase5D_swigregister(_VectorBase5D)

class _VectorBase6D(_GeometricPrimitive6D):
    """Proxy of C++ IMP::algebra::VectorBaseD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::algebra::VectorBaseD<(6)> self) -> _VectorBase6D"""
        this = _IMP_algebra.new__VectorBase6D()
        try: self.this.append(this)
        except: self.this = this
    def get_scalar_product(self, *args):
        """get_scalar_product(_VectorBase6D self, _VectorBase6D o) -> double"""
        return _IMP_algebra._VectorBase6D_get_scalar_product(self, *args)

    def get_squared_magnitude(self):
        """get_squared_magnitude(_VectorBase6D self) -> double"""
        return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)

    def get_magnitude(self):
        """get_magnitude(_VectorBase6D self) -> double"""
        return _IMP_algebra._VectorBase6D_get_magnitude(self)

    def __mul__(self, *args):
        """__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
        return _IMP_algebra._VectorBase6D___mul__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
        return _IMP_algebra._VectorBase6D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
        return _IMP_algebra._VectorBase6D___isub__(self, *args)

    def __idiv__(self, *args):
        """__idiv__(_VectorBase6D self, double f) -> _VectorBase6D"""
        return _IMP_algebra._VectorBase6D___idiv__(self, *args)

    def __imul__(self, *args):
        """__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
        return _IMP_algebra._VectorBase6D___imul__(self, *args)

    def show(self, *args):
        """
        show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
        show(_VectorBase6D self, _ostream out, std::string delim)
        show(_VectorBase6D self, _ostream out=std::cout)
        show(_VectorBase6D self)
        """
        return _IMP_algebra._VectorBase6D_show(self, *args)

    def get_dimension(self):
        """get_dimension(_VectorBase6D self) -> unsigned int"""
        return _IMP_algebra._VectorBase6D_get_dimension(self)

    __swig_destroy__ = _IMP_algebra.delete__VectorBase6D
    __del__ = lambda self : None;
_VectorBase6D_swigregister = _IMP_algebra._VectorBase6D_swigregister
_VectorBase6D_swigregister(_VectorBase6D)


def get_basis_vector_kd(*args):
  """get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
  return _IMP_algebra.get_basis_vector_kd(*args)

def get_zero_vector_kd(*args):
  """get_zero_vector_kd(int D) -> VectorKD"""
  return _IMP_algebra.get_zero_vector_kd(*args)

def get_ones_vector_kd(*args):
  """
    get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD
    get_ones_vector_kd(unsigned int D) -> VectorKD
    """
  return _IMP_algebra.get_ones_vector_kd(*args)

def get_vector_product(*args):
  """get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
  return _IMP_algebra.get_vector_product(*args)

def get_orthogonal_vector(*args):
  """get_orthogonal_vector(Vector3D v) -> Vector3D"""
  return _IMP_algebra.get_orthogonal_vector(*args)

def get_centroid(*args):
  """get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
  return _IMP_algebra.get_centroid(*args)

def get_radius_of_gyration(*args):
  """get_radius_of_gyration(IMP::algebra::Vector3Ds const & ps) -> double"""
  return _IMP_algebra.get_radius_of_gyration(*args)
class Rotation3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Rotation3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
        __init__(IMP::algebra::Rotation3D self, Vector4D v) -> Rotation3D
        __init__(IMP::algebra::Rotation3D self) -> Rotation3D
        __init__(IMP::algebra::Rotation3D self, double a, double b, double c, double d) -> Rotation3D
        """
        this = _IMP_algebra.new_Rotation3D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_algebra.delete_Rotation3D
    __del__ = lambda self : None;
    def get_rotated_no_cache(self, *args):
        """get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, *args)

    def get_rotated_one_coordinate_no_cache(self, *args):
        """get_rotated_one_coordinate_no_cache(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
        return _IMP_algebra.Rotation3D_get_rotated_one_coordinate_no_cache(self, *args)

    def get_rotated(self, *args):
        """get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_rotated(self, *args)

    def get_rotated_one_coordinate(self, *args):
        """get_rotated_one_coordinate(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
        return _IMP_algebra.Rotation3D_get_rotated_one_coordinate(self, *args)

    def get_rotation_matrix_row(self, *args):
        """get_rotation_matrix_row(Rotation3D self, int i) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_rotation_matrix_row(self, *args)

    def show(self, *args):
        """
        show(Rotation3D self, _ostream out=std::cout)
        show(Rotation3D self)
        """
        return _IMP_algebra.Rotation3D_show(self, *args)

    def get_inverse(self):
        """get_inverse(Rotation3D self) -> Rotation3D"""
        return _IMP_algebra.Rotation3D_get_inverse(self)

    def get_quaternion(self):
        """get_quaternion(Rotation3D self) -> Vector4D"""
        return _IMP_algebra.Rotation3D_get_quaternion(self)

    def __mul__(self, *args):
        """
        __mul__(Rotation3D self, Vector3D v) -> Vector3D
        __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
        """
        return _IMP_algebra.Rotation3D___mul__(self, *args)

    def __div__(self, *args):
        """__div__(Rotation3D self, Rotation3D r) -> Rotation3D"""
        return _IMP_algebra.Rotation3D___div__(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Rotation3D self, Vector3D o, unsigned int i) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_derivative(self, *args)

    def get_is_valid(self):
        """get_is_valid(Rotation3D self) -> bool"""
        return _IMP_algebra.Rotation3D_get_is_valid(self)

    def __str__(self):
        """__str__(Rotation3D self) -> std::string"""
        return _IMP_algebra.Rotation3D___str__(self)

    def __repr__(self):
        """__repr__(Rotation3D self) -> std::string"""
        return _IMP_algebra.Rotation3D___repr__(self)

    __truediv__ = __div__

Rotation3D_swigregister = _IMP_algebra.Rotation3D_swigregister
Rotation3D_swigregister(Rotation3D)


def get_identity_rotation_3d():
  """get_identity_rotation_3d() -> Rotation3D"""
  return _IMP_algebra.get_identity_rotation_3d()

def get_rotation_about_normalized_axis(*args):
  """get_rotation_about_normalized_axis(Vector3D axis_norm, double angle) -> Rotation3D"""
  return _IMP_algebra.get_rotation_about_normalized_axis(*args)

def get_rotation_about_axis(*args):
  """get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
  return _IMP_algebra.get_rotation_about_axis(*args)

def get_rotation_taking_first_to_second(*args):
  """get_rotation_taking_first_to_second(Vector3D v1, Vector3D v2) -> Rotation3D"""
  return _IMP_algebra.get_rotation_taking_first_to_second(*args)

def get_rotation_from_matrix(*args):
  """
    get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, 
        double m21, double m22) -> Rotation3D
    get_rotation_from_matrix(IMP_Eigen::Matrix3d m) -> Rotation3D
    """
  return _IMP_algebra.get_rotation_from_matrix(*args)

def get_random_rotation_3d(*args):
  """
    get_random_rotation_3d() -> Rotation3D
    get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
    """
  return _IMP_algebra.get_random_rotation_3d(*args)

def get_uniform_cover_rotations_3d(*args):
  """get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
  return _IMP_algebra.get_uniform_cover_rotations_3d(*args)

def get_uniformly_sampled_rotations(*args):
  """get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
  return _IMP_algebra.get_uniformly_sampled_rotations(*args)

def get_rotation_from_vector4d(*args):
  """get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
  return _IMP_algebra.get_rotation_from_vector4d(*args)

def get_rotation_from_fixed_xyz(*args):
  """get_rotation_from_fixed_xyz(double xr, double yr, double zr) -> Rotation3D"""
  return _IMP_algebra.get_rotation_from_fixed_xyz(*args)

def get_rotation_from_fixed_zxz(*args):
  """get_rotation_from_fixed_zxz(double phi, double theta, double psi) -> Rotation3D"""
  return _IMP_algebra.get_rotation_from_fixed_zxz(*args)

def get_rotation_from_fixed_zyz(*args):
  """get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
  return _IMP_algebra.get_rotation_from_fixed_zyz(*args)
class FixedXYZ(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::FixedXYZ class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::FixedXYZ self) -> FixedXYZ
        __init__(IMP::algebra::FixedXYZ self, double x, double y, double z) -> FixedXYZ
        """
        this = _IMP_algebra.new_FixedXYZ(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_x(self):
        """get_x(FixedXYZ self) -> double"""
        return _IMP_algebra.FixedXYZ_get_x(self)

    def get_y(self):
        """get_y(FixedXYZ self) -> double"""
        return _IMP_algebra.FixedXYZ_get_y(self)

    def get_z(self):
        """get_z(FixedXYZ self) -> double"""
        return _IMP_algebra.FixedXYZ_get_z(self)

    def show(self, *args):
        """
        show(FixedXYZ self, _ostream out=std::cout)
        show(FixedXYZ self)
        """
        return _IMP_algebra.FixedXYZ_show(self, *args)

    def __str__(self):
        """__str__(FixedXYZ self) -> std::string"""
        return _IMP_algebra.FixedXYZ___str__(self)

    def __repr__(self):
        """__repr__(FixedXYZ self) -> std::string"""
        return _IMP_algebra.FixedXYZ___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
    __del__ = lambda self : None;
FixedXYZ_swigregister = _IMP_algebra.FixedXYZ_swigregister
FixedXYZ_swigregister(FixedXYZ)


def get_fixed_xyz_from_rotation(*args):
  """get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
  return _IMP_algebra.get_fixed_xyz_from_rotation(*args)

def get_interpolated(*args):
  """get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
  return _IMP_algebra.get_interpolated(*args)

def get_rotation_from_x_y_axes(*args):
  """get_rotation_from_x_y_axes(Vector3D x, Vector3D y) -> Rotation3D"""
  return _IMP_algebra.get_rotation_from_x_y_axes(*args)

def get_axis_and_angle(*args):
  """get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
  return _IMP_algebra.get_axis_and_angle(*args)

def get_unit_bounding_box_kd(*args):
  """get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
  return _IMP_algebra.get_unit_bounding_box_kd(*args)

def get_cube_kd(*args):
  """get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
  return _IMP_algebra.get_cube_kd(*args)

def get_edges(*args):
  """get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
  return _IMP_algebra.get_edges(*args)
class Transformation3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Transformation3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Transformation3D self) -> Transformation3D
        __init__(IMP::algebra::Transformation3D self, Rotation3D r, Vector3D t=IMP::algebra::Vector3D(0, 0, 0)) -> Transformation3D
        __init__(IMP::algebra::Transformation3D self, Rotation3D r) -> Transformation3D
        __init__(IMP::algebra::Transformation3D self, Vector3D t) -> Transformation3D
        """
        this = _IMP_algebra.new_Transformation3D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_algebra.delete_Transformation3D
    __del__ = lambda self : None;
    def get_transformed(self, *args):
        """get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Transformation3D_get_transformed(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Transformation3D self, Vector3D v) -> Vector3D
        __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
        """
        return _IMP_algebra.Transformation3D___mul__(self, *args)

    def __div__(self, *args):
        """__div__(Transformation3D self, Transformation3D b) -> Transformation3D"""
        return _IMP_algebra.Transformation3D___div__(self, *args)

    def get_rotation(self):
        """get_rotation(Transformation3D self) -> Rotation3D"""
        return _IMP_algebra.Transformation3D_get_rotation(self)

    def get_translation(self):
        """get_translation(Transformation3D self) -> Vector3D"""
        return _IMP_algebra.Transformation3D_get_translation(self)

    def show(self, *args):
        """
        show(Transformation3D self, _ostream out=std::cout)
        show(Transformation3D self)
        """
        return _IMP_algebra.Transformation3D_show(self, *args)

    def get_inverse(self):
        """get_inverse(Transformation3D self) -> Transformation3D"""
        return _IMP_algebra.Transformation3D_get_inverse(self)

    def get_is_valid(self):
        """get_is_valid(Transformation3D self) -> bool"""
        return _IMP_algebra.Transformation3D_get_is_valid(self)

    def __str__(self):
        """__str__(Transformation3D self) -> std::string"""
        return _IMP_algebra.Transformation3D___str__(self)

    def __repr__(self):
        """__repr__(Transformation3D self) -> std::string"""
        return _IMP_algebra.Transformation3D___repr__(self)

    __truediv__ = __div__

Transformation3D_swigregister = _IMP_algebra.Transformation3D_swigregister
Transformation3D_swigregister(Transformation3D)


def get_identity_transformation_3d():
  """get_identity_transformation_3d() -> Transformation3D"""
  return _IMP_algebra.get_identity_transformation_3d()

def get_transformation_3d(*args):
  """get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
  return _IMP_algebra.get_transformation_3d(*args)

def get_random_local_transformation(*args):
  """
    get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D
    get_random_local_transformation(Vector3D origin, double max_translation=5.) -> Transformation3D
    get_random_local_transformation(Vector3D origin) -> Transformation3D
    """
  return _IMP_algebra.get_random_local_transformation(*args)
class Rotation2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::Rotation2D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Rotation2D self) -> Rotation2D
        __init__(IMP::algebra::Rotation2D self, double angle) -> Rotation2D
        """
        this = _IMP_algebra.new_Rotation2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_rotated(self, *args):
        """
        get_rotated(Rotation2D self, Vector2D o) -> Vector2D
        get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
        """
        return _IMP_algebra.Rotation2D_get_rotated(self, *args)

    def get_inverse(self):
        """get_inverse(Rotation2D self) -> Rotation2D"""
        return _IMP_algebra.Rotation2D_get_inverse(self)

    def set_angle(self, *args):
        """set_angle(Rotation2D self, double angle)"""
        return _IMP_algebra.Rotation2D_set_angle(self, *args)

    def get_angle(self):
        """get_angle(Rotation2D self) -> double"""
        return _IMP_algebra.Rotation2D_get_angle(self)

    def show(self, *args):
        """
        show(Rotation2D self, _ostream out=std::cout)
        show(Rotation2D self)
        """
        return _IMP_algebra.Rotation2D_show(self, *args)

    def __str__(self):
        """__str__(Rotation2D self) -> std::string"""
        return _IMP_algebra.Rotation2D___str__(self)

    def __repr__(self):
        """__repr__(Rotation2D self) -> std::string"""
        return _IMP_algebra.Rotation2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Rotation2D
    __del__ = lambda self : None;
Rotation2D_swigregister = _IMP_algebra.Rotation2D_swigregister
Rotation2D_swigregister(Rotation2D)


def get_identity_rotation_2d():
  """get_identity_rotation_2d() -> Rotation2D"""
  return _IMP_algebra.get_identity_rotation_2d()

def get_random_rotation_2d():
  """get_random_rotation_2d() -> Rotation2D"""
  return _IMP_algebra.get_random_rotation_2d()

def get_rotation_to_x_axis(*args):
  """get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
  return _IMP_algebra.get_rotation_to_x_axis(*args)
class Transformation2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::Transformation2D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Transformation2D self) -> Transformation2D
        __init__(IMP::algebra::Transformation2D self, Rotation2D r, Vector2D t=IMP::algebra::Vector2D(0.0, 0.0)) -> Transformation2D
        __init__(IMP::algebra::Transformation2D self, Rotation2D r) -> Transformation2D
        __init__(IMP::algebra::Transformation2D self, Vector2D t) -> Transformation2D
        """
        this = _IMP_algebra.new_Transformation2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_algebra.delete_Transformation2D
    __del__ = lambda self : None;
    def get_transformed(self, *args):
        """get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
        return _IMP_algebra.Transformation2D_get_transformed(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Transformation2D self, Vector2D v) -> Vector2D
        __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
        """
        return _IMP_algebra.Transformation2D___mul__(self, *args)

    def __div__(self, *args):
        """__div__(Transformation2D self, Transformation2D b) -> Transformation2D"""
        return _IMP_algebra.Transformation2D___div__(self, *args)

    def get_rotation(self):
        """get_rotation(Transformation2D self) -> Rotation2D"""
        return _IMP_algebra.Transformation2D_get_rotation(self)

    def set_rotation(self, *args):
        """set_rotation(Transformation2D self, double angle)"""
        return _IMP_algebra.Transformation2D_set_rotation(self, *args)

    def get_translation(self):
        """get_translation(Transformation2D self) -> Vector2D"""
        return _IMP_algebra.Transformation2D_get_translation(self)

    def set_translation(self, *args):
        """set_translation(Transformation2D self, Vector2D v)"""
        return _IMP_algebra.Transformation2D_set_translation(self, *args)

    def show(self, *args):
        """
        show(Transformation2D self, _ostream out=std::cout)
        show(Transformation2D self)
        """
        return _IMP_algebra.Transformation2D_show(self, *args)

    def get_inverse(self):
        """get_inverse(Transformation2D self) -> Transformation2D"""
        return _IMP_algebra.Transformation2D_get_inverse(self)

    def __str__(self):
        """__str__(Transformation2D self) -> std::string"""
        return _IMP_algebra.Transformation2D___str__(self)

    def __repr__(self):
        """__repr__(Transformation2D self) -> std::string"""
        return _IMP_algebra.Transformation2D___repr__(self)

    __truediv__ = __div__

Transformation2D_swigregister = _IMP_algebra.Transformation2D_swigregister
Transformation2D_swigregister(Transformation2D)


def get_identity_transformation_2d():
  """get_identity_transformation_2d() -> Transformation2D"""
  return _IMP_algebra.get_identity_transformation_2d()

def get_rotation_about_point(*args):
  """
    get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
    get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
    """
  return _IMP_algebra.get_rotation_about_point(*args)

def compose(*args):
  """
    compose(Rotation3D a, Rotation3D b) -> Rotation3D
    compose(Transformation3D a, Transformation3D b) -> Transformation3D
    compose(Rotation2D a, Rotation2D b) -> Rotation2D
    compose(Transformation2D a, Transformation2D b) -> Transformation2D
    """
  return _IMP_algebra.compose(*args)

def get_unit_sphere_kd(*args):
  """get_unit_sphere_kd(unsigned int d) -> SphereKD"""
  return _IMP_algebra.get_unit_sphere_kd(*args)

def get_enclosing_sphere(*args):
  """
    get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
    get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
    """
  return _IMP_algebra.get_enclosing_sphere(*args)

def get_ball_radius_from_volume_3d(*args):
  """get_ball_radius_from_volume_3d(double volume) -> double"""
  return _IMP_algebra.get_ball_radius_from_volume_3d(*args)

def get_surface_area_and_volume(*args):
  """get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
  return _IMP_algebra.get_surface_area_and_volume(*args)

def get_simplified_from_volume(*args):
  """get_simplified_from_volume(IMP::algebra::Sphere3Ds _in, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
  return _IMP_algebra.get_simplified_from_volume(*args)
class Vector1D(_VectorBase1D):
    """Proxy of C++ IMP::algebra::VectorD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector1D self) -> Vector1D"""
        return _IMP_algebra.Vector1D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector1D self, double s) -> Vector1D"""
        return _IMP_algebra.Vector1D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector1D self) -> Vector1D"""
        return _IMP_algebra.Vector1D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector1D self, Vector1D o) -> Vector1D"""
        return _IMP_algebra.Vector1D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector1D self, Vector1D ret) -> Vector1D"""
        return _IMP_algebra.Vector1D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector1D self, double s) -> Vector1D
        __mul__(Vector1D self, Vector1D o) -> double
        """
        return _IMP_algebra.Vector1D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(1)> self, IMP::Floats const & f) -> Vector1D
        __init__(IMP::algebra::VectorD<(1)> self) -> Vector1D
        __init__(IMP::algebra::VectorD<(1)> self, double x) -> Vector1D
        """
        this = _IMP_algebra.new_Vector1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector1D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector1D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector1D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector1D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector1D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector1D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector1D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector1D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector1D self) -> unsigned int"""
        return _IMP_algebra.Vector1D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector1D self, double f) -> Vector1D"""
        return _IMP_algebra.Vector1D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector1D self) -> std::string"""
        return _IMP_algebra.Vector1D___str__(self)

    def __repr__(self):
        """__repr__(Vector1D self) -> std::string"""
        return _IMP_algebra.Vector1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector1D self, Vector1D arg2) -> int"""
        return _IMP_algebra.Vector1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector1D self, Vector1D arg2) -> bool"""
        return _IMP_algebra.Vector1D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector1D
    __del__ = lambda self : None;
Vector1D_swigregister = _IMP_algebra.Vector1D_swigregister
Vector1D_swigregister(Vector1D)

class Vector2D(_VectorBase2D):
    """Proxy of C++ IMP::algebra::VectorD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector2D self) -> Vector2D"""
        return _IMP_algebra.Vector2D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector2D self, double s) -> Vector2D"""
        return _IMP_algebra.Vector2D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector2D self) -> Vector2D"""
        return _IMP_algebra.Vector2D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector2D self, Vector2D o) -> Vector2D"""
        return _IMP_algebra.Vector2D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector2D self, Vector2D ret) -> Vector2D"""
        return _IMP_algebra.Vector2D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector2D self, double s) -> Vector2D
        __mul__(Vector2D self, Vector2D o) -> double
        """
        return _IMP_algebra.Vector2D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(2)> self, IMP::Floats const & f) -> Vector2D
        __init__(IMP::algebra::VectorD<(2)> self) -> Vector2D
        __init__(IMP::algebra::VectorD<(2)> self, double x, double y) -> Vector2D
        """
        this = _IMP_algebra.new_Vector2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector2D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector2D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector2D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector2D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector2D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector2D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector2D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector2D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector2D self) -> unsigned int"""
        return _IMP_algebra.Vector2D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector2D self, double f) -> Vector2D"""
        return _IMP_algebra.Vector2D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector2D self) -> std::string"""
        return _IMP_algebra.Vector2D___str__(self)

    def __repr__(self):
        """__repr__(Vector2D self) -> std::string"""
        return _IMP_algebra.Vector2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector2D self, Vector2D arg2) -> int"""
        return _IMP_algebra.Vector2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector2D self, Vector2D arg2) -> bool"""
        return _IMP_algebra.Vector2D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector2D
    __del__ = lambda self : None;
Vector2D_swigregister = _IMP_algebra.Vector2D_swigregister
Vector2D_swigregister(Vector2D)

class Vector3D(_VectorBase3D):
    """Proxy of C++ IMP::algebra::VectorD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector3D self) -> Vector3D"""
        return _IMP_algebra.Vector3D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector3D self, double s) -> Vector3D"""
        return _IMP_algebra.Vector3D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector3D self) -> Vector3D"""
        return _IMP_algebra.Vector3D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Vector3D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector3D self, Vector3D ret) -> Vector3D"""
        return _IMP_algebra.Vector3D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector3D self, double s) -> Vector3D
        __mul__(Vector3D self, Vector3D o) -> double
        """
        return _IMP_algebra.Vector3D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(3)> self, IMP::Floats const & f) -> Vector3D
        __init__(IMP::algebra::VectorD<(3)> self) -> Vector3D
        __init__(IMP::algebra::VectorD<(3)> self, double x, double y, double z) -> Vector3D
        """
        this = _IMP_algebra.new_Vector3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector3D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector3D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector3D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector3D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector3D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector3D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector3D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector3D self) -> unsigned int"""
        return _IMP_algebra.Vector3D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector3D self, double f) -> Vector3D"""
        return _IMP_algebra.Vector3D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector3D self) -> std::string"""
        return _IMP_algebra.Vector3D___str__(self)

    def __repr__(self):
        """__repr__(Vector3D self) -> std::string"""
        return _IMP_algebra.Vector3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector3D self, Vector3D arg2) -> int"""
        return _IMP_algebra.Vector3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector3D self, Vector3D arg2) -> bool"""
        return _IMP_algebra.Vector3D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector3D
    __del__ = lambda self : None;
Vector3D_swigregister = _IMP_algebra.Vector3D_swigregister
Vector3D_swigregister(Vector3D)

class Vector4D(_VectorBase4D):
    """Proxy of C++ IMP::algebra::VectorD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector4D self) -> Vector4D"""
        return _IMP_algebra.Vector4D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector4D self, double s) -> Vector4D"""
        return _IMP_algebra.Vector4D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector4D self) -> Vector4D"""
        return _IMP_algebra.Vector4D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector4D self, Vector4D o) -> Vector4D"""
        return _IMP_algebra.Vector4D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector4D self, Vector4D ret) -> Vector4D"""
        return _IMP_algebra.Vector4D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector4D self, double s) -> Vector4D
        __mul__(Vector4D self, Vector4D o) -> double
        """
        return _IMP_algebra.Vector4D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(4)> self, IMP::Floats const & f) -> Vector4D
        __init__(IMP::algebra::VectorD<(4)> self) -> Vector4D
        __init__(IMP::algebra::VectorD<(4)> self, double x0, double x1, double x2, double x3) -> Vector4D
        """
        this = _IMP_algebra.new_Vector4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector4D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector4D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector4D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector4D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector4D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector4D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector4D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector4D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector4D self) -> unsigned int"""
        return _IMP_algebra.Vector4D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector4D self, double f) -> Vector4D"""
        return _IMP_algebra.Vector4D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector4D self) -> std::string"""
        return _IMP_algebra.Vector4D___str__(self)

    def __repr__(self):
        """__repr__(Vector4D self) -> std::string"""
        return _IMP_algebra.Vector4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector4D self, Vector4D arg2) -> int"""
        return _IMP_algebra.Vector4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector4D self, Vector4D arg2) -> bool"""
        return _IMP_algebra.Vector4D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector4D
    __del__ = lambda self : None;
Vector4D_swigregister = _IMP_algebra.Vector4D_swigregister
Vector4D_swigregister(Vector4D)

class Vector5D(_VectorBase5D):
    """Proxy of C++ IMP::algebra::VectorD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector5D self) -> Vector5D"""
        return _IMP_algebra.Vector5D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector5D self, double s) -> Vector5D"""
        return _IMP_algebra.Vector5D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector5D self) -> Vector5D"""
        return _IMP_algebra.Vector5D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector5D self, Vector5D o) -> Vector5D"""
        return _IMP_algebra.Vector5D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector5D self, Vector5D ret) -> Vector5D"""
        return _IMP_algebra.Vector5D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector5D self, double s) -> Vector5D
        __mul__(Vector5D self, Vector5D o) -> double
        """
        return _IMP_algebra.Vector5D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(5)> self, IMP::Floats const & f) -> Vector5D
        __init__(IMP::algebra::VectorD<(5)> self) -> Vector5D
        __init__(IMP::algebra::VectorD<(5)> self, double x0, double x1, double x2, double x3, double x4) -> Vector5D
        """
        this = _IMP_algebra.new_Vector5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector5D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector5D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector5D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector5D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector5D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector5D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector5D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector5D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector5D self) -> unsigned int"""
        return _IMP_algebra.Vector5D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector5D self, double f) -> Vector5D"""
        return _IMP_algebra.Vector5D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector5D self) -> std::string"""
        return _IMP_algebra.Vector5D___str__(self)

    def __repr__(self):
        """__repr__(Vector5D self) -> std::string"""
        return _IMP_algebra.Vector5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector5D self, Vector5D arg2) -> int"""
        return _IMP_algebra.Vector5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector5D self, Vector5D arg2) -> bool"""
        return _IMP_algebra.Vector5D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector5D
    __del__ = lambda self : None;
Vector5D_swigregister = _IMP_algebra.Vector5D_swigregister
Vector5D_swigregister(Vector5D)

class Vector6D(_VectorBase6D):
    """Proxy of C++ IMP::algebra::VectorD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(Vector6D self) -> Vector6D"""
        return _IMP_algebra.Vector6D_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(Vector6D self, double s) -> Vector6D"""
        return _IMP_algebra.Vector6D___div__(self, *args)

    def __neg__(self):
        """__neg__(Vector6D self) -> Vector6D"""
        return _IMP_algebra.Vector6D___neg__(self)

    def __sub__(self, *args):
        """__sub__(Vector6D self, Vector6D o) -> Vector6D"""
        return _IMP_algebra.Vector6D___sub__(self, *args)

    def __add__(self, *args):
        """__add__(Vector6D self, Vector6D ret) -> Vector6D"""
        return _IMP_algebra.Vector6D___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(Vector6D self, double s) -> Vector6D
        __mul__(Vector6D self, Vector6D o) -> double
        """
        return _IMP_algebra.Vector6D___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(6)> self, IMP::Floats const & f) -> Vector6D
        __init__(IMP::algebra::VectorD<(6)> self) -> Vector6D
        __init__(IMP::algebra::VectorD<(6)> self, double x0, double x1, double x2, double x3, double x4, double x5) -> Vector6D
        """
        this = _IMP_algebra.new_Vector6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(Vector6D self, unsigned int index) -> double"""
        return _IMP_algebra.Vector6D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(Vector6D self, unsigned int index, double val)"""
        return _IMP_algebra.Vector6D___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.Vector6D___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.Vector6D___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.Vector6D___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.Vector6D___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(Vector6D self) -> unsigned int"""
        return _IMP_algebra.Vector6D___len__(self)

    def __rmul__(self, *args):
        """__rmul__(Vector6D self, double f) -> Vector6D"""
        return _IMP_algebra.Vector6D___rmul__(self, *args)

    def __str__(self):
        """__str__(Vector6D self) -> std::string"""
        return _IMP_algebra.Vector6D___str__(self)

    def __repr__(self):
        """__repr__(Vector6D self) -> std::string"""
        return _IMP_algebra.Vector6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Vector6D self, Vector6D arg2) -> int"""
        return _IMP_algebra.Vector6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Vector6D self, Vector6D arg2) -> bool"""
        return _IMP_algebra.Vector6D___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_Vector6D
    __del__ = lambda self : None;
Vector6D_swigregister = _IMP_algebra.Vector6D_swigregister
Vector6D_swigregister(Vector6D)

class VectorKD(_VectorBaseKD):
    """Proxy of C++ IMP::algebra::VectorD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_unit_vector(self):
        """get_unit_vector(VectorKD self) -> VectorKD"""
        return _IMP_algebra.VectorKD_get_unit_vector(self)

    def __div__(self, *args):
        """__div__(VectorKD self, double s) -> VectorKD"""
        return _IMP_algebra.VectorKD___div__(self, *args)

    def __neg__(self):
        """__neg__(VectorKD self) -> VectorKD"""
        return _IMP_algebra.VectorKD___neg__(self)

    def __sub__(self, *args):
        """__sub__(VectorKD self, VectorKD o) -> VectorKD"""
        return _IMP_algebra.VectorKD___sub__(self, *args)

    def __add__(self, *args):
        """__add__(VectorKD self, VectorKD ret) -> VectorKD"""
        return _IMP_algebra.VectorKD___add__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(VectorKD self, double s) -> VectorKD
        __mul__(VectorKD self, VectorKD o) -> double
        """
        return _IMP_algebra.VectorKD___mul__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::VectorD<(-1)> self, IMP::Floats const & f) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max(), 
            double x3=std::numeric_limits< double >::max(), double x4=std::numeric_limits< double >::max(), 
            double x5=std::numeric_limits< double >::max()) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max(), 
            double x3=std::numeric_limits< double >::max(), double x4=std::numeric_limits< double >::max()) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max(), 
            double x3=std::numeric_limits< double >::max()) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max()) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1=std::numeric_limits< double >::max()) -> VectorKD
        __init__(IMP::algebra::VectorD<(-1)> self, double x0) -> VectorKD
        """
        this = _IMP_algebra.new_VectorKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(VectorKD self, unsigned int index) -> double"""
        return _IMP_algebra.VectorKD___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(VectorKD self, unsigned int index, double val)"""
        return _IMP_algebra.VectorKD___setitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.VectorKD___iadd__(self, *args)
        return self


    def __imul__(self, *args):
        _IMP_algebra.VectorKD___imul__(self, *args)
        return self


    def __idiv__(self, *args):
        _IMP_algebra.VectorKD___idiv__(self, *args)
        return self


    def __isub__(self, *args):
        _IMP_algebra.VectorKD___isub__(self, *args)
        return self


    def __len__(self):
        """__len__(VectorKD self) -> unsigned int"""
        return _IMP_algebra.VectorKD___len__(self)

    def __rmul__(self, *args):
        """__rmul__(VectorKD self, double f) -> VectorKD"""
        return _IMP_algebra.VectorKD___rmul__(self, *args)

    def __str__(self):
        """__str__(VectorKD self) -> std::string"""
        return _IMP_algebra.VectorKD___str__(self)

    def __repr__(self):
        """__repr__(VectorKD self) -> std::string"""
        return _IMP_algebra.VectorKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(VectorKD self, VectorKD arg2) -> int"""
        return _IMP_algebra.VectorKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(VectorKD self, VectorKD arg2) -> bool"""
        return _IMP_algebra.VectorKD___eq__(self, *args)

    __truediv__ = __div__
    __itruediv__ = __idiv__

    __swig_destroy__ = _IMP_algebra.delete_VectorKD
    __del__ = lambda self : None;
VectorKD_swigregister = _IMP_algebra.VectorKD_swigregister
VectorKD_swigregister(VectorKD)

class BoundingBox1D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox1D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox1D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox1D self, unsigned int i) -> Vector1D"""
        return _IMP_algebra.BoundingBox1D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox1D self, Vector1D o) -> bool
        get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
        """
        return _IMP_algebra.BoundingBox1D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox1D self, _ostream out=std::cout)
        show(BoundingBox1D self)
        """
        return _IMP_algebra.BoundingBox1D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox1D self) -> std::string"""
        return _IMP_algebra.BoundingBox1D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox1D self) -> std::string"""
        return _IMP_algebra.BoundingBox1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
        return _IMP_algebra.BoundingBox1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
        return _IMP_algebra.BoundingBox1D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(1)> self, unsigned int d) -> BoundingBox1D
        __init__(IMP::algebra::BoundingBoxD<(1)> self, Vector1D lb, Vector1D ub) -> BoundingBox1D
        __init__(IMP::algebra::BoundingBoxD<(1)> self, Vector1D v) -> BoundingBox1D
        __init__(IMP::algebra::BoundingBoxD<(1)> self, IMP::base::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
        __init__(IMP::algebra::BoundingBoxD<(1)> self) -> BoundingBox1D
        """
        this = _IMP_algebra.new_BoundingBox1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
        return _IMP_algebra.BoundingBox1D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox1D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox1D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox1D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
        __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
        __add__(BoundingBox1D self, double o) -> BoundingBox1D
        """
        return _IMP_algebra.BoundingBox1D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
    __del__ = lambda self : None;
BoundingBox1D_swigregister = _IMP_algebra.BoundingBox1D_swigregister
BoundingBox1D_swigregister(BoundingBox1D)

class BoundingBox2D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox2D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox2D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox2D self, unsigned int i) -> Vector2D"""
        return _IMP_algebra.BoundingBox2D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox2D self, Vector2D o) -> bool
        get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
        """
        return _IMP_algebra.BoundingBox2D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox2D self, _ostream out=std::cout)
        show(BoundingBox2D self)
        """
        return _IMP_algebra.BoundingBox2D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox2D self) -> std::string"""
        return _IMP_algebra.BoundingBox2D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox2D self) -> std::string"""
        return _IMP_algebra.BoundingBox2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
        return _IMP_algebra.BoundingBox2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
        return _IMP_algebra.BoundingBox2D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(2)> self, unsigned int d) -> BoundingBox2D
        __init__(IMP::algebra::BoundingBoxD<(2)> self, Vector2D lb, Vector2D ub) -> BoundingBox2D
        __init__(IMP::algebra::BoundingBoxD<(2)> self, Vector2D v) -> BoundingBox2D
        __init__(IMP::algebra::BoundingBoxD<(2)> self, IMP::base::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
        __init__(IMP::algebra::BoundingBoxD<(2)> self) -> BoundingBox2D
        """
        this = _IMP_algebra.new_BoundingBox2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
        return _IMP_algebra.BoundingBox2D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox2D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox2D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox2D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
        __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
        __add__(BoundingBox2D self, double o) -> BoundingBox2D
        """
        return _IMP_algebra.BoundingBox2D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
    __del__ = lambda self : None;
BoundingBox2D_swigregister = _IMP_algebra.BoundingBox2D_swigregister
BoundingBox2D_swigregister(BoundingBox2D)

class BoundingBox3D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox3D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox3D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox3D self, unsigned int i) -> Vector3D"""
        return _IMP_algebra.BoundingBox3D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox3D self, Vector3D o) -> bool
        get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
        """
        return _IMP_algebra.BoundingBox3D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox3D self, _ostream out=std::cout)
        show(BoundingBox3D self)
        """
        return _IMP_algebra.BoundingBox3D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox3D self) -> std::string"""
        return _IMP_algebra.BoundingBox3D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox3D self) -> std::string"""
        return _IMP_algebra.BoundingBox3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
        return _IMP_algebra.BoundingBox3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
        return _IMP_algebra.BoundingBox3D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(3)> self, unsigned int d) -> BoundingBox3D
        __init__(IMP::algebra::BoundingBoxD<(3)> self, Vector3D lb, Vector3D ub) -> BoundingBox3D
        __init__(IMP::algebra::BoundingBoxD<(3)> self, Vector3D v) -> BoundingBox3D
        __init__(IMP::algebra::BoundingBoxD<(3)> self, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
        __init__(IMP::algebra::BoundingBoxD<(3)> self) -> BoundingBox3D
        """
        this = _IMP_algebra.new_BoundingBox3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
        return _IMP_algebra.BoundingBox3D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox3D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox3D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox3D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
        __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
        __add__(BoundingBox3D self, double o) -> BoundingBox3D
        """
        return _IMP_algebra.BoundingBox3D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
    __del__ = lambda self : None;
BoundingBox3D_swigregister = _IMP_algebra.BoundingBox3D_swigregister
BoundingBox3D_swigregister(BoundingBox3D)

class BoundingBox4D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox4D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox4D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox4D self, unsigned int i) -> Vector4D"""
        return _IMP_algebra.BoundingBox4D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox4D self, Vector4D o) -> bool
        get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
        """
        return _IMP_algebra.BoundingBox4D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox4D self, _ostream out=std::cout)
        show(BoundingBox4D self)
        """
        return _IMP_algebra.BoundingBox4D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox4D self) -> std::string"""
        return _IMP_algebra.BoundingBox4D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox4D self) -> std::string"""
        return _IMP_algebra.BoundingBox4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
        return _IMP_algebra.BoundingBox4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
        return _IMP_algebra.BoundingBox4D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(4)> self, unsigned int d) -> BoundingBox4D
        __init__(IMP::algebra::BoundingBoxD<(4)> self, Vector4D lb, Vector4D ub) -> BoundingBox4D
        __init__(IMP::algebra::BoundingBoxD<(4)> self, Vector4D v) -> BoundingBox4D
        __init__(IMP::algebra::BoundingBoxD<(4)> self, IMP::base::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
        __init__(IMP::algebra::BoundingBoxD<(4)> self) -> BoundingBox4D
        """
        this = _IMP_algebra.new_BoundingBox4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
        return _IMP_algebra.BoundingBox4D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox4D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox4D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox4D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
        __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
        __add__(BoundingBox4D self, double o) -> BoundingBox4D
        """
        return _IMP_algebra.BoundingBox4D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
    __del__ = lambda self : None;
BoundingBox4D_swigregister = _IMP_algebra.BoundingBox4D_swigregister
BoundingBox4D_swigregister(BoundingBox4D)

class BoundingBox5D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox5D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox5D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox5D self, unsigned int i) -> Vector5D"""
        return _IMP_algebra.BoundingBox5D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox5D self, Vector5D o) -> bool
        get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
        """
        return _IMP_algebra.BoundingBox5D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox5D self, _ostream out=std::cout)
        show(BoundingBox5D self)
        """
        return _IMP_algebra.BoundingBox5D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox5D self) -> std::string"""
        return _IMP_algebra.BoundingBox5D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox5D self) -> std::string"""
        return _IMP_algebra.BoundingBox5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
        return _IMP_algebra.BoundingBox5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
        return _IMP_algebra.BoundingBox5D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(5)> self, unsigned int d) -> BoundingBox5D
        __init__(IMP::algebra::BoundingBoxD<(5)> self, Vector5D lb, Vector5D ub) -> BoundingBox5D
        __init__(IMP::algebra::BoundingBoxD<(5)> self, Vector5D v) -> BoundingBox5D
        __init__(IMP::algebra::BoundingBoxD<(5)> self, IMP::base::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
        __init__(IMP::algebra::BoundingBoxD<(5)> self) -> BoundingBox5D
        """
        this = _IMP_algebra.new_BoundingBox5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
        return _IMP_algebra.BoundingBox5D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox5D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox5D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox5D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
        __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
        __add__(BoundingBox5D self, double o) -> BoundingBox5D
        """
        return _IMP_algebra.BoundingBox5D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D
    __del__ = lambda self : None;
BoundingBox5D_swigregister = _IMP_algebra.BoundingBox5D_swigregister
BoundingBox5D_swigregister(BoundingBox5D)

class BoundingBox6D(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBox6D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox6D_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBox6D self, unsigned int i) -> Vector6D"""
        return _IMP_algebra.BoundingBox6D_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBox6D self, Vector6D o) -> bool
        get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
        """
        return _IMP_algebra.BoundingBox6D_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBox6D self, _ostream out=std::cout)
        show(BoundingBox6D self)
        """
        return _IMP_algebra.BoundingBox6D_show(self, *args)

    def __str__(self):
        """__str__(BoundingBox6D self) -> std::string"""
        return _IMP_algebra.BoundingBox6D___str__(self)

    def __repr__(self):
        """__repr__(BoundingBox6D self) -> std::string"""
        return _IMP_algebra.BoundingBox6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
        return _IMP_algebra.BoundingBox6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
        return _IMP_algebra.BoundingBox6D___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(6)> self, unsigned int d) -> BoundingBox6D
        __init__(IMP::algebra::BoundingBoxD<(6)> self, Vector6D lb, Vector6D ub) -> BoundingBox6D
        __init__(IMP::algebra::BoundingBoxD<(6)> self, Vector6D v) -> BoundingBox6D
        __init__(IMP::algebra::BoundingBoxD<(6)> self, IMP::base::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
        __init__(IMP::algebra::BoundingBoxD<(6)> self) -> BoundingBox6D
        """
        this = _IMP_algebra.new_BoundingBox6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
        return _IMP_algebra.BoundingBox6D___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBox6D___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBox6D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox6D___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
        __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
        __add__(BoundingBox6D self, double o) -> BoundingBox6D
        """
        return _IMP_algebra.BoundingBox6D___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
    __del__ = lambda self : None;
BoundingBox6D_swigregister = _IMP_algebra.BoundingBox6D_swigregister
BoundingBox6D_swigregister(BoundingBox6D)

class BoundingBoxKD(object):
    """Proxy of C++ IMP::algebra::BoundingBoxD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_dimension(self):
        """get_dimension(BoundingBoxKD self) -> unsigned int"""
        return _IMP_algebra.BoundingBoxKD_get_dimension(self)

    def get_corner(self, *args):
        """get_corner(BoundingBoxKD self, unsigned int i) -> VectorKD"""
        return _IMP_algebra.BoundingBoxKD_get_corner(self, *args)

    def get_contains(self, *args):
        """
        get_contains(BoundingBoxKD self, VectorKD o) -> bool
        get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
        """
        return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)

    def show(self, *args):
        """
        show(BoundingBoxKD self, _ostream out=std::cout)
        show(BoundingBoxKD self)
        """
        return _IMP_algebra.BoundingBoxKD_show(self, *args)

    def __str__(self):
        """__str__(BoundingBoxKD self) -> std::string"""
        return _IMP_algebra.BoundingBoxKD___str__(self)

    def __repr__(self):
        """__repr__(BoundingBoxKD self) -> std::string"""
        return _IMP_algebra.BoundingBoxKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
        return _IMP_algebra.BoundingBoxKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
        return _IMP_algebra.BoundingBoxKD___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundingBoxD<(-1)> self, unsigned int d) -> BoundingBoxKD
        __init__(IMP::algebra::BoundingBoxD<(-1)> self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
        __init__(IMP::algebra::BoundingBoxD<(-1)> self, VectorKD v) -> BoundingBoxKD
        __init__(IMP::algebra::BoundingBoxD<(-1)> self, IMP::base::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
        __init__(IMP::algebra::BoundingBoxD<(-1)> self) -> BoundingBoxKD
        """
        this = _IMP_algebra.new_BoundingBoxKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
        return _IMP_algebra.BoundingBoxKD___getitem__(self, *args)

    def __iadd__(self, *args):
        _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
        return self


    def __len__(self):
        """__len__(BoundingBoxKD self) -> unsigned int"""
        return _IMP_algebra.BoundingBoxKD___len__(self)

    def __add__(self, *args):
        """
        __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
        __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
        __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
        """
        return _IMP_algebra.BoundingBoxKD___add__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
    __del__ = lambda self : None;
BoundingBoxKD_swigregister = _IMP_algebra.BoundingBoxKD_swigregister
BoundingBoxKD_swigregister(BoundingBoxKD)

class Sphere1D(_GeometricPrimitive1D):
    """Proxy of C++ IMP::algebra::SphereD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(1)> self) -> Sphere1D
        __init__(IMP::algebra::SphereD<(1)> self, Vector1D center, double radius) -> Sphere1D
        """
        this = _IMP_algebra.new_Sphere1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere1D self) -> double"""
        return _IMP_algebra.Sphere1D_get_radius(self)

    def get_center(self):
        """get_center(Sphere1D self) -> Vector1D"""
        return _IMP_algebra.Sphere1D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere1D self, Sphere1D o) -> bool
        get_contains(Sphere1D self, Vector1D p) -> bool
        """
        return _IMP_algebra.Sphere1D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere1D self, _ostream out=std::cout)
        show(Sphere1D self)
        """
        return _IMP_algebra.Sphere1D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere1D self) -> unsigned int"""
        return _IMP_algebra.Sphere1D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere1D self) -> std::string"""
        return _IMP_algebra.Sphere1D___str__(self)

    def __repr__(self):
        """__repr__(Sphere1D self) -> std::string"""
        return _IMP_algebra.Sphere1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
        return _IMP_algebra.Sphere1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
        return _IMP_algebra.Sphere1D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere1D
    __del__ = lambda self : None;
Sphere1D_swigregister = _IMP_algebra.Sphere1D_swigregister
Sphere1D_swigregister(Sphere1D)

class Sphere2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::SphereD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(2)> self) -> Sphere2D
        __init__(IMP::algebra::SphereD<(2)> self, Vector2D center, double radius) -> Sphere2D
        """
        this = _IMP_algebra.new_Sphere2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere2D self) -> double"""
        return _IMP_algebra.Sphere2D_get_radius(self)

    def get_center(self):
        """get_center(Sphere2D self) -> Vector2D"""
        return _IMP_algebra.Sphere2D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere2D self, Sphere2D o) -> bool
        get_contains(Sphere2D self, Vector2D p) -> bool
        """
        return _IMP_algebra.Sphere2D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere2D self, _ostream out=std::cout)
        show(Sphere2D self)
        """
        return _IMP_algebra.Sphere2D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere2D self) -> unsigned int"""
        return _IMP_algebra.Sphere2D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere2D self) -> std::string"""
        return _IMP_algebra.Sphere2D___str__(self)

    def __repr__(self):
        """__repr__(Sphere2D self) -> std::string"""
        return _IMP_algebra.Sphere2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
        return _IMP_algebra.Sphere2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
        return _IMP_algebra.Sphere2D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere2D
    __del__ = lambda self : None;
Sphere2D_swigregister = _IMP_algebra.Sphere2D_swigregister
Sphere2D_swigregister(Sphere2D)

class Sphere3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::SphereD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(3)> self) -> Sphere3D
        __init__(IMP::algebra::SphereD<(3)> self, Vector3D center, double radius) -> Sphere3D
        """
        this = _IMP_algebra.new_Sphere3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere3D self) -> double"""
        return _IMP_algebra.Sphere3D_get_radius(self)

    def get_center(self):
        """get_center(Sphere3D self) -> Vector3D"""
        return _IMP_algebra.Sphere3D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere3D self, Sphere3D o) -> bool
        get_contains(Sphere3D self, Vector3D p) -> bool
        """
        return _IMP_algebra.Sphere3D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere3D self, _ostream out=std::cout)
        show(Sphere3D self)
        """
        return _IMP_algebra.Sphere3D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere3D self) -> unsigned int"""
        return _IMP_algebra.Sphere3D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere3D self) -> std::string"""
        return _IMP_algebra.Sphere3D___str__(self)

    def __repr__(self):
        """__repr__(Sphere3D self) -> std::string"""
        return _IMP_algebra.Sphere3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
        return _IMP_algebra.Sphere3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
        return _IMP_algebra.Sphere3D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere3D
    __del__ = lambda self : None;
Sphere3D_swigregister = _IMP_algebra.Sphere3D_swigregister
Sphere3D_swigregister(Sphere3D)

class Sphere4D(_GeometricPrimitive4D):
    """Proxy of C++ IMP::algebra::SphereD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(4)> self) -> Sphere4D
        __init__(IMP::algebra::SphereD<(4)> self, Vector4D center, double radius) -> Sphere4D
        """
        this = _IMP_algebra.new_Sphere4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere4D self) -> double"""
        return _IMP_algebra.Sphere4D_get_radius(self)

    def get_center(self):
        """get_center(Sphere4D self) -> Vector4D"""
        return _IMP_algebra.Sphere4D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere4D self, Sphere4D o) -> bool
        get_contains(Sphere4D self, Vector4D p) -> bool
        """
        return _IMP_algebra.Sphere4D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere4D self, _ostream out=std::cout)
        show(Sphere4D self)
        """
        return _IMP_algebra.Sphere4D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere4D self) -> unsigned int"""
        return _IMP_algebra.Sphere4D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere4D self) -> std::string"""
        return _IMP_algebra.Sphere4D___str__(self)

    def __repr__(self):
        """__repr__(Sphere4D self) -> std::string"""
        return _IMP_algebra.Sphere4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
        return _IMP_algebra.Sphere4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
        return _IMP_algebra.Sphere4D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere4D
    __del__ = lambda self : None;
Sphere4D_swigregister = _IMP_algebra.Sphere4D_swigregister
Sphere4D_swigregister(Sphere4D)

class Sphere5D(_GeometricPrimitive5D):
    """Proxy of C++ IMP::algebra::SphereD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(5)> self) -> Sphere5D
        __init__(IMP::algebra::SphereD<(5)> self, Vector5D center, double radius) -> Sphere5D
        """
        this = _IMP_algebra.new_Sphere5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere5D self) -> double"""
        return _IMP_algebra.Sphere5D_get_radius(self)

    def get_center(self):
        """get_center(Sphere5D self) -> Vector5D"""
        return _IMP_algebra.Sphere5D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere5D self, Sphere5D o) -> bool
        get_contains(Sphere5D self, Vector5D p) -> bool
        """
        return _IMP_algebra.Sphere5D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere5D self, _ostream out=std::cout)
        show(Sphere5D self)
        """
        return _IMP_algebra.Sphere5D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere5D self) -> unsigned int"""
        return _IMP_algebra.Sphere5D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere5D self) -> std::string"""
        return _IMP_algebra.Sphere5D___str__(self)

    def __repr__(self):
        """__repr__(Sphere5D self) -> std::string"""
        return _IMP_algebra.Sphere5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
        return _IMP_algebra.Sphere5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
        return _IMP_algebra.Sphere5D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere5D
    __del__ = lambda self : None;
Sphere5D_swigregister = _IMP_algebra.Sphere5D_swigregister
Sphere5D_swigregister(Sphere5D)

class Sphere6D(_GeometricPrimitive6D):
    """Proxy of C++ IMP::algebra::SphereD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(6)> self) -> Sphere6D
        __init__(IMP::algebra::SphereD<(6)> self, Vector6D center, double radius) -> Sphere6D
        """
        this = _IMP_algebra.new_Sphere6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Sphere6D self) -> double"""
        return _IMP_algebra.Sphere6D_get_radius(self)

    def get_center(self):
        """get_center(Sphere6D self) -> Vector6D"""
        return _IMP_algebra.Sphere6D_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(Sphere6D self, Sphere6D o) -> bool
        get_contains(Sphere6D self, Vector6D p) -> bool
        """
        return _IMP_algebra.Sphere6D_get_contains(self, *args)

    def show(self, *args):
        """
        show(Sphere6D self, _ostream out=std::cout)
        show(Sphere6D self)
        """
        return _IMP_algebra.Sphere6D_show(self, *args)

    def get_dimension(self):
        """get_dimension(Sphere6D self) -> unsigned int"""
        return _IMP_algebra.Sphere6D_get_dimension(self)

    def __str__(self):
        """__str__(Sphere6D self) -> std::string"""
        return _IMP_algebra.Sphere6D___str__(self)

    def __repr__(self):
        """__repr__(Sphere6D self) -> std::string"""
        return _IMP_algebra.Sphere6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
        return _IMP_algebra.Sphere6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
        return _IMP_algebra.Sphere6D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_Sphere6D
    __del__ = lambda self : None;
Sphere6D_swigregister = _IMP_algebra.Sphere6D_swigregister
Sphere6D_swigregister(Sphere6D)

class SphereKD(_GeometricPrimitiveKD):
    """Proxy of C++ IMP::algebra::SphereD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphereD<(-1)> self) -> SphereKD
        __init__(IMP::algebra::SphereD<(-1)> self, VectorKD center, double radius) -> SphereKD
        """
        this = _IMP_algebra.new_SphereKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(SphereKD self) -> double"""
        return _IMP_algebra.SphereKD_get_radius(self)

    def get_center(self):
        """get_center(SphereKD self) -> VectorKD"""
        return _IMP_algebra.SphereKD_get_center(self)

    def get_contains(self, *args):
        """
        get_contains(SphereKD self, SphereKD o) -> bool
        get_contains(SphereKD self, VectorKD p) -> bool
        """
        return _IMP_algebra.SphereKD_get_contains(self, *args)

    def show(self, *args):
        """
        show(SphereKD self, _ostream out=std::cout)
        show(SphereKD self)
        """
        return _IMP_algebra.SphereKD_show(self, *args)

    def get_dimension(self):
        """get_dimension(SphereKD self) -> unsigned int"""
        return _IMP_algebra.SphereKD_get_dimension(self)

    def __str__(self):
        """__str__(SphereKD self) -> std::string"""
        return _IMP_algebra.SphereKD___str__(self)

    def __repr__(self):
        """__repr__(SphereKD self) -> std::string"""
        return _IMP_algebra.SphereKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(SphereKD self, SphereKD arg2) -> int"""
        return _IMP_algebra.SphereKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(SphereKD self, SphereKD arg2) -> bool"""
        return _IMP_algebra.SphereKD___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_SphereKD
    __del__ = lambda self : None;
SphereKD_swigregister = _IMP_algebra.SphereKD_swigregister
SphereKD_swigregister(SphereKD)

class ReferenceFrame3D(object):
    """Proxy of C++ IMP::algebra::ReferenceFrame3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ReferenceFrame3D self) -> ReferenceFrame3D
        __init__(IMP::algebra::ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
        """
        this = _IMP_algebra.new_ReferenceFrame3D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
    __del__ = lambda self : None;
    def get_transformation_to(self):
        """get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
        return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)

    def get_transformation_from(self):
        """get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
        return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)

    def get_global_coordinates(self, *args):
        """get_global_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
        return _IMP_algebra.ReferenceFrame3D_get_global_coordinates(self, *args)

    def get_local_coordinates(self, *args):
        """get_local_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
        return _IMP_algebra.ReferenceFrame3D_get_local_coordinates(self, *args)

    def get_global_reference_frame(self, *args):
        """get_global_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
        return _IMP_algebra.ReferenceFrame3D_get_global_reference_frame(self, *args)

    def get_local_reference_frame(self, *args):
        """get_local_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
        return _IMP_algebra.ReferenceFrame3D_get_local_reference_frame(self, *args)

    def show(self, *args):
        """
        show(ReferenceFrame3D self, _ostream out=std::cout)
        show(ReferenceFrame3D self)
        """
        return _IMP_algebra.ReferenceFrame3D_show(self, *args)

    def __str__(self):
        """__str__(ReferenceFrame3D self) -> std::string"""
        return _IMP_algebra.ReferenceFrame3D___str__(self)

    def __repr__(self):
        """__repr__(ReferenceFrame3D self) -> std::string"""
        return _IMP_algebra.ReferenceFrame3D___repr__(self)

ReferenceFrame3D_swigregister = _IMP_algebra.ReferenceFrame3D_swigregister
ReferenceFrame3D_swigregister(ReferenceFrame3D)


def get_transformed(*args):
  """
    get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
    get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
    """
  return _IMP_algebra.get_transformed(*args)

def get_transformation_from_first_to_second(*args):
  """get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
  return _IMP_algebra.get_transformation_from_first_to_second(*args)
class SphericalVector3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::SphericalVector3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SphericalVector3D self) -> SphericalVector3D
        __init__(IMP::algebra::SphericalVector3D self, Vector3D v) -> SphericalVector3D
        __init__(IMP::algebra::SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
        __init__(IMP::algebra::SphericalVector3D self, double r, double theta, double psi) -> SphericalVector3D
        """
        this = _IMP_algebra.new_SphericalVector3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_cartesian_coordinates(self):
        """get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
        return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)

    def show(self, *args):
        """
        show(SphericalVector3D self, _ostream out=std::cout)
        show(SphericalVector3D self)
        """
        return _IMP_algebra.SphericalVector3D_show(self, *args)

    def __str__(self):
        """__str__(SphericalVector3D self) -> std::string"""
        return _IMP_algebra.SphericalVector3D___str__(self)

    def __repr__(self):
        """__repr__(SphericalVector3D self) -> std::string"""
        return _IMP_algebra.SphericalVector3D___repr__(self)

    def __getitem__(self, *args):
        """__getitem__(SphericalVector3D self, unsigned int index) -> double"""
        return _IMP_algebra.SphericalVector3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(SphericalVector3D self, unsigned int index, double val)"""
        return _IMP_algebra.SphericalVector3D___setitem__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D
    __del__ = lambda self : None;
SphericalVector3D_swigregister = _IMP_algebra.SphericalVector3D_swigregister
SphericalVector3D_swigregister(SphericalVector3D)


def get_alignments_from_first_to_second(*args):
  """get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
  return _IMP_algebra.get_alignments_from_first_to_second(*args)
class Segment3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Segment3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Segment3D self) -> Segment3D
        __init__(IMP::algebra::Segment3D self, Vector3D start, Vector3D end) -> Segment3D
        """
        this = _IMP_algebra.new_Segment3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_point(self, i):
        if i < 0 or i >= 2:
            raise IMP.base.UsageException("Invalid point index")
        return _IMP_algebra.Segment3D_get_point(self, i)


    def get_middle_point(self):
        """get_middle_point(Segment3D self) -> Vector3D"""
        return _IMP_algebra.Segment3D_get_middle_point(self)

    def get_direction(self):
        """get_direction(Segment3D self) -> Vector3D"""
        return _IMP_algebra.Segment3D_get_direction(self)

    def get_length(self):
        """get_length(Segment3D self) -> double"""
        return _IMP_algebra.Segment3D_get_length(self)

    def show(self, *args):
        """
        show(Segment3D self, _ostream out=std::cout)
        show(Segment3D self)
        """
        return _IMP_algebra.Segment3D_show(self, *args)

    def __str__(self):
        """__str__(Segment3D self) -> std::string"""
        return _IMP_algebra.Segment3D___str__(self)

    def __repr__(self):
        """__repr__(Segment3D self) -> std::string"""
        return _IMP_algebra.Segment3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Segment3D
    __del__ = lambda self : None;
Segment3D_swigregister = _IMP_algebra.Segment3D_swigregister
Segment3D_swigregister(Segment3D)


def get_segment_3d_geometry(*args):
  """get_segment_3d_geometry(Segment3D g) -> Segment3D"""
  return _IMP_algebra.get_segment_3d_geometry(*args)

def get_relative_projection_on_segment(*args):
  """get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
  return _IMP_algebra.get_relative_projection_on_segment(*args)
class Triangle3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Triangle3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Triangle3D self) -> Triangle3D
        __init__(IMP::algebra::Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
        """
        this = _IMP_algebra.new_Triangle3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_point(self, *args):
        """get_point(Triangle3D self, unsigned int i) -> Vector3D"""
        return _IMP_algebra.Triangle3D_get_point(self, *args)

    def show(self, *args):
        """
        show(Triangle3D self, _ostream out=std::cout)
        show(Triangle3D self)
        """
        return _IMP_algebra.Triangle3D_show(self, *args)

    def get_edge_lengths(self):
        """get_edge_lengths(Triangle3D self) -> IMP::Floats"""
        return _IMP_algebra.Triangle3D_get_edge_lengths(self)

    def __str__(self):
        """__str__(Triangle3D self) -> std::string"""
        return _IMP_algebra.Triangle3D___str__(self)

    def __repr__(self):
        """__repr__(Triangle3D self) -> std::string"""
        return _IMP_algebra.Triangle3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Triangle3D
    __del__ = lambda self : None;
Triangle3D_swigregister = _IMP_algebra.Triangle3D_swigregister
Triangle3D_swigregister(Triangle3D)


def get_largest_triangle(*args):
  """get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
  return _IMP_algebra.get_largest_triangle(*args)

def get_transformation_from_first_triangle_to_second(*args):
  """get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri) -> Transformation3D"""
  return _IMP_algebra.get_transformation_from_first_triangle_to_second(*args)

def get_are_colinear(*args):
  """get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
  return _IMP_algebra.get_are_colinear(*args)
class LinearFit2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::LinearFit2D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
        __init__(IMP::algebra::LinearFit2D self, IMP::algebra::Vector2Ds const & data) -> LinearFit2D
        """
        this = _IMP_algebra.new_LinearFit2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_fit_error(self):
        """get_fit_error(LinearFit2D self) -> double"""
        return _IMP_algebra.LinearFit2D_get_fit_error(self)

    def get_a(self):
        """get_a(LinearFit2D self) -> double"""
        return _IMP_algebra.LinearFit2D_get_a(self)

    def get_b(self):
        """get_b(LinearFit2D self) -> double"""
        return _IMP_algebra.LinearFit2D_get_b(self)

    def show(self, *args):
        """
        show(LinearFit2D self, _ostream out=std::cout)
        show(LinearFit2D self)
        """
        return _IMP_algebra.LinearFit2D_show(self, *args)

    def __str__(self):
        """__str__(LinearFit2D self) -> std::string"""
        return _IMP_algebra.LinearFit2D___str__(self)

    def __repr__(self):
        """__repr__(LinearFit2D self) -> std::string"""
        return _IMP_algebra.LinearFit2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
    __del__ = lambda self : None;
LinearFit2D_swigregister = _IMP_algebra.LinearFit2D_swigregister
LinearFit2D_swigregister(LinearFit2D)

class ParabolicFit2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::ParabolicFit2D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::algebra::ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D"""
        this = _IMP_algebra.new_ParabolicFit2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_fit_error(self):
        """get_fit_error(ParabolicFit2D self) -> double"""
        return _IMP_algebra.ParabolicFit2D_get_fit_error(self)

    def get_a(self):
        """get_a(ParabolicFit2D self) -> double"""
        return _IMP_algebra.ParabolicFit2D_get_a(self)

    def get_b(self):
        """get_b(ParabolicFit2D self) -> double"""
        return _IMP_algebra.ParabolicFit2D_get_b(self)

    def get_c(self):
        """get_c(ParabolicFit2D self) -> double"""
        return _IMP_algebra.ParabolicFit2D_get_c(self)

    def show(self, *args):
        """
        show(ParabolicFit2D self, _ostream out=std::cout)
        show(ParabolicFit2D self)
        """
        return _IMP_algebra.ParabolicFit2D_show(self, *args)

    def __str__(self):
        """__str__(ParabolicFit2D self) -> std::string"""
        return _IMP_algebra.ParabolicFit2D___str__(self)

    def __repr__(self):
        """__repr__(ParabolicFit2D self) -> std::string"""
        return _IMP_algebra.ParabolicFit2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
    __del__ = lambda self : None;
ParabolicFit2D_swigregister = _IMP_algebra.ParabolicFit2D_swigregister
ParabolicFit2D_swigregister(ParabolicFit2D)

class Plane3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Plane3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Plane3D self) -> Plane3D
        __init__(IMP::algebra::Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
        __init__(IMP::algebra::Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
        """
        this = _IMP_algebra.new_Plane3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_point_on_plane(self):
        """get_point_on_plane(Plane3D self) -> Vector3D"""
        return _IMP_algebra.Plane3D_get_point_on_plane(self)

    def get_normal(self):
        """get_normal(Plane3D self) -> Vector3D"""
        return _IMP_algebra.Plane3D_get_normal(self)

    def get_projected(self, *args):
        """get_projected(Plane3D self, Vector3D p) -> Vector3D"""
        return _IMP_algebra.Plane3D_get_projected(self, *args)

    def get_projection(self, *args):
        """get_projection(Plane3D self, Vector3D p) -> Vector3D"""
        return _IMP_algebra.Plane3D_get_projection(self, *args)

    def get_is_above(self, *args):
        """get_is_above(Plane3D self, Vector3D p) -> bool"""
        return _IMP_algebra.Plane3D_get_is_above(self, *args)

    def get_is_below(self, *args):
        """get_is_below(Plane3D self, Vector3D p) -> bool"""
        return _IMP_algebra.Plane3D_get_is_below(self, *args)

    def get_height(self, *args):
        """get_height(Plane3D self, Vector3D p) -> double"""
        return _IMP_algebra.Plane3D_get_height(self, *args)

    def show(self, *args):
        """
        show(Plane3D self, _ostream out=std::cout)
        show(Plane3D self)
        """
        return _IMP_algebra.Plane3D_show(self, *args)

    def get_opposite(self):
        """get_opposite(Plane3D self) -> Plane3D"""
        return _IMP_algebra.Plane3D_get_opposite(self)

    def get_distance_from_origin(self):
        """get_distance_from_origin(Plane3D self) -> double"""
        return _IMP_algebra.Plane3D_get_distance_from_origin(self)

    def __str__(self):
        """__str__(Plane3D self) -> std::string"""
        return _IMP_algebra.Plane3D___str__(self)

    def __repr__(self):
        """__repr__(Plane3D self) -> std::string"""
        return _IMP_algebra.Plane3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Plane3D
    __del__ = lambda self : None;
Plane3D_swigregister = _IMP_algebra.Plane3D_swigregister
Plane3D_swigregister(Plane3D)


def get_reflected(*args):
  """get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
  return _IMP_algebra.get_reflected(*args)

def get_plane_3d_geometry(*args):
  """get_plane_3d_geometry(Plane3D g) -> Plane3D"""
  return _IMP_algebra.get_plane_3d_geometry(*args)
class Reflection3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Reflection3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Reflection3D self) -> Reflection3D
        __init__(IMP::algebra::Reflection3D self, Plane3D pl) -> Reflection3D
        """
        this = _IMP_algebra.new_Reflection3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_reflected(self, *args):
        """get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
        return _IMP_algebra.Reflection3D_get_reflected(self, *args)

    def show(self, *args):
        """
        show(Reflection3D self, _ostream out=std::cout)
        show(Reflection3D self)
        """
        return _IMP_algebra.Reflection3D_show(self, *args)

    def __str__(self):
        """__str__(Reflection3D self) -> std::string"""
        return _IMP_algebra.Reflection3D___str__(self)

    def __repr__(self):
        """__repr__(Reflection3D self) -> std::string"""
        return _IMP_algebra.Reflection3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Reflection3D
    __del__ = lambda self : None;
Reflection3D_swigregister = _IMP_algebra.Reflection3D_swigregister
Reflection3D_swigregister(Reflection3D)

class Cylinder3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Cylinder3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Cylinder3D self) -> Cylinder3D
        __init__(IMP::algebra::Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
        """
        this = _IMP_algebra.new_Cylinder3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radius(self):
        """get_radius(Cylinder3D self) -> double"""
        return _IMP_algebra.Cylinder3D_get_radius(self)

    def get_segment(self):
        """get_segment(Cylinder3D self) -> Segment3D"""
        return _IMP_algebra.Cylinder3D_get_segment(self)

    def get_surface_point_at(self, *args):
        """get_surface_point_at(Cylinder3D self, double relative_height, double angle) -> Vector3D"""
        return _IMP_algebra.Cylinder3D_get_surface_point_at(self, *args)

    def get_inner_point_at(self, *args):
        """get_inner_point_at(Cylinder3D self, double relative_height, double relative_radius, double angle) -> Vector3D"""
        return _IMP_algebra.Cylinder3D_get_inner_point_at(self, *args)

    def show(self, *args):
        """
        show(Cylinder3D self, _ostream out=std::cout)
        show(Cylinder3D self)
        """
        return _IMP_algebra.Cylinder3D_show(self, *args)

    def __str__(self):
        """__str__(Cylinder3D self) -> std::string"""
        return _IMP_algebra.Cylinder3D___str__(self)

    def __repr__(self):
        """__repr__(Cylinder3D self) -> std::string"""
        return _IMP_algebra.Cylinder3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
    __del__ = lambda self : None;
Cylinder3D_swigregister = _IMP_algebra.Cylinder3D_swigregister
Cylinder3D_swigregister(Cylinder3D)


def get_cylinder_3d_geometry(*args):
  """get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
  return _IMP_algebra.get_cylinder_3d_geometry(*args)
class Ellipsoid3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Ellipsoid3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Ellipsoid3D self) -> Ellipsoid3D
        __init__(IMP::algebra::Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
        __init__(IMP::algebra::Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
        """
        this = _IMP_algebra.new_Ellipsoid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_radii(self):
        """get_radii(Ellipsoid3D self) -> Vector3D"""
        return _IMP_algebra.Ellipsoid3D_get_radii(self)

    def get_reference_frame(self):
        """get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
        return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)

    def get_radius(self, *args):
        """get_radius(Ellipsoid3D self, unsigned int i) -> double"""
        return _IMP_algebra.Ellipsoid3D_get_radius(self, *args)

    def get_center(self):
        """get_center(Ellipsoid3D self) -> Vector3D"""
        return _IMP_algebra.Ellipsoid3D_get_center(self)

    def get_rotation(self):
        """get_rotation(Ellipsoid3D self) -> Rotation3D"""
        return _IMP_algebra.Ellipsoid3D_get_rotation(self)

    def get_transformation(self):
        """get_transformation(Ellipsoid3D self) -> Transformation3D"""
        return _IMP_algebra.Ellipsoid3D_get_transformation(self)

    def show(self, *args):
        """
        show(Ellipsoid3D self, _ostream out=std::cout)
        show(Ellipsoid3D self)
        """
        return _IMP_algebra.Ellipsoid3D_show(self, *args)

    def __str__(self):
        """__str__(Ellipsoid3D self) -> std::string"""
        return _IMP_algebra.Ellipsoid3D___str__(self)

    def __repr__(self):
        """__repr__(Ellipsoid3D self) -> std::string"""
        return _IMP_algebra.Ellipsoid3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
    __del__ = lambda self : None;
Ellipsoid3D_swigregister = _IMP_algebra.Ellipsoid3D_swigregister
Ellipsoid3D_swigregister(Ellipsoid3D)


def get_ellipsoid_3d_geometry(*args):
  """get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
  return _IMP_algebra.get_ellipsoid_3d_geometry(*args)
class ConnollySurfacePoint(object):
    """Proxy of C++ IMP::algebra::ConnollySurfacePoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::algebra::ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint"""
        this = _IMP_algebra.new_ConnollySurfacePoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_atom(self, *args):
        """get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
        return _IMP_algebra.ConnollySurfacePoint_get_atom(self, *args)

    def get_surface_point(self):
        """get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
        return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)

    def get_area(self):
        """get_area(ConnollySurfacePoint self) -> double"""
        return _IMP_algebra.ConnollySurfacePoint_get_area(self)

    def get_normal(self):
        """get_normal(ConnollySurfacePoint self) -> Vector3D"""
        return _IMP_algebra.ConnollySurfacePoint_get_normal(self)

    def show(self, *args):
        """
        show(ConnollySurfacePoint self, _ostream out=std::cout)
        show(ConnollySurfacePoint self)
        """
        return _IMP_algebra.ConnollySurfacePoint_show(self, *args)

    def __str__(self):
        """__str__(ConnollySurfacePoint self) -> std::string"""
        return _IMP_algebra.ConnollySurfacePoint___str__(self)

    def __repr__(self):
        """__repr__(ConnollySurfacePoint self) -> std::string"""
        return _IMP_algebra.ConnollySurfacePoint___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
    __del__ = lambda self : None;
ConnollySurfacePoint_swigregister = _IMP_algebra.ConnollySurfacePoint_swigregister
ConnollySurfacePoint_swigregister(ConnollySurfacePoint)


def get_connolly_surface(*args):
  """get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
  return _IMP_algebra.get_connolly_surface(*args)
class LogEmbedding3D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(3)> self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
        __init__(IMP::algebra::LogEmbeddingD<(3)> self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
        __init__(IMP::algebra::LogEmbeddingD<(3)> self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts) -> LogEmbedding3D
        __init__(IMP::algebra::LogEmbeddingD<(3)> self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
        __init__(IMP::algebra::LogEmbeddingD<(3)> self) -> LogEmbedding3D
        """
        this = _IMP_algebra.new_LogEmbedding3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.LogEmbedding3D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.LogEmbedding3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding3D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding3D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
        set_unit_cell(LogEmbedding3D self, Vector3D o)
        """
        return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
        return _IMP_algebra.LogEmbedding3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
        return _IMP_algebra.LogEmbedding3D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.LogEmbedding3D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
        get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
        """
        return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding3D self, _ostream out=std::cout)
        show(LogEmbedding3D self)
        """
        return _IMP_algebra.LogEmbedding3D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding3D self) -> std::string"""
        return _IMP_algebra.LogEmbedding3D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding3D self) -> std::string"""
        return _IMP_algebra.LogEmbedding3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
        return _IMP_algebra.LogEmbedding3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding3D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
    __del__ = lambda self : None;
LogEmbedding3D_swigregister = _IMP_algebra.LogEmbedding3D_swigregister
LogEmbedding3D_swigregister(LogEmbedding3D)

class LogEmbeddingKD(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(-1)> self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
        __init__(IMP::algebra::LogEmbeddingD<(-1)> self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
        __init__(IMP::algebra::LogEmbeddingD<(-1)> self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts) -> LogEmbeddingKD
        __init__(IMP::algebra::LogEmbeddingD<(-1)> self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
        __init__(IMP::algebra::LogEmbeddingD<(-1)> self) -> LogEmbeddingKD
        """
        this = _IMP_algebra.new_LogEmbeddingKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.LogEmbeddingKD_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.LogEmbeddingKD_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbeddingKD self) -> unsigned int"""
        return _IMP_algebra.LogEmbeddingKD_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
        set_unit_cell(LogEmbeddingKD self, VectorKD o)
        """
        return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
        return _IMP_algebra.LogEmbeddingKD_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
        return _IMP_algebra.LogEmbeddingKD_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
        get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
        """
        return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
        get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
        """
        return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbeddingKD self, _ostream out=std::cout)
        show(LogEmbeddingKD self)
        """
        return _IMP_algebra.LogEmbeddingKD_show(self, *args)

    def __str__(self):
        """__str__(LogEmbeddingKD self) -> std::string"""
        return _IMP_algebra.LogEmbeddingKD___str__(self)

    def __repr__(self):
        """__repr__(LogEmbeddingKD self) -> std::string"""
        return _IMP_algebra.LogEmbeddingKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
        return _IMP_algebra.LogEmbeddingKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
        return _IMP_algebra.LogEmbeddingKD___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
    __del__ = lambda self : None;
LogEmbeddingKD_swigregister = _IMP_algebra.LogEmbeddingKD_swigregister
LogEmbeddingKD_swigregister(LogEmbeddingKD)

class DenseFloatLogGridKD(object):
    """Proxy of C++ IMP::algebra::DenseFloatLogGridKD class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::algebra::DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
        this = _IMP_algebra.new_DenseFloatLogGridKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
        return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
        __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
        """
        return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
        __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
        """
        return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
        get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
        """
        return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >
        get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >
        """
        return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(DenseFloatLogGridKD self) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.DenseFloatLogGridKD_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
        get_extended_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
        """
        return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
        get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
        """
        return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
        return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
        return _IMP_algebra.DenseFloatLogGridKD_get_index(self, *args)

    def get_origin(self):
        """get_origin(DenseFloatLogGridKD self) -> VectorKD"""
        return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)

    def get_dimension(self):
        """get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
        return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
        return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> bool"""
        return _IMP_algebra.DenseFloatLogGridKD_get_has_index(self, *args)

    def __str__(self):
        """__str__(DenseFloatLogGridKD self) -> std::string"""
        return _IMP_algebra.DenseFloatLogGridKD___str__(self)

    def __repr__(self):
        """__repr__(DenseFloatLogGridKD self) -> std::string"""
        return _IMP_algebra.DenseFloatLogGridKD___repr__(self)

    def show(self, *args):
        """
        show(DenseFloatLogGridKD self, _ostream out=std::cout)
        show(DenseFloatLogGridKD self)
        """
        return _IMP_algebra.DenseFloatLogGridKD_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DenseFloatLogGridKD
    __del__ = lambda self : None;
DenseFloatLogGridKD_swigregister = _IMP_algebra.DenseFloatLogGridKD_swigregister
DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)

class DenseIntLogGrid3D(object):
    """Proxy of C++ IMP::algebra::DenseIntLogGrid3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::algebra::DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
        this = _IMP_algebra.new_DenseIntLogGrid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
        __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
        """
        return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
        __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
        """
        return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
        get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(DenseIntLogGrid3D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_index(self, *args)

    def get_origin(self):
        """get_origin(DenseIntLogGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, *args)

    def __str__(self):
        """__str__(DenseIntLogGrid3D self) -> std::string"""
        return _IMP_algebra.DenseIntLogGrid3D___str__(self)

    def __repr__(self):
        """__repr__(DenseIntLogGrid3D self) -> std::string"""
        return _IMP_algebra.DenseIntLogGrid3D___repr__(self)

    def show(self, *args):
        """
        show(DenseIntLogGrid3D self, _ostream out=std::cout)
        show(DenseIntLogGrid3D self)
        """
        return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D
    __del__ = lambda self : None;
DenseIntLogGrid3D_swigregister = _IMP_algebra.DenseIntLogGrid3D_swigregister
DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)

class DenseDoubleGrid3D(object):
    """Proxy of C++ IMP::algebra::DenseGrid3D<(double)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGrid3D<(double)> self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
        __init__(IMP::algebra::DenseGrid3D<(double)> self, double side, BoundingBox3D bb) -> DenseDoubleGrid3D
        __init__(IMP::algebra::DenseGrid3D<(double)> self) -> DenseDoubleGrid3D
        """
        this = _IMP_algebra.new_DenseDoubleGrid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
        __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
        """
        return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
        __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
        """
        return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
        get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(DenseDoubleGrid3D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_index(self, *args)

    def get_origin(self):
        """get_origin(DenseDoubleGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, *args)

    def __str__(self):
        """__str__(DenseDoubleGrid3D self) -> std::string"""
        return _IMP_algebra.DenseDoubleGrid3D___str__(self)

    def __repr__(self):
        """__repr__(DenseDoubleGrid3D self) -> std::string"""
        return _IMP_algebra.DenseDoubleGrid3D___repr__(self)

    def show(self, *args):
        """
        show(DenseDoubleGrid3D self, _ostream out=std::cout)
        show(DenseDoubleGrid3D self)
        """
        return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D
    __del__ = lambda self : None;
DenseDoubleGrid3D_swigregister = _IMP_algebra.DenseDoubleGrid3D_swigregister
DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)

class DenseFloatGrid3D(object):
    """Proxy of C++ IMP::algebra::DenseGrid3D<(float)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DenseGrid3D<(float)> self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
        __init__(IMP::algebra::DenseGrid3D<(float)> self, double side, BoundingBox3D bb) -> DenseFloatGrid3D
        __init__(IMP::algebra::DenseGrid3D<(float)> self) -> DenseFloatGrid3D
        """
        this = _IMP_algebra.new_DenseFloatGrid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
        __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
        """
        return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
        __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
        """
        return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
        get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
        """
        return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        """
        return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(DenseFloatGrid3D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        """
        return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_index(self, *args)

    def get_origin(self):
        """get_origin(DenseFloatGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DenseFloatGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, *args)

    def __str__(self):
        """__str__(DenseFloatGrid3D self) -> std::string"""
        return _IMP_algebra.DenseFloatGrid3D___str__(self)

    def __repr__(self):
        """__repr__(DenseFloatGrid3D self) -> std::string"""
        return _IMP_algebra.DenseFloatGrid3D___repr__(self)

    def show(self, *args):
        """
        show(DenseFloatGrid3D self, _ostream out=std::cout)
        show(DenseFloatGrid3D self)
        """
        return _IMP_algebra.DenseFloatGrid3D_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D
    __del__ = lambda self : None;
DenseFloatGrid3D_swigregister = _IMP_algebra.DenseFloatGrid3D_swigregister
DenseFloatGrid3D_swigregister(DenseFloatGrid3D)

class SparseUnboundedIntGrid3D(object):
    """Proxy of C++ IMP::algebra::SparseUnboundedGrid3D<(int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, double side, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
        __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, double side, Vector3D origin) -> SparseUnboundedIntGrid3D
        __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, Vector3D sides, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
        __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, Vector3D sides, Vector3D origin) -> SparseUnboundedIntGrid3D
        __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self) -> SparseUnboundedIntGrid3D
        """
        this = _IMP_algebra.new_SparseUnboundedIntGrid3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
        __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
        __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
        get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, *args)

    def get_origin(self):
        """get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, *args)

    def __str__(self):
        """__str__(SparseUnboundedIntGrid3D self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)

    def __repr__(self):
        """__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)

    def show(self, *args):
        """
        show(SparseUnboundedIntGrid3D self, _ostream out=std::cout)
        show(SparseUnboundedIntGrid3D self)
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D
    __del__ = lambda self : None;
SparseUnboundedIntGrid3D_swigregister = _IMP_algebra.SparseUnboundedIntGrid3D_swigregister
SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)

class SparseUnboundedIntGridKD(object):
    """Proxy of C++ IMP::algebra::SparseUnboundedGridD<(-1,int)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
        __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self, double side, VectorKD origin) -> SparseUnboundedIntGridKD
        __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self) -> SparseUnboundedIntGridKD
        """
        this = _IMP_algebra.new_SparseUnboundedIntGridKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_voxel(self, *args):
        """add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
        __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
        """
        return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
        __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
        """
        return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
        get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)

    def get_indexes(self, *args):
        """
        get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >
        get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        """
        get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
        get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)

    def get_center(self, *args):
        """
        get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
        get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)

    def get_extended_index(self, *args):
        """get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, *args)

    def get_origin(self):
        """get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)

    def get_dimension(self):
        """get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)

    def get_unit_cell(self):
        """get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)

    def get_has_index(self, *args):
        """get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, *args)

    def __str__(self):
        """__str__(SparseUnboundedIntGridKD self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)

    def __repr__(self):
        """__repr__(SparseUnboundedIntGridKD self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)

    def show(self, *args):
        """
        show(SparseUnboundedIntGridKD self, _ostream out=std::cout)
        show(SparseUnboundedIntGridKD self)
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD
    __del__ = lambda self : None;
SparseUnboundedIntGridKD_swigregister = _IMP_algebra.SparseUnboundedIntGridKD_swigregister
SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)

class GridIndex1D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(1)> self) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int x) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int x, int y) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int x, int y, int z) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l, int m) -> GridIndex1D
        __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
        """
        this = _IMP_algebra.new_GridIndex1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex1D self) -> unsigned int"""
        return _IMP_algebra.GridIndex1D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex1D self, _ostream out=std::cout)
        show(GridIndex1D self)
        """
        return _IMP_algebra.GridIndex1D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex1D self) -> unsigned int"""
        return _IMP_algebra.GridIndex1D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
        return _IMP_algebra.GridIndex1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex1D self) -> std::size_t"""
        return _IMP_algebra.GridIndex1D___hash__(self)

    def __str__(self):
        """__str__(GridIndex1D self) -> std::string"""
        return _IMP_algebra.GridIndex1D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex1D self) -> std::string"""
        return _IMP_algebra.GridIndex1D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
    __del__ = lambda self : None;
GridIndex1D_swigregister = _IMP_algebra.GridIndex1D_swigregister
GridIndex1D_swigregister(GridIndex1D)

class GridIndex2D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(2)> self) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int x) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int x, int y) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int x, int y, int z) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l, int m) -> GridIndex2D
        __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
        """
        this = _IMP_algebra.new_GridIndex2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex2D self) -> unsigned int"""
        return _IMP_algebra.GridIndex2D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex2D self, _ostream out=std::cout)
        show(GridIndex2D self)
        """
        return _IMP_algebra.GridIndex2D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex2D self) -> unsigned int"""
        return _IMP_algebra.GridIndex2D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
        return _IMP_algebra.GridIndex2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex2D self) -> std::size_t"""
        return _IMP_algebra.GridIndex2D___hash__(self)

    def __str__(self):
        """__str__(GridIndex2D self) -> std::string"""
        return _IMP_algebra.GridIndex2D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex2D self) -> std::string"""
        return _IMP_algebra.GridIndex2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
    __del__ = lambda self : None;
GridIndex2D_swigregister = _IMP_algebra.GridIndex2D_swigregister
GridIndex2D_swigregister(GridIndex2D)

class GridIndex3D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(3)> self) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int x) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int x, int y) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int x, int y, int z) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l, int m) -> GridIndex3D
        __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
        """
        this = _IMP_algebra.new_GridIndex3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex3D self) -> unsigned int"""
        return _IMP_algebra.GridIndex3D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex3D self, _ostream out=std::cout)
        show(GridIndex3D self)
        """
        return _IMP_algebra.GridIndex3D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex3D self) -> unsigned int"""
        return _IMP_algebra.GridIndex3D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
        return _IMP_algebra.GridIndex3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex3D self) -> std::size_t"""
        return _IMP_algebra.GridIndex3D___hash__(self)

    def __str__(self):
        """__str__(GridIndex3D self) -> std::string"""
        return _IMP_algebra.GridIndex3D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex3D self) -> std::string"""
        return _IMP_algebra.GridIndex3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
    __del__ = lambda self : None;
GridIndex3D_swigregister = _IMP_algebra.GridIndex3D_swigregister
GridIndex3D_swigregister(GridIndex3D)

class GridIndex4D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(4)> self) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int x) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int x, int y) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int x, int y, int z) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l, int m) -> GridIndex4D
        __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
        """
        this = _IMP_algebra.new_GridIndex4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex4D self) -> unsigned int"""
        return _IMP_algebra.GridIndex4D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex4D self, _ostream out=std::cout)
        show(GridIndex4D self)
        """
        return _IMP_algebra.GridIndex4D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex4D self) -> unsigned int"""
        return _IMP_algebra.GridIndex4D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
        return _IMP_algebra.GridIndex4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex4D self) -> std::size_t"""
        return _IMP_algebra.GridIndex4D___hash__(self)

    def __str__(self):
        """__str__(GridIndex4D self) -> std::string"""
        return _IMP_algebra.GridIndex4D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex4D self) -> std::string"""
        return _IMP_algebra.GridIndex4D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
    __del__ = lambda self : None;
GridIndex4D_swigregister = _IMP_algebra.GridIndex4D_swigregister
GridIndex4D_swigregister(GridIndex4D)

class GridIndex5D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(5)> self) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int x) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int x, int y) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int x, int y, int z) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l, int m) -> GridIndex5D
        __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
        """
        this = _IMP_algebra.new_GridIndex5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex5D self) -> unsigned int"""
        return _IMP_algebra.GridIndex5D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex5D self, _ostream out=std::cout)
        show(GridIndex5D self)
        """
        return _IMP_algebra.GridIndex5D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex5D self) -> unsigned int"""
        return _IMP_algebra.GridIndex5D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
        return _IMP_algebra.GridIndex5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex5D self) -> std::size_t"""
        return _IMP_algebra.GridIndex5D___hash__(self)

    def __str__(self):
        """__str__(GridIndex5D self) -> std::string"""
        return _IMP_algebra.GridIndex5D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex5D self) -> std::string"""
        return _IMP_algebra.GridIndex5D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
    __del__ = lambda self : None;
GridIndex5D_swigregister = _IMP_algebra.GridIndex5D_swigregister
GridIndex5D_swigregister(GridIndex5D)

class GridIndex6D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(6)> self) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int x) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int x, int y) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int x, int y, int z) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l, int m) -> GridIndex6D
        __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
        """
        this = _IMP_algebra.new_GridIndex6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndex6D self) -> unsigned int"""
        return _IMP_algebra.GridIndex6D_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndex6D self, _ostream out=std::cout)
        show(GridIndex6D self)
        """
        return _IMP_algebra.GridIndex6D_show(self, *args)

    def __len__(self):
        """__len__(GridIndex6D self) -> unsigned int"""
        return _IMP_algebra.GridIndex6D___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
        return _IMP_algebra.GridIndex6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndex6D self) -> std::size_t"""
        return _IMP_algebra.GridIndex6D___hash__(self)

    def __str__(self):
        """__str__(GridIndex6D self) -> std::string"""
        return _IMP_algebra.GridIndex6D___str__(self)

    def __repr__(self):
        """__repr__(GridIndex6D self) -> std::string"""
        return _IMP_algebra.GridIndex6D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
    __del__ = lambda self : None;
GridIndex6D_swigregister = _IMP_algebra.GridIndex6D_swigregister
GridIndex6D_swigregister(GridIndex6D)

class GridIndexKD(IMP.base._Value):
    """Proxy of C++ IMP::algebra::GridIndexD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::GridIndexD<(-1)> self) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int x) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int x, int y) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int x, int y, int z) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l, int m) -> GridIndexKD
        __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
        """
        this = _IMP_algebra.new_GridIndexKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(GridIndexKD self) -> unsigned int"""
        return _IMP_algebra.GridIndexKD_get_dimension(self)

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

    def show(self, *args):
        """
        show(GridIndexKD self, _ostream out=std::cout)
        show(GridIndexKD self)
        """
        return _IMP_algebra.GridIndexKD_show(self, *args)

    def __len__(self):
        """__len__(GridIndexKD self) -> unsigned int"""
        return _IMP_algebra.GridIndexKD___len__(self)

    def __cmp__(self, *args):
        """__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
        return _IMP_algebra.GridIndexKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___ge__(self, *args)

    def __le__(self, *args):
        """__le__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___le__(self, *args)

    def __hash__(self):
        """__hash__(GridIndexKD self) -> std::size_t"""
        return _IMP_algebra.GridIndexKD___hash__(self)

    def __str__(self):
        """__str__(GridIndexKD self) -> std::string"""
        return _IMP_algebra.GridIndexKD___str__(self)

    def __repr__(self):
        """__repr__(GridIndexKD self) -> std::string"""
        return _IMP_algebra.GridIndexKD___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
    __del__ = lambda self : None;
GridIndexKD_swigregister = _IMP_algebra.GridIndexKD_swigregister
GridIndexKD_swigregister(GridIndexKD)

class ExtendedGridIndex1D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, IMP::Ints vals) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x, int y) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x, int y, int z) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
        __init__(IMP::algebra::ExtendedGridIndexD<(1)> self) -> ExtendedGridIndex1D
        """
        this = _IMP_algebra.new_ExtendedGridIndex1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex1D self, _ostream out=std::cout)
        show(ExtendedGridIndex1D self)
        """
        return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex1D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex1D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex1D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex1D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
        return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
        return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex1D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex1D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex1D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex1D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
    __del__ = lambda self : None;
ExtendedGridIndex1D_swigregister = _IMP_algebra.ExtendedGridIndex1D_swigregister
ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)

class ExtendedGridIndex2D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, IMP::Ints vals) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x, int y) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x, int y, int z) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
        __init__(IMP::algebra::ExtendedGridIndexD<(2)> self) -> ExtendedGridIndex2D
        """
        this = _IMP_algebra.new_ExtendedGridIndex2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex2D self, _ostream out=std::cout)
        show(ExtendedGridIndex2D self)
        """
        return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex2D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex2D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex2D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex2D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
        return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
        return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex2D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex2D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex2D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
    __del__ = lambda self : None;
ExtendedGridIndex2D_swigregister = _IMP_algebra.ExtendedGridIndex2D_swigregister
ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)

class ExtendedGridIndex3D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, IMP::Ints vals) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x, int y) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x, int y, int z) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
        __init__(IMP::algebra::ExtendedGridIndexD<(3)> self) -> ExtendedGridIndex3D
        """
        this = _IMP_algebra.new_ExtendedGridIndex3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex3D self, _ostream out=std::cout)
        show(ExtendedGridIndex3D self)
        """
        return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex3D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex3D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex3D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex3D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
        return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
        return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex3D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex3D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex3D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
    __del__ = lambda self : None;
ExtendedGridIndex3D_swigregister = _IMP_algebra.ExtendedGridIndex3D_swigregister
ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)

class ExtendedGridIndex4D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, IMP::Ints vals) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x, int y) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x, int y, int z) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
        __init__(IMP::algebra::ExtendedGridIndexD<(4)> self) -> ExtendedGridIndex4D
        """
        this = _IMP_algebra.new_ExtendedGridIndex4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex4D self, _ostream out=std::cout)
        show(ExtendedGridIndex4D self)
        """
        return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex4D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex4D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex4D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex4D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
        return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
        return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex4D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex4D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex4D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex4D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
    __del__ = lambda self : None;
ExtendedGridIndex4D_swigregister = _IMP_algebra.ExtendedGridIndex4D_swigregister
ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)

class ExtendedGridIndex5D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, IMP::Ints vals) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x, int y) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x, int y, int z) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
        __init__(IMP::algebra::ExtendedGridIndexD<(5)> self) -> ExtendedGridIndex5D
        """
        this = _IMP_algebra.new_ExtendedGridIndex5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex5D self, _ostream out=std::cout)
        show(ExtendedGridIndex5D self)
        """
        return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex5D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex5D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex5D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex5D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
        return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
        return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex5D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex5D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex5D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex5D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
    __del__ = lambda self : None;
ExtendedGridIndex5D_swigregister = _IMP_algebra.ExtendedGridIndex5D_swigregister
ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)

class ExtendedGridIndex6D(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, IMP::Ints vals) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x, int y) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x, int y, int z) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
        __init__(IMP::algebra::ExtendedGridIndexD<(6)> self) -> ExtendedGridIndex6D
        """
        this = _IMP_algebra.new_ExtendedGridIndex6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
        return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndex6D self, _ostream out=std::cout)
        show(ExtendedGridIndex6D self)
        """
        return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndex6D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex6D___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndex6D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex6D___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
        return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
        return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndex6D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex6D___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndex6D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex6D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
    __del__ = lambda self : None;
ExtendedGridIndex6D_swigregister = _IMP_algebra.ExtendedGridIndex6D_swigregister
ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)

class ExtendedGridIndexKD(IMP.base._Value):
    """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, IMP::Ints vals) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x, int y) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x, int y, int z) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
        __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self) -> ExtendedGridIndexKD
        """
        this = _IMP_algebra.new_ExtendedGridIndexKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_dimension(self):
        """get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)

    def __cmp__(self, *args):
        """__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
        return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___le__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, *args)

    def show(self, *args):
        """
        show(ExtendedGridIndexKD self, _ostream out=std::cout)
        show(ExtendedGridIndexKD self)
        """
        return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)

    def __len__(self):
        """__len__(ExtendedGridIndexKD self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndexKD___len__(self)

    def __hash__(self):
        """__hash__(ExtendedGridIndexKD self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndexKD___hash__(self)

    def get_uniform_offset(self, *args):
        """get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
        return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, *args)

    def get_offset(self, *args):
        """get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
        return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, *args)

    def __str__(self):
        """__str__(ExtendedGridIndexKD self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndexKD___str__(self)

    def __repr__(self):
        """__repr__(ExtendedGridIndexKD self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndexKD___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
    __del__ = lambda self : None;
ExtendedGridIndexKD_swigregister = _IMP_algebra.ExtendedGridIndexKD_swigregister
ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)

class BoundedGridRange1D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange1D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(1)> self) -> BoundedGridRange1D
        __init__(IMP::algebra::BoundedGridRangeD<(1)> self, IMP::Ints const & counts) -> BoundedGridRange1D
        """
        this = _IMP_algebra.new_BoundedGridRange1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange1D self, _ostream out=std::cout)
        show(BoundedGridRange1D self)
        """
        return _IMP_algebra.BoundedGridRange1D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange1D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
        return _IMP_algebra.BoundedGridRange1D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange1D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange1D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange1D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange1D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
    __del__ = lambda self : None;
BoundedGridRange1D_swigregister = _IMP_algebra.BoundedGridRange1D_swigregister
BoundedGridRange1D_swigregister(BoundedGridRange1D)

def BoundedGridRange1D_get_is_bounded():
  """BoundedGridRange1D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange1D_get_is_bounded()

class BoundedGridRange2D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange2D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(2)> self) -> BoundedGridRange2D
        __init__(IMP::algebra::BoundedGridRangeD<(2)> self, IMP::Ints const & counts) -> BoundedGridRange2D
        """
        this = _IMP_algebra.new_BoundedGridRange2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange2D self, _ostream out=std::cout)
        show(BoundedGridRange2D self)
        """
        return _IMP_algebra.BoundedGridRange2D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange2D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
        return _IMP_algebra.BoundedGridRange2D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange2D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange2D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange2D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange2D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
    __del__ = lambda self : None;
BoundedGridRange2D_swigregister = _IMP_algebra.BoundedGridRange2D_swigregister
BoundedGridRange2D_swigregister(BoundedGridRange2D)

def BoundedGridRange2D_get_is_bounded():
  """BoundedGridRange2D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange2D_get_is_bounded()

class BoundedGridRange3D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange3D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(3)> self) -> BoundedGridRange3D
        __init__(IMP::algebra::BoundedGridRangeD<(3)> self, IMP::Ints const & counts) -> BoundedGridRange3D
        """
        this = _IMP_algebra.new_BoundedGridRange3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange3D self, _ostream out=std::cout)
        show(BoundedGridRange3D self)
        """
        return _IMP_algebra.BoundedGridRange3D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange3D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.BoundedGridRange3D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange3D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange3D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange3D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange3D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
    __del__ = lambda self : None;
BoundedGridRange3D_swigregister = _IMP_algebra.BoundedGridRange3D_swigregister
BoundedGridRange3D_swigregister(BoundedGridRange3D)

def BoundedGridRange3D_get_is_bounded():
  """BoundedGridRange3D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange3D_get_is_bounded()

class BoundedGridRange4D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange4D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(4)> self) -> BoundedGridRange4D
        __init__(IMP::algebra::BoundedGridRangeD<(4)> self, IMP::Ints const & counts) -> BoundedGridRange4D
        """
        this = _IMP_algebra.new_BoundedGridRange4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange4D self, _ostream out=std::cout)
        show(BoundedGridRange4D self)
        """
        return _IMP_algebra.BoundedGridRange4D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange4D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
        return _IMP_algebra.BoundedGridRange4D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange4D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange4D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange4D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange4D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
    __del__ = lambda self : None;
BoundedGridRange4D_swigregister = _IMP_algebra.BoundedGridRange4D_swigregister
BoundedGridRange4D_swigregister(BoundedGridRange4D)

def BoundedGridRange4D_get_is_bounded():
  """BoundedGridRange4D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange4D_get_is_bounded()

class BoundedGridRange5D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange5D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(5)> self) -> BoundedGridRange5D
        __init__(IMP::algebra::BoundedGridRangeD<(5)> self, IMP::Ints const & counts) -> BoundedGridRange5D
        """
        this = _IMP_algebra.new_BoundedGridRange5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange5D self, _ostream out=std::cout)
        show(BoundedGridRange5D self)
        """
        return _IMP_algebra.BoundedGridRange5D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange5D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
        return _IMP_algebra.BoundedGridRange5D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange5D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange5D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange5D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange5D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
    __del__ = lambda self : None;
BoundedGridRange5D_swigregister = _IMP_algebra.BoundedGridRange5D_swigregister
BoundedGridRange5D_swigregister(BoundedGridRange5D)

def BoundedGridRange5D_get_is_bounded():
  """BoundedGridRange5D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange5D_get_is_bounded()

class BoundedGridRange6D(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange6D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(6)> self) -> BoundedGridRange6D
        __init__(IMP::algebra::BoundedGridRangeD<(6)> self, IMP::Ints const & counts) -> BoundedGridRange6D
        """
        this = _IMP_algebra.new_BoundedGridRange6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRange6D self, _ostream out=std::cout)
        show(BoundedGridRange6D self)
        """
        return _IMP_algebra.BoundedGridRange6D_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRange6D self) -> IMP::base::Vector< IMP::algebra::GridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
        return _IMP_algebra.BoundedGridRange6D_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRange6D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange6D___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRange6D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
        return _IMP_algebra.BoundedGridRange6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange6D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
    __del__ = lambda self : None;
BoundedGridRange6D_swigregister = _IMP_algebra.BoundedGridRange6D_swigregister
BoundedGridRange6D_swigregister(BoundedGridRange6D)

def BoundedGridRange6D_get_is_bounded():
  """BoundedGridRange6D_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRange6D_get_is_bounded()

class BoundedGridRangeKD(object):
    """Proxy of C++ IMP::algebra::BoundedGridRangeD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::BoundedGridRangeD<(-1)> self) -> BoundedGridRangeKD
        __init__(IMP::algebra::BoundedGridRangeD<(-1)> self, IMP::Ints const & counts) -> BoundedGridRangeKD
        """
        this = _IMP_algebra.new_BoundedGridRangeKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_voxels(self, *args):
        """
        get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
        get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
        """
        return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)

    def get_end_index(self):
        """get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)

    def show(self, *args):
        """
        show(BoundedGridRangeKD self, _ostream out=std::cout)
        show(BoundedGridRangeKD self)
        """
        return _IMP_algebra.BoundedGridRangeKD_show(self, *args)

    def get_all_indexes(self):
        """get_all_indexes(BoundedGridRangeKD self) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)

    def get_indexes(self, *args):
        """get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, *args)

    def get_index(self, *args):
        """get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_index(self, *args)

    def get_has_index(self, *args):
        """get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
        return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, *args)

    def get_minimum_extended_index(self):
        """get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        """get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)

    def __str__(self):
        """__str__(BoundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.BoundedGridRangeKD___str__(self)

    def __repr__(self):
        """__repr__(BoundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.BoundedGridRangeKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
        return _IMP_algebra.BoundedGridRangeKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
        return _IMP_algebra.BoundedGridRangeKD___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
    __del__ = lambda self : None;
BoundedGridRangeKD_swigregister = _IMP_algebra.BoundedGridRangeKD_swigregister
BoundedGridRangeKD_swigregister(BoundedGridRangeKD)

def BoundedGridRangeKD_get_is_bounded():
  """BoundedGridRangeKD_get_is_bounded() -> bool"""
  return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()

class UnboundedGridRange1D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(1)> self) -> UnboundedGridRange1D
        __init__(IMP::algebra::UnboundedGridRangeD<(1)> self, IMP::Ints const & arg2) -> UnboundedGridRange1D
        """
        this = _IMP_algebra.new_UnboundedGridRange1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange1D self, _ostream out=std::cout)
        show(UnboundedGridRange1D self)
        """
        return _IMP_algebra.UnboundedGridRange1D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
        return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange1D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange1D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange1D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange1D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
    __del__ = lambda self : None;
UnboundedGridRange1D_swigregister = _IMP_algebra.UnboundedGridRange1D_swigregister
UnboundedGridRange1D_swigregister(UnboundedGridRange1D)

def UnboundedGridRange1D_get_is_bounded():
  """UnboundedGridRange1D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()

class UnboundedGridRange2D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(2)> self) -> UnboundedGridRange2D
        __init__(IMP::algebra::UnboundedGridRangeD<(2)> self, IMP::Ints const & arg2) -> UnboundedGridRange2D
        """
        this = _IMP_algebra.new_UnboundedGridRange2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange2D self, _ostream out=std::cout)
        show(UnboundedGridRange2D self)
        """
        return _IMP_algebra.UnboundedGridRange2D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
        return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange2D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange2D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange2D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange2D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
    __del__ = lambda self : None;
UnboundedGridRange2D_swigregister = _IMP_algebra.UnboundedGridRange2D_swigregister
UnboundedGridRange2D_swigregister(UnboundedGridRange2D)

def UnboundedGridRange2D_get_is_bounded():
  """UnboundedGridRange2D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()

class UnboundedGridRange3D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(3)> self) -> UnboundedGridRange3D
        __init__(IMP::algebra::UnboundedGridRangeD<(3)> self, IMP::Ints const & arg2) -> UnboundedGridRange3D
        """
        this = _IMP_algebra.new_UnboundedGridRange3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange3D self, _ostream out=std::cout)
        show(UnboundedGridRange3D self)
        """
        return _IMP_algebra.UnboundedGridRange3D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
        return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange3D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange3D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange3D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange3D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
    __del__ = lambda self : None;
UnboundedGridRange3D_swigregister = _IMP_algebra.UnboundedGridRange3D_swigregister
UnboundedGridRange3D_swigregister(UnboundedGridRange3D)

def UnboundedGridRange3D_get_is_bounded():
  """UnboundedGridRange3D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()

class UnboundedGridRange4D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(4)> self) -> UnboundedGridRange4D
        __init__(IMP::algebra::UnboundedGridRangeD<(4)> self, IMP::Ints const & arg2) -> UnboundedGridRange4D
        """
        this = _IMP_algebra.new_UnboundedGridRange4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange4D self, _ostream out=std::cout)
        show(UnboundedGridRange4D self)
        """
        return _IMP_algebra.UnboundedGridRange4D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
        return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange4D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange4D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange4D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange4D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
    __del__ = lambda self : None;
UnboundedGridRange4D_swigregister = _IMP_algebra.UnboundedGridRange4D_swigregister
UnboundedGridRange4D_swigregister(UnboundedGridRange4D)

def UnboundedGridRange4D_get_is_bounded():
  """UnboundedGridRange4D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()

class UnboundedGridRange5D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(5)> self) -> UnboundedGridRange5D
        __init__(IMP::algebra::UnboundedGridRangeD<(5)> self, IMP::Ints const & arg2) -> UnboundedGridRange5D
        """
        this = _IMP_algebra.new_UnboundedGridRange5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange5D self, _ostream out=std::cout)
        show(UnboundedGridRange5D self)
        """
        return _IMP_algebra.UnboundedGridRange5D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
        return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange5D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange5D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange5D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange5D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
    __del__ = lambda self : None;
UnboundedGridRange5D_swigregister = _IMP_algebra.UnboundedGridRange5D_swigregister
UnboundedGridRange5D_swigregister(UnboundedGridRange5D)

def UnboundedGridRange5D_get_is_bounded():
  """UnboundedGridRange5D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()

class UnboundedGridRange6D(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(6)> self) -> UnboundedGridRange6D
        __init__(IMP::algebra::UnboundedGridRangeD<(6)> self, IMP::Ints const & arg2) -> UnboundedGridRange6D
        """
        this = _IMP_algebra.new_UnboundedGridRange6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRange6D self, _ostream out=std::cout)
        show(UnboundedGridRange6D self)
        """
        return _IMP_algebra.UnboundedGridRange6D_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
        return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRange6D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange6D___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRange6D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
        return _IMP_algebra.UnboundedGridRange6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange6D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
    __del__ = lambda self : None;
UnboundedGridRange6D_swigregister = _IMP_algebra.UnboundedGridRange6D_swigregister
UnboundedGridRange6D_swigregister(UnboundedGridRange6D)

def UnboundedGridRange6D_get_is_bounded():
  """UnboundedGridRange6D_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()

class UnboundedGridRangeKD(object):
    """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::UnboundedGridRangeD<(-1)> self) -> UnboundedGridRangeKD
        __init__(IMP::algebra::UnboundedGridRangeD<(-1)> self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
        """
        this = _IMP_algebra.new_UnboundedGridRangeKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_number_of_voxels(self, *args):
        """set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, *args)

    def get_number_of_voxels(self, *args):
        """get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, *args)

    def get_is_bounded():
        """get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()

    get_is_bounded = staticmethod(get_is_bounded)
    def get_has_index(self, *args):
        """get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, *args)

    def show(self, *args):
        """
        show(UnboundedGridRangeKD self, _ostream out=std::cout)
        show(UnboundedGridRangeKD self)
        """
        return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)

    def get_extended_indexes(self, *args):
        """get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::base::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
        return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, *args)

    def __str__(self):
        """__str__(UnboundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.UnboundedGridRangeKD___str__(self)

    def __repr__(self):
        """__repr__(UnboundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.UnboundedGridRangeKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
        return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
    __del__ = lambda self : None;
UnboundedGridRangeKD_swigregister = _IMP_algebra.UnboundedGridRangeKD_swigregister
UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)

def UnboundedGridRangeKD_get_is_bounded():
  """UnboundedGridRangeKD_get_is_bounded() -> bool"""
  return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()

class DefaultEmbedding1D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(1)> self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
        __init__(IMP::algebra::DefaultEmbeddingD<(1)> self) -> DefaultEmbedding1D
        """
        this = _IMP_algebra.new_DefaultEmbedding1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.DefaultEmbedding1D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding1D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
        get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
        """
        return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
        get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
        """
        return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding1D self, _ostream out=std::cout)
        show(DefaultEmbedding1D self)
        """
        return _IMP_algebra.DefaultEmbedding1D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding1D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding1D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding1D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding1D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
    __del__ = lambda self : None;
DefaultEmbedding1D_swigregister = _IMP_algebra.DefaultEmbedding1D_swigregister
DefaultEmbedding1D_swigregister(DefaultEmbedding1D)

class DefaultEmbedding2D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(2)> self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
        __init__(IMP::algebra::DefaultEmbeddingD<(2)> self) -> DefaultEmbedding2D
        """
        this = _IMP_algebra.new_DefaultEmbedding2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.DefaultEmbedding2D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding2D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
        get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
        """
        return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
        get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
        """
        return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding2D self, _ostream out=std::cout)
        show(DefaultEmbedding2D self)
        """
        return _IMP_algebra.DefaultEmbedding2D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding2D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding2D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding2D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding2D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
    __del__ = lambda self : None;
DefaultEmbedding2D_swigregister = _IMP_algebra.DefaultEmbedding2D_swigregister
DefaultEmbedding2D_swigregister(DefaultEmbedding2D)

class DefaultEmbedding3D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(3)> self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
        __init__(IMP::algebra::DefaultEmbeddingD<(3)> self) -> DefaultEmbedding3D
        """
        this = _IMP_algebra.new_DefaultEmbedding3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.DefaultEmbedding3D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding3D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
        get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
        """
        return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
        get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
        """
        return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding3D self, _ostream out=std::cout)
        show(DefaultEmbedding3D self)
        """
        return _IMP_algebra.DefaultEmbedding3D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding3D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding3D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding3D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding3D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding3D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
    __del__ = lambda self : None;
DefaultEmbedding3D_swigregister = _IMP_algebra.DefaultEmbedding3D_swigregister
DefaultEmbedding3D_swigregister(DefaultEmbedding3D)

class DefaultEmbedding4D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(4)> self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
        __init__(IMP::algebra::DefaultEmbeddingD<(4)> self) -> DefaultEmbedding4D
        """
        this = _IMP_algebra.new_DefaultEmbedding4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.DefaultEmbedding4D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding4D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
        get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
        """
        return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
        get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
        """
        return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding4D self, _ostream out=std::cout)
        show(DefaultEmbedding4D self)
        """
        return _IMP_algebra.DefaultEmbedding4D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding4D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding4D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding4D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding4D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
    __del__ = lambda self : None;
DefaultEmbedding4D_swigregister = _IMP_algebra.DefaultEmbedding4D_swigregister
DefaultEmbedding4D_swigregister(DefaultEmbedding4D)

class DefaultEmbedding5D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(5)> self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
        __init__(IMP::algebra::DefaultEmbeddingD<(5)> self) -> DefaultEmbedding5D
        """
        this = _IMP_algebra.new_DefaultEmbedding5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.DefaultEmbedding5D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding5D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
        get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
        """
        return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
        get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
        """
        return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding5D self, _ostream out=std::cout)
        show(DefaultEmbedding5D self)
        """
        return _IMP_algebra.DefaultEmbedding5D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding5D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding5D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding5D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding5D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
    __del__ = lambda self : None;
DefaultEmbedding5D_swigregister = _IMP_algebra.DefaultEmbedding5D_swigregister
DefaultEmbedding5D_swigregister(DefaultEmbedding5D)

class DefaultEmbedding6D(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(6)> self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
        __init__(IMP::algebra::DefaultEmbeddingD<(6)> self) -> DefaultEmbedding6D
        """
        this = _IMP_algebra.new_DefaultEmbedding6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.DefaultEmbedding6D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbedding6D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
        get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
        """
        return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
        get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
        """
        return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbedding6D self, _ostream out=std::cout)
        show(DefaultEmbedding6D self)
        """
        return _IMP_algebra.DefaultEmbedding6D_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbedding6D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding6D___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbedding6D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
        return _IMP_algebra.DefaultEmbedding6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding6D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
    __del__ = lambda self : None;
DefaultEmbedding6D_swigregister = _IMP_algebra.DefaultEmbedding6D_swigregister
DefaultEmbedding6D_swigregister(DefaultEmbedding6D)

class DefaultEmbeddingKD(object):
    """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DefaultEmbeddingD<(-1)> self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
        __init__(IMP::algebra::DefaultEmbeddingD<(-1)> self) -> DefaultEmbeddingKD
        """
        this = _IMP_algebra.new_DefaultEmbeddingKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(DefaultEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)

    def get_dimension(self):
        """get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)

    def set_unit_cell(self, *args):
        """set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, *args)

    def get_inverse_unit_cell(self):
        """get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        """get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
        get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
        """
        return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
        get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
        """
        return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(DefaultEmbeddingKD self, _ostream out=std::cout)
        show(DefaultEmbeddingKD self)
        """
        return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)

    def __str__(self):
        """__str__(DefaultEmbeddingKD self) -> std::string"""
        return _IMP_algebra.DefaultEmbeddingKD___str__(self)

    def __repr__(self):
        """__repr__(DefaultEmbeddingKD self) -> std::string"""
        return _IMP_algebra.DefaultEmbeddingKD___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
        return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
        return _IMP_algebra.DefaultEmbeddingKD___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
    __del__ = lambda self : None;
DefaultEmbeddingKD_swigregister = _IMP_algebra.DefaultEmbeddingKD_swigregister
DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)

class LogEmbedding1D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(1)> self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
        __init__(IMP::algebra::LogEmbeddingD<(1)> self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
        __init__(IMP::algebra::LogEmbeddingD<(1)> self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts) -> LogEmbedding1D
        __init__(IMP::algebra::LogEmbeddingD<(1)> self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
        __init__(IMP::algebra::LogEmbeddingD<(1)> self) -> LogEmbedding1D
        """
        this = _IMP_algebra.new_LogEmbedding1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.LogEmbedding1D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.LogEmbedding1D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding1D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding1D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
        set_unit_cell(LogEmbedding1D self, Vector1D o)
        """
        return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
        return _IMP_algebra.LogEmbedding1D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
        return _IMP_algebra.LogEmbedding1D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
        get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
        """
        return _IMP_algebra.LogEmbedding1D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
        get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
        """
        return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding1D self, _ostream out=std::cout)
        show(LogEmbedding1D self)
        """
        return _IMP_algebra.LogEmbedding1D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding1D self) -> std::string"""
        return _IMP_algebra.LogEmbedding1D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding1D self) -> std::string"""
        return _IMP_algebra.LogEmbedding1D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
        return _IMP_algebra.LogEmbedding1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding1D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
    __del__ = lambda self : None;
LogEmbedding1D_swigregister = _IMP_algebra.LogEmbedding1D_swigregister
LogEmbedding1D_swigregister(LogEmbedding1D)

class LogEmbedding2D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(2)> self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
        __init__(IMP::algebra::LogEmbeddingD<(2)> self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
        __init__(IMP::algebra::LogEmbeddingD<(2)> self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts) -> LogEmbedding2D
        __init__(IMP::algebra::LogEmbeddingD<(2)> self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
        __init__(IMP::algebra::LogEmbeddingD<(2)> self) -> LogEmbedding2D
        """
        this = _IMP_algebra.new_LogEmbedding2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.LogEmbedding2D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.LogEmbedding2D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding2D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding2D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
        set_unit_cell(LogEmbedding2D self, Vector2D o)
        """
        return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
        return _IMP_algebra.LogEmbedding2D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
        return _IMP_algebra.LogEmbedding2D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
        get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
        """
        return _IMP_algebra.LogEmbedding2D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
        get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
        """
        return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding2D self, _ostream out=std::cout)
        show(LogEmbedding2D self)
        """
        return _IMP_algebra.LogEmbedding2D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding2D self) -> std::string"""
        return _IMP_algebra.LogEmbedding2D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding2D self) -> std::string"""
        return _IMP_algebra.LogEmbedding2D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
        return _IMP_algebra.LogEmbedding2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding2D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
    __del__ = lambda self : None;
LogEmbedding2D_swigregister = _IMP_algebra.LogEmbedding2D_swigregister
LogEmbedding2D_swigregister(LogEmbedding2D)

class LogEmbedding4D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(4)> self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
        __init__(IMP::algebra::LogEmbeddingD<(4)> self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
        __init__(IMP::algebra::LogEmbeddingD<(4)> self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts) -> LogEmbedding4D
        __init__(IMP::algebra::LogEmbeddingD<(4)> self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
        __init__(IMP::algebra::LogEmbeddingD<(4)> self) -> LogEmbedding4D
        """
        this = _IMP_algebra.new_LogEmbedding4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.LogEmbedding4D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.LogEmbedding4D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding4D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding4D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
        set_unit_cell(LogEmbedding4D self, Vector4D o)
        """
        return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
        return _IMP_algebra.LogEmbedding4D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
        return _IMP_algebra.LogEmbedding4D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
        get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
        """
        return _IMP_algebra.LogEmbedding4D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
        get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
        """
        return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding4D self, _ostream out=std::cout)
        show(LogEmbedding4D self)
        """
        return _IMP_algebra.LogEmbedding4D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding4D self) -> std::string"""
        return _IMP_algebra.LogEmbedding4D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding4D self) -> std::string"""
        return _IMP_algebra.LogEmbedding4D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
        return _IMP_algebra.LogEmbedding4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding4D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
    __del__ = lambda self : None;
LogEmbedding4D_swigregister = _IMP_algebra.LogEmbedding4D_swigregister
LogEmbedding4D_swigregister(LogEmbedding4D)

class LogEmbedding5D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(5)> self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
        __init__(IMP::algebra::LogEmbeddingD<(5)> self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
        __init__(IMP::algebra::LogEmbeddingD<(5)> self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts) -> LogEmbedding5D
        __init__(IMP::algebra::LogEmbeddingD<(5)> self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
        __init__(IMP::algebra::LogEmbeddingD<(5)> self) -> LogEmbedding5D
        """
        this = _IMP_algebra.new_LogEmbedding5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.LogEmbedding5D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.LogEmbedding5D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding5D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding5D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
        set_unit_cell(LogEmbedding5D self, Vector5D o)
        """
        return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
        return _IMP_algebra.LogEmbedding5D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
        return _IMP_algebra.LogEmbedding5D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
        get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
        """
        return _IMP_algebra.LogEmbedding5D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
        get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
        """
        return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding5D self, _ostream out=std::cout)
        show(LogEmbedding5D self)
        """
        return _IMP_algebra.LogEmbedding5D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding5D self) -> std::string"""
        return _IMP_algebra.LogEmbedding5D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding5D self) -> std::string"""
        return _IMP_algebra.LogEmbedding5D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
        return _IMP_algebra.LogEmbedding5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding5D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
    __del__ = lambda self : None;
LogEmbedding5D_swigregister = _IMP_algebra.LogEmbedding5D_swigregister
LogEmbedding5D_swigregister(LogEmbedding5D)

class LogEmbedding6D(object):
    """Proxy of C++ IMP::algebra::LogEmbeddingD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::LogEmbeddingD<(6)> self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
        __init__(IMP::algebra::LogEmbeddingD<(6)> self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
        __init__(IMP::algebra::LogEmbeddingD<(6)> self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts) -> LogEmbedding6D
        __init__(IMP::algebra::LogEmbeddingD<(6)> self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
        __init__(IMP::algebra::LogEmbeddingD<(6)> self) -> LogEmbedding6D
        """
        this = _IMP_algebra.new_LogEmbedding6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_origin(self, *args):
        """set_origin(LogEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.LogEmbedding6D_set_origin(self, *args)

    def get_origin(self):
        """get_origin(LogEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.LogEmbedding6D_get_origin(self)

    def get_dimension(self):
        """get_dimension(LogEmbedding6D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding6D_get_dimension(self)

    def set_unit_cell(self, *args):
        """
        set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
        set_unit_cell(LogEmbedding6D self, Vector6D o)
        """
        return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)

    def get_unit_cell(self):
        """get_unit_cell(LogEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)

    def get_extended_index(self, *args):
        """get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
        return _IMP_algebra.LogEmbedding6D_get_extended_index(self, *args)

    def get_index(self, *args):
        """get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
        return _IMP_algebra.LogEmbedding6D_get_index(self, *args)

    def get_center(self, *args):
        """
        get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
        get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
        """
        return _IMP_algebra.LogEmbedding6D_get_center(self, *args)

    def get_bounding_box(self, *args):
        """
        get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
        get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
        """
        return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)

    def show(self, *args):
        """
        show(LogEmbedding6D self, _ostream out=std::cout)
        show(LogEmbedding6D self)
        """
        return _IMP_algebra.LogEmbedding6D_show(self, *args)

    def __str__(self):
        """__str__(LogEmbedding6D self) -> std::string"""
        return _IMP_algebra.LogEmbedding6D___str__(self)

    def __repr__(self):
        """__repr__(LogEmbedding6D self) -> std::string"""
        return _IMP_algebra.LogEmbedding6D___repr__(self)

    def __cmp__(self, *args):
        """__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
        return _IMP_algebra.LogEmbedding6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding6D___eq__(self, *args)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
    __del__ = lambda self : None;
LogEmbedding6D_swigregister = _IMP_algebra.LogEmbedding6D_swigregister
LogEmbedding6D_swigregister(LogEmbedding6D)

class SpherePatch3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::SpherePatch3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::SpherePatch3D self) -> SpherePatch3D
        __init__(IMP::algebra::SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
        """
        this = _IMP_algebra.new_SpherePatch3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_contains(self, *args):
        """get_contains(SpherePatch3D self, Vector3D p) -> bool"""
        return _IMP_algebra.SpherePatch3D_get_contains(self, *args)

    def get_plane(self):
        """get_plane(SpherePatch3D self) -> Plane3D"""
        return _IMP_algebra.SpherePatch3D_get_plane(self)

    def get_sphere(self):
        """get_sphere(SpherePatch3D self) -> Sphere3D"""
        return _IMP_algebra.SpherePatch3D_get_sphere(self)

    def show(self, *args):
        """
        show(SpherePatch3D self, _ostream out=std::cout)
        show(SpherePatch3D self)
        """
        return _IMP_algebra.SpherePatch3D_show(self, *args)

    def get_boundary_point(self):
        """get_boundary_point(SpherePatch3D self) -> Vector3D"""
        return _IMP_algebra.SpherePatch3D_get_boundary_point(self)

    def __str__(self):
        """__str__(SpherePatch3D self) -> std::string"""
        return _IMP_algebra.SpherePatch3D___str__(self)

    def __repr__(self):
        """__repr__(SpherePatch3D self) -> std::string"""
        return _IMP_algebra.SpherePatch3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
    __del__ = lambda self : None;
SpherePatch3D_swigregister = _IMP_algebra.SpherePatch3D_swigregister
SpherePatch3D_swigregister(SpherePatch3D)


def get_area(*args):
  """
    get_area(Plane3D g) -> double
    get_area(SpherePatch3D g) -> double
    """
  return _IMP_algebra.get_area(*args)

def get_sphere_patch_3d_geometry(*args):
  """get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
  return _IMP_algebra.get_sphere_patch_3d_geometry(*args)
class Cone3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Cone3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Cone3D self) -> Cone3D
        __init__(IMP::algebra::Cone3D self, Segment3D s, double radius) -> Cone3D
        """
        this = _IMP_algebra.new_Cone3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_tip(self):
        """get_tip(Cone3D self) -> Vector3D"""
        return _IMP_algebra.Cone3D_get_tip(self)

    def get_direction(self):
        """get_direction(Cone3D self) -> Vector3D"""
        return _IMP_algebra.Cone3D_get_direction(self)

    def get_height(self):
        """get_height(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_height(self)

    def get_angle(self):
        """get_angle(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_angle(self)

    def get_radius(self):
        """get_radius(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_radius(self)

    def get_contains(self, *args):
        """get_contains(Cone3D self, Vector3D v) -> bool"""
        return _IMP_algebra.Cone3D_get_contains(self, *args)

    def get_base_plane(self):
        """get_base_plane(Cone3D self) -> Plane3D"""
        return _IMP_algebra.Cone3D_get_base_plane(self)

    def show(self, *args):
        """
        show(Cone3D self, _ostream out=std::cout)
        show(Cone3D self)
        """
        return _IMP_algebra.Cone3D_show(self, *args)

    def __str__(self):
        """__str__(Cone3D self) -> std::string"""
        return _IMP_algebra.Cone3D___str__(self)

    def __repr__(self):
        """__repr__(Cone3D self) -> std::string"""
        return _IMP_algebra.Cone3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Cone3D
    __del__ = lambda self : None;
Cone3D_swigregister = _IMP_algebra.Cone3D_swigregister
Cone3D_swigregister(Cone3D)


def get_surface_area(*args):
  """
    get_surface_area(BoundingBox3D g) -> double
    get_surface_area(Sphere3D g) -> double
    get_surface_area(Cylinder3D g) -> double
    get_surface_area(Ellipsoid3D g) -> double
    get_surface_area(Cone3D g) -> double
    """
  return _IMP_algebra.get_surface_area(*args)

def get_volume(*args):
  """
    get_volume(BoundingBox3D g) -> double
    get_volume(Sphere3D g) -> double
    get_volume(Cylinder3D g) -> double
    get_volume(Ellipsoid3D g) -> double
    get_volume(Cone3D g) -> double
    """
  return _IMP_algebra.get_volume(*args)

def get_cone_3d_geometry(*args):
  """get_cone_3d_geometry(Cone3D g) -> Cone3D"""
  return _IMP_algebra.get_cone_3d_geometry(*args)

def write_pts(*args):
  """write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
  return _IMP_algebra.write_pts(*args)

def read_pts(*args):
  """read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
  return _IMP_algebra.read_pts(*args)

def write_spheres(*args):
  """write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
  return _IMP_algebra.write_spheres(*args)

def read_spheres(*args):
  """read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
  return _IMP_algebra.read_spheres(*args)

def get_random_vector_on_unit_sphere():
  """get_random_vector_on_unit_sphere() -> Vector3D"""
  return _IMP_algebra.get_random_vector_on_unit_sphere()

def get_grid_surface_cover(*args):
  """get_grid_surface_cover(Cylinder3D cyl, int number_of_cycles, int number_of_points_on_cycle) -> IMP::algebra::Vector3Ds"""
  return _IMP_algebra.get_grid_surface_cover(*args)

def get_random_chain(*args):
  """
    get_random_chain(unsigned int n, double r, Vector3D start=IMP::algebra::Vector3D(0, 0, 0), IMP::algebra::Sphere3Ds const & obstacles=IMP::algebra::Sphere3Ds()) -> IMP::algebra::Vector3Ds
    get_random_chain(unsigned int n, double r, Vector3D start=IMP::algebra::Vector3D(0, 0, 0)) -> IMP::algebra::Vector3Ds
    get_random_chain(unsigned int n, double r) -> IMP::algebra::Vector3Ds
    """
  return _IMP_algebra.get_random_chain(*args)

def reversed_read(*args):
  """reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
  return _IMP_algebra.reversed_read(*args)

def reversed_write(*args):
  """
    reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)
    reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f)
    """
  return _IMP_algebra.reversed_write(*args)

def get_is_big_endian():
  """get_is_big_endian() -> bool"""
  return _IMP_algebra.get_is_big_endian()

def get_is_little_endian():
  """get_is_little_endian() -> bool"""
  return _IMP_algebra.get_is_little_endian()

def get_shortest_segment(*args):
  """
    get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
    get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
    """
  return _IMP_algebra.get_shortest_segment(*args)
class DynamicNearestNeighbor3D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D
        __init__(IMP::algebra::DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs) -> DynamicNearestNeighbor3D
        """
        this = _IMP_algebra.new_DynamicNearestNeighbor3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_in_ball(self, *args):
        """get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
        return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, *args)

    def set_coordinates(self, *args):
        """set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
        return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, *args)

    def get_version_info(self):
        """get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
        return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)

    def __str__(self):
        """__str__(DynamicNearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)

    def __repr__(self):
        """__repr__(DynamicNearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)

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

DynamicNearestNeighbor3D_swigregister = _IMP_algebra.DynamicNearestNeighbor3D_swigregister
DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)

class VectorKDMetric(IMP.base.Object):
    """Proxy of C++ IMP::algebra::VectorKDMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::algebra::VectorKDMetric self, std::string name) -> VectorKDMetric"""
        if self.__class__ == VectorKDMetric:
            _self = None
        else:
            _self = self
        this = _IMP_algebra.new_VectorKDMetric(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != VectorKDMetric:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_distance(self, *args):
        """get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
        return _IMP_algebra.VectorKDMetric_get_distance(self, *args)

    def get_centroid(self, *args):
        """get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
        return _IMP_algebra.VectorKDMetric_get_centroid(self, *args)

    def __str__(self):
        """__str__(VectorKDMetric self) -> std::string"""
        return _IMP_algebra.VectorKDMetric___str__(self)

    def __repr__(self):
        """__repr__(VectorKDMetric self) -> std::string"""
        return _IMP_algebra.VectorKDMetric___repr__(self)

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

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

    __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _IMP_algebra.disown_VectorKDMetric(self)
        return weakref_proxy(self)
    def do_destroy(self):
        """do_destroy(VectorKDMetric self)"""
        return _IMP_algebra.VectorKDMetric_do_destroy(self)

VectorKDMetric_swigregister = _IMP_algebra.VectorKDMetric_swigregister
VectorKDMetric_swigregister(VectorKDMetric)

class EuclideanVectorKDMetric(VectorKDMetric):
    """Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, name="EuclideanVectorKDMetric%1%"): 
        """
        __init__(IMP::algebra::EuclideanVectorKDMetric self, std::string name="EuclideanVectorKDMetric%1%") -> EuclideanVectorKDMetric
        __init__(IMP::algebra::EuclideanVectorKDMetric self) -> EuclideanVectorKDMetric
        """
        this = _IMP_algebra.new_EuclideanVectorKDMetric(name)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
        return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)

    def __str__(self):
        """__str__(EuclideanVectorKDMetric self) -> std::string"""
        return _IMP_algebra.EuclideanVectorKDMetric___str__(self)

    def __repr__(self):
        """__repr__(EuclideanVectorKDMetric self) -> std::string"""
        return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)

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

EuclideanVectorKDMetric_swigregister = _IMP_algebra.EuclideanVectorKDMetric_swigregister
EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)

class MaxVectorKDMetric(VectorKDMetric):
    """Proxy of C++ IMP::algebra::MaxVectorKDMetric class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, name="MaxVectorKDMetric%1%"): 
        """
        __init__(IMP::algebra::MaxVectorKDMetric self, std::string name="MaxVectorKDMetric%1%") -> MaxVectorKDMetric
        __init__(IMP::algebra::MaxVectorKDMetric self) -> MaxVectorKDMetric
        """
        this = _IMP_algebra.new_MaxVectorKDMetric(name)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
        return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)

    def __str__(self):
        """__str__(MaxVectorKDMetric self) -> std::string"""
        return _IMP_algebra.MaxVectorKDMetric___str__(self)

    def __repr__(self):
        """__repr__(MaxVectorKDMetric self) -> std::string"""
        return _IMP_algebra.MaxVectorKDMetric___repr__(self)

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

MaxVectorKDMetric_swigregister = _IMP_algebra.MaxVectorKDMetric_swigregister
MaxVectorKDMetric_swigregister(MaxVectorKDMetric)

class Gaussian3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::Gaussian3D class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::Gaussian3D self) -> Gaussian3D
        __init__(IMP::algebra::Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
        """
        this = _IMP_algebra.new_Gaussian3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_reference_frame(self):
        """get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
        return _IMP_algebra.Gaussian3D_get_reference_frame(self)

    def get_variances(self):
        """get_variances(Gaussian3D self) -> Vector3D"""
        return _IMP_algebra.Gaussian3D_get_variances(self)

    def get_center(self):
        """get_center(Gaussian3D self) -> Vector3D"""
        return _IMP_algebra.Gaussian3D_get_center(self)

    def show(self, *args):
        """
        show(Gaussian3D self, _ostream out=std::cout)
        show(Gaussian3D self)
        """
        return _IMP_algebra.Gaussian3D_show(self, *args)

    def __str__(self):
        """__str__(Gaussian3D self) -> std::string"""
        return _IMP_algebra.Gaussian3D___str__(self)

    def __repr__(self):
        """__repr__(Gaussian3D self) -> std::string"""
        return _IMP_algebra.Gaussian3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
    __del__ = lambda self : None;
Gaussian3D_swigregister = _IMP_algebra.Gaussian3D_swigregister
Gaussian3D_swigregister(Gaussian3D)


def get_covariance(*args):
  """get_covariance(Gaussian3D g) -> IMP_Eigen::Matrix3d"""
  return _IMP_algebra.get_covariance(*args)

def get_gaussian_from_covariance(*args):
  """get_gaussian_from_covariance(IMP_Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
  return _IMP_algebra.get_gaussian_from_covariance(*args)

def get_rasterized(*args):
  """
    get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, 
        BoundingBox3D bb) -> DenseFloatGrid3D
    """
  return _IMP_algebra.get_rasterized(*args)

def _pass_matrix_xf(*args):
  """_pass_matrix_xf(IMP_Eigen::MatrixXf const & m) -> IMP_Eigen::MatrixXf"""
  return _IMP_algebra._pass_matrix_xf(*args)

def _pass_matrix_xd(*args):
  """_pass_matrix_xd(IMP_Eigen::MatrixXd const & m) -> IMP_Eigen::MatrixXd"""
  return _IMP_algebra._pass_matrix_xd(*args)

def _pass_matrix_3d(*args):
  """_pass_matrix_3d(IMP_Eigen::Matrix3d const & m) -> IMP_Eigen::Matrix3d"""
  return _IMP_algebra._pass_matrix_3d(*args)

def _pass_array_xd(*args):
  """_pass_array_xd(IMP_Eigen::ArrayXXd const & m) -> IMP_Eigen::ArrayXXd"""
  return _IMP_algebra._pass_array_xd(*args)

def _pass_vector_xd(*args):
  """_pass_vector_xd(IMP_Eigen::VectorXd const & m) -> IMP_Eigen::VectorXd"""
  return _IMP_algebra._pass_vector_xd(*args)
class NearestNeighbor1D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(1)> self, IMP::base::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D
        __init__(IMP::algebra::NearestNeighborD<(1)> self, IMP::base::Vector< IMP::algebra::VectorD< 1 > > const & vs) -> NearestNeighbor1D
        """
        this = _IMP_algebra.new_NearestNeighbor1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor1D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor1D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor1D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor1D self, Vector1D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor1D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor1D self, Vector1D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor1D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor1D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor1D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor1D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor1D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor1D___repr__(self)

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

NearestNeighbor1D_swigregister = _IMP_algebra.NearestNeighbor1D_swigregister
NearestNeighbor1D_swigregister(NearestNeighbor1D)

class NearestNeighbor2D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(2)> self, IMP::base::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D
        __init__(IMP::algebra::NearestNeighborD<(2)> self, IMP::base::Vector< IMP::algebra::VectorD< 2 > > const & vs) -> NearestNeighbor2D
        """
        this = _IMP_algebra.new_NearestNeighbor2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor2D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor2D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor2D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor2D self, Vector2D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor2D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor2D self, Vector2D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor2D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor2D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor2D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor2D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor2D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor2D___repr__(self)

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

NearestNeighbor2D_swigregister = _IMP_algebra.NearestNeighbor2D_swigregister
NearestNeighbor2D_swigregister(NearestNeighbor2D)

class NearestNeighbor3D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(3)> self, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D
        __init__(IMP::algebra::NearestNeighborD<(3)> self, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & vs) -> NearestNeighbor3D
        """
        this = _IMP_algebra.new_NearestNeighbor3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor3D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor3D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor3D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor3D self, Vector3D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor3D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor3D self, Vector3D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor3D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor3D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor3D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor3D___repr__(self)

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

NearestNeighbor3D_swigregister = _IMP_algebra.NearestNeighbor3D_swigregister
NearestNeighbor3D_swigregister(NearestNeighbor3D)

class NearestNeighbor4D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(4)> self, IMP::base::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D
        __init__(IMP::algebra::NearestNeighborD<(4)> self, IMP::base::Vector< IMP::algebra::VectorD< 4 > > const & vs) -> NearestNeighbor4D
        """
        this = _IMP_algebra.new_NearestNeighbor4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor4D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor4D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor4D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor4D self, Vector4D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor4D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor4D self, Vector4D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor4D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor4D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor4D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor4D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor4D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor4D___repr__(self)

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

NearestNeighbor4D_swigregister = _IMP_algebra.NearestNeighbor4D_swigregister
NearestNeighbor4D_swigregister(NearestNeighbor4D)

class NearestNeighbor5D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(5)> self, IMP::base::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D
        __init__(IMP::algebra::NearestNeighborD<(5)> self, IMP::base::Vector< IMP::algebra::VectorD< 5 > > const & vs) -> NearestNeighbor5D
        """
        this = _IMP_algebra.new_NearestNeighbor5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor5D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor5D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor5D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor5D self, Vector5D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor5D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor5D self, Vector5D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor5D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor5D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor5D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor5D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor5D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor5D___repr__(self)

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

NearestNeighbor5D_swigregister = _IMP_algebra.NearestNeighbor5D_swigregister
NearestNeighbor5D_swigregister(NearestNeighbor5D)

class NearestNeighbor6D(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(6)> self, IMP::base::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D
        __init__(IMP::algebra::NearestNeighborD<(6)> self, IMP::base::Vector< IMP::algebra::VectorD< 6 > > const & vs) -> NearestNeighbor6D
        """
        this = _IMP_algebra.new_NearestNeighbor6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighbor6D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor6D_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
        get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighbor6D self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighbor6D self, Vector6D v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighbor6D self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighbor6D self, Vector6D pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighbor6D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor6D_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighbor6D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor6D___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighbor6D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor6D___repr__(self)

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

NearestNeighbor6D_swigregister = _IMP_algebra.NearestNeighbor6D_swigregister
NearestNeighbor6D_swigregister(NearestNeighbor6D)

class NearestNeighborKD(IMP.base.Object):
    """Proxy of C++ IMP::algebra::NearestNeighborD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::NearestNeighborD<(-1)> self, IMP::base::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD
        __init__(IMP::algebra::NearestNeighborD<(-1)> self, IMP::base::Vector< IMP::algebra::VectorD< -1 > > const & vs) -> NearestNeighborKD
        """
        this = _IMP_algebra.new_NearestNeighborKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_query_log(self, *args):
        """set_query_log(NearestNeighborKD self, std::string fname)"""
        return _IMP_algebra.NearestNeighborKD_set_query_log(self, *args)

    def get_nearest_neighbor(self, *args):
        """
        get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
        get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
        """
        return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)

    def get_nearest_neighbors(self, *args):
        """
        get_nearest_neighbors(NearestNeighborKD self, unsigned int i, unsigned int k) -> IMP::Ints
        get_nearest_neighbors(NearestNeighborKD self, VectorKD v, unsigned int k) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)

    def get_in_ball(self, *args):
        """
        get_in_ball(NearestNeighborKD self, unsigned int i, double distance) -> IMP::Ints
        get_in_ball(NearestNeighborKD self, VectorKD pt, double distance) -> IMP::Ints
        """
        return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)

    def get_version_info(self):
        """get_version_info(NearestNeighborKD self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighborKD_get_version_info(self)

    def __str__(self):
        """__str__(NearestNeighborKD self) -> std::string"""
        return _IMP_algebra.NearestNeighborKD___str__(self)

    def __repr__(self):
        """__repr__(NearestNeighborKD self) -> std::string"""
        return _IMP_algebra.NearestNeighborKD___repr__(self)

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

NearestNeighborKD_swigregister = _IMP_algebra.NearestNeighborKD_swigregister
NearestNeighborKD_swigregister(NearestNeighborKD)


def get_transformation_aligning_pair(*args):
  """get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
  return _IMP_algebra.get_transformation_aligning_pair(*args)
class PrincipalComponentAnalysis1D(_GeometricPrimitive1D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(1)> self) -> PrincipalComponentAnalysis1D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(1)> self, IMP::base::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis1D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::base::Vector< IMP::algebra::VectorD< 1 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis1D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis1D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
    __del__ = lambda self : None;
PrincipalComponentAnalysis1D_swigregister = _IMP_algebra.PrincipalComponentAnalysis1D_swigregister
PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)

class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(2)> self) -> PrincipalComponentAnalysis2D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(2)> self, IMP::base::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis2D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::base::Vector< IMP::algebra::VectorD< 2 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis2D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis2D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
    __del__ = lambda self : None;
PrincipalComponentAnalysis2D_swigregister = _IMP_algebra.PrincipalComponentAnalysis2D_swigregister
PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)

class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(3)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(3)> self) -> PrincipalComponentAnalysis3D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(3)> self, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::base::Vector< IMP::algebra::VectorD< 3 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis3D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis3D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
    __del__ = lambda self : None;
PrincipalComponentAnalysis3D_swigregister = _IMP_algebra.PrincipalComponentAnalysis3D_swigregister
PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)

class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(4)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(4)> self) -> PrincipalComponentAnalysis4D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(4)> self, IMP::base::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis4D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::base::Vector< IMP::algebra::VectorD< 4 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis4D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis4D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
    __del__ = lambda self : None;
PrincipalComponentAnalysis4D_swigregister = _IMP_algebra.PrincipalComponentAnalysis4D_swigregister
PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)

class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(5)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(5)> self) -> PrincipalComponentAnalysis5D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(5)> self, IMP::base::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis5D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::base::Vector< IMP::algebra::VectorD< 5 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis5D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis5D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
    __del__ = lambda self : None;
PrincipalComponentAnalysis5D_swigregister = _IMP_algebra.PrincipalComponentAnalysis5D_swigregister
PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)

class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(6)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(6)> self) -> PrincipalComponentAnalysis6D
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(6)> self, IMP::base::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysis6D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::base::Vector< IMP::algebra::VectorD< 6 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)
        show(PrincipalComponentAnalysis6D self)
        """
        return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysis6D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
    __del__ = lambda self : None;
PrincipalComponentAnalysis6D_swigregister = _IMP_algebra.PrincipalComponentAnalysis6D_swigregister
PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)

class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
    """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(-1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(-1)> self) -> PrincipalComponentAnalysisKD
        __init__(IMP::algebra::PrincipalComponentAnalysisD<(-1)> self, IMP::base::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
        """
        this = _IMP_algebra.new_PrincipalComponentAnalysisKD(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_principal_components(self):
        """get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::base::Vector< IMP::algebra::VectorD< -1 > >"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)

    def get_principal_component(self, *args):
        """get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, *args)

    def get_principal_values(self):
        """get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)

    def get_principal_value(self, *args):
        """get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, *args)

    def get_centroid(self):
        """get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)

    def set_centroid(self, *args):
        """set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, *args)

    def show(self, *args):
        """
        show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)
        show(PrincipalComponentAnalysisKD self)
        """
        return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)

    def __cmp__(self, *args):
        """__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, *args)

    def __eq__(self, *args):
        """__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, *args)

    def __le__(self, *args):
        """__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, *args)

    def __str__(self):
        """__str__(PrincipalComponentAnalysisKD self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)

    def __repr__(self):
        """__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
    __del__ = lambda self : None;
PrincipalComponentAnalysisKD_swigregister = _IMP_algebra.PrincipalComponentAnalysisKD_swigregister
PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)


def get_principal_components(*args):
  """
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector1D > const & a) -> PrincipalComponentAnalysis1D
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector2D > const & a) -> PrincipalComponentAnalysis2D
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector3D > const & a) -> PrincipalComponentAnalysis3D
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector4D > const & a) -> PrincipalComponentAnalysis4D
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector5D > const & a) -> PrincipalComponentAnalysis5D
    get_principal_components(IMP::base::Vector< IMP::algebra::Vector6D > const & a) -> PrincipalComponentAnalysis6D
    get_principal_components(IMP::base::Vector< IMP::algebra::VectorKD > const & a) -> PrincipalComponentAnalysisKD
    """
  return _IMP_algebra.get_principal_components(*args)

def get_vertices(*args):
  """
    get_vertices(BoundingBox1D a) -> IMP::base::Vector< IMP::algebra::Vector1D >
    get_vertices(BoundingBox2D a) -> IMP::base::Vector< IMP::algebra::Vector2D >
    get_vertices(BoundingBox3D a) -> IMP::base::Vector< IMP::algebra::Vector3D >
    get_vertices(BoundingBox4D a) -> IMP::base::Vector< IMP::algebra::Vector4D >
    get_vertices(BoundingBox5D a) -> IMP::base::Vector< IMP::algebra::Vector5D >
    get_vertices(BoundingBox6D a) -> IMP::base::Vector< IMP::algebra::Vector6D >
    get_vertices(BoundingBoxKD a) -> IMP::base::Vector< IMP::algebra::VectorKD >
    """
  return _IMP_algebra.get_vertices(*args)

def get_distance(*args):
  """
    get_distance(Rotation3D r0, Rotation3D r1) -> double
    get_distance(Segment3D s, Vector3D p) -> double
    get_distance(Segment3D a, Segment3D b) -> double
    get_distance(Plane3D pln, Vector3D p) -> double
    get_distance(Vector1D a, Vector1D b) -> double
    get_distance(Vector2D a, Vector2D b) -> double
    get_distance(Vector3D a, Vector3D b) -> double
    get_distance(Vector4D a, Vector4D b) -> double
    get_distance(Vector5D a, Vector5D b) -> double
    get_distance(Vector6D a, Vector6D b) -> double
    get_distance(VectorKD a, VectorKD b) -> double
    get_distance(Sphere1D a, Sphere1D b) -> double
    get_distance(Sphere2D a, Sphere2D b) -> double
    get_distance(Sphere3D a, Sphere3D b) -> double
    get_distance(Sphere4D a, Sphere4D b) -> double
    get_distance(Sphere5D a, Sphere5D b) -> double
    get_distance(Sphere6D a, Sphere6D b) -> double
    get_distance(SphereKD a, SphereKD b) -> double
    """
  return _IMP_algebra.get_distance(*args)

def get_squared_distance(*args):
  """
    get_squared_distance(Vector1D a, Vector1D b) -> double
    get_squared_distance(Vector2D a, Vector2D b) -> double
    get_squared_distance(Vector3D a, Vector3D b) -> double
    get_squared_distance(Vector4D a, Vector4D b) -> double
    get_squared_distance(Vector5D a, Vector5D b) -> double
    get_squared_distance(Vector6D a, Vector6D b) -> double
    get_squared_distance(VectorKD a, VectorKD b) -> double
    """
  return _IMP_algebra.get_squared_distance(*args)

def get_basis_vector_1d(*args):
  """get_basis_vector_1d(unsigned int coordinate) -> Vector1D"""
  return _IMP_algebra.get_basis_vector_1d(*args)

def get_basis_vector_2d(*args):
  """get_basis_vector_2d(unsigned int coordinate) -> Vector2D"""
  return _IMP_algebra.get_basis_vector_2d(*args)

def get_basis_vector_3d(*args):
  """get_basis_vector_3d(unsigned int coordinate) -> Vector3D"""
  return _IMP_algebra.get_basis_vector_3d(*args)

def get_basis_vector_4d(*args):
  """get_basis_vector_4d(unsigned int coordinate) -> Vector4D"""
  return _IMP_algebra.get_basis_vector_4d(*args)

def get_basis_vector_5d(*args):
  """get_basis_vector_5d(unsigned int coordinate) -> Vector5D"""
  return _IMP_algebra.get_basis_vector_5d(*args)

def get_basis_vector_6d(*args):
  """get_basis_vector_6d(unsigned int coordinate) -> Vector6D"""
  return _IMP_algebra.get_basis_vector_6d(*args)

def get_zero_vector_1d():
  """get_zero_vector_1d() -> Vector1D"""
  return _IMP_algebra.get_zero_vector_1d()

def get_zero_vector_2d():
  """get_zero_vector_2d() -> Vector2D"""
  return _IMP_algebra.get_zero_vector_2d()

def get_zero_vector_3d():
  """get_zero_vector_3d() -> Vector3D"""
  return _IMP_algebra.get_zero_vector_3d()

def get_zero_vector_4d():
  """get_zero_vector_4d() -> Vector4D"""
  return _IMP_algebra.get_zero_vector_4d()

def get_zero_vector_5d():
  """get_zero_vector_5d() -> Vector5D"""
  return _IMP_algebra.get_zero_vector_5d()

def get_zero_vector_6d():
  """get_zero_vector_6d() -> Vector6D"""
  return _IMP_algebra.get_zero_vector_6d()

def get_ones_vector_1d(v=1):
  """
    get_ones_vector_1d(double v=1) -> Vector1D
    get_ones_vector_1d() -> Vector1D
    """
  return _IMP_algebra.get_ones_vector_1d(v)

def get_ones_vector_2d(v=1):
  """
    get_ones_vector_2d(double v=1) -> Vector2D
    get_ones_vector_2d() -> Vector2D
    """
  return _IMP_algebra.get_ones_vector_2d(v)

def get_ones_vector_3d(v=1):
  """
    get_ones_vector_3d(double v=1) -> Vector3D
    get_ones_vector_3d() -> Vector3D
    """
  return _IMP_algebra.get_ones_vector_3d(v)

def get_ones_vector_4d(v=1):
  """
    get_ones_vector_4d(double v=1) -> Vector4D
    get_ones_vector_4d() -> Vector4D
    """
  return _IMP_algebra.get_ones_vector_4d(v)

def get_ones_vector_5d(v=1):
  """
    get_ones_vector_5d(double v=1) -> Vector5D
    get_ones_vector_5d() -> Vector5D
    """
  return _IMP_algebra.get_ones_vector_5d(v)

def get_ones_vector_6d(v=1):
  """
    get_ones_vector_6d(double v=1) -> Vector6D
    get_ones_vector_6d() -> Vector6D
    """
  return _IMP_algebra.get_ones_vector_6d(v)

def get_unit_bounding_box_1d():
  """get_unit_bounding_box_1d() -> BoundingBox1D"""
  return _IMP_algebra.get_unit_bounding_box_1d()

def get_unit_bounding_box_2d():
  """get_unit_bounding_box_2d() -> BoundingBox2D"""
  return _IMP_algebra.get_unit_bounding_box_2d()

def get_unit_bounding_box_3d():
  """get_unit_bounding_box_3d() -> BoundingBox3D"""
  return _IMP_algebra.get_unit_bounding_box_3d()

def get_unit_bounding_box_4d():
  """get_unit_bounding_box_4d() -> BoundingBox4D"""
  return _IMP_algebra.get_unit_bounding_box_4d()

def get_unit_bounding_box_5d():
  """get_unit_bounding_box_5d() -> BoundingBox5D"""
  return _IMP_algebra.get_unit_bounding_box_5d()

def get_unit_bounding_box_6d():
  """get_unit_bounding_box_6d() -> BoundingBox6D"""
  return _IMP_algebra.get_unit_bounding_box_6d()

def get_cube_1d(*args):
  """get_cube_1d(double radius) -> BoundingBox1D"""
  return _IMP_algebra.get_cube_1d(*args)

def get_cube_2d(*args):
  """get_cube_2d(double radius) -> BoundingBox2D"""
  return _IMP_algebra.get_cube_2d(*args)

def get_cube_3d(*args):
  """get_cube_3d(double radius) -> BoundingBox3D"""
  return _IMP_algebra.get_cube_3d(*args)

def get_cube_4d(*args):
  """get_cube_4d(double radius) -> BoundingBox4D"""
  return _IMP_algebra.get_cube_4d(*args)

def get_cube_5d(*args):
  """get_cube_5d(double radius) -> BoundingBox5D"""
  return _IMP_algebra.get_cube_5d(*args)

def get_cube_6d(*args):
  """get_cube_6d(double radius) -> BoundingBox6D"""
  return _IMP_algebra.get_cube_6d(*args)

def get_unit_sphere_1d():
  """get_unit_sphere_1d() -> Sphere1D"""
  return _IMP_algebra.get_unit_sphere_1d()

def get_unit_sphere_2d():
  """get_unit_sphere_2d() -> Sphere2D"""
  return _IMP_algebra.get_unit_sphere_2d()

def get_unit_sphere_3d():
  """get_unit_sphere_3d() -> Sphere3D"""
  return _IMP_algebra.get_unit_sphere_3d()

def get_unit_sphere_4d():
  """get_unit_sphere_4d() -> Sphere4D"""
  return _IMP_algebra.get_unit_sphere_4d()

def get_unit_sphere_5d():
  """get_unit_sphere_5d() -> Sphere5D"""
  return _IMP_algebra.get_unit_sphere_5d()

def get_unit_sphere_6d():
  """get_unit_sphere_6d() -> Sphere6D"""
  return _IMP_algebra.get_unit_sphere_6d()

def get_interiors_intersect(*args):
  """
    get_interiors_intersect(Sphere1D a, Sphere1D b) -> bool
    get_interiors_intersect(Sphere2D a, Sphere2D b) -> bool
    get_interiors_intersect(Sphere3D a, Sphere3D b) -> bool
    get_interiors_intersect(Sphere4D a, Sphere4D b) -> bool
    get_interiors_intersect(Sphere5D a, Sphere5D b) -> bool
    get_interiors_intersect(Sphere6D a, Sphere6D b) -> bool
    get_interiors_intersect(SphereKD a, SphereKD b) -> bool
    get_interiors_intersect(BoundingBox1D a, BoundingBox1D b) -> bool
    get_interiors_intersect(BoundingBox2D a, BoundingBox2D b) -> bool
    get_interiors_intersect(BoundingBox3D a, BoundingBox3D b) -> bool
    get_interiors_intersect(BoundingBox4D a, BoundingBox4D b) -> bool
    get_interiors_intersect(BoundingBox5D a, BoundingBox5D b) -> bool
    get_interiors_intersect(BoundingBox6D a, BoundingBox6D b) -> bool
    get_interiors_intersect(BoundingBoxKD a, BoundingBoxKD b) -> bool
    """
  return _IMP_algebra.get_interiors_intersect(*args)

def get_random_vector_on(*args):
  """
    get_random_vector_on(Sphere1D a) -> Vector1D
    get_random_vector_on(Sphere2D a) -> Vector2D
    get_random_vector_on(Sphere3D a) -> Vector3D
    get_random_vector_on(Sphere4D a) -> Vector4D
    get_random_vector_on(Sphere5D a) -> Vector5D
    get_random_vector_on(Sphere6D a) -> Vector6D
    get_random_vector_on(SphereKD a) -> VectorKD
    get_random_vector_on(BoundingBox1D a) -> Vector1D
    get_random_vector_on(BoundingBox2D a) -> Vector2D
    get_random_vector_on(BoundingBox3D a) -> Vector3D
    get_random_vector_on(BoundingBox4D a) -> Vector4D
    get_random_vector_on(BoundingBox5D a) -> Vector5D
    get_random_vector_on(BoundingBox6D a) -> Vector6D
    get_random_vector_on(BoundingBoxKD a) -> VectorKD
    """
  return _IMP_algebra.get_random_vector_on(*args)

def get_random_vector_in(*args):
  """
    get_random_vector_in(Cylinder3D c) -> Vector3D
    get_random_vector_in(Sphere1D a) -> Vector1D
    get_random_vector_in(Sphere2D a) -> Vector2D
    get_random_vector_in(Sphere3D a) -> Vector3D
    get_random_vector_in(Sphere4D a) -> Vector4D
    get_random_vector_in(Sphere5D a) -> Vector5D
    get_random_vector_in(Sphere6D a) -> Vector6D
    get_random_vector_in(SphereKD a) -> VectorKD
    get_random_vector_in(BoundingBox1D a) -> Vector1D
    get_random_vector_in(BoundingBox2D a) -> Vector2D
    get_random_vector_in(BoundingBox3D a) -> Vector3D
    get_random_vector_in(BoundingBox4D a) -> Vector4D
    get_random_vector_in(BoundingBox5D a) -> Vector5D
    get_random_vector_in(BoundingBox6D a) -> Vector6D
    get_random_vector_in(BoundingBoxKD a) -> VectorKD
    """
  return _IMP_algebra.get_random_vector_in(*args)

def get_intersection(*args):
  """
    get_intersection(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
    get_intersection(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
    get_intersection(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
    get_intersection(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
    get_intersection(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
    get_intersection(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
    get_intersection(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
    """
  return _IMP_algebra.get_intersection(*args)

def get_union(*args):
  """
    get_union(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
    get_union(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
    get_union(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
    get_union(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
    get_union(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
    get_union(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
    get_union(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
    """
  return _IMP_algebra.get_union(*args)

def get_bounding_box(*args):
  """
    get_bounding_box(Segment3D g) -> BoundingBox3D
    get_bounding_box(Plane3D g) -> BoundingBox3D
    get_bounding_box(Cylinder3D g) -> BoundingBox3D
    get_bounding_box(Ellipsoid3D g) -> BoundingBox3D
    get_bounding_box(SpherePatch3D g) -> BoundingBox3D
    get_bounding_box(Cone3D g) -> BoundingBox3D
    get_bounding_box(Sphere1D a) -> BoundingBox1D
    get_bounding_box(Sphere2D a) -> BoundingBox2D
    get_bounding_box(Sphere3D a) -> BoundingBox3D
    get_bounding_box(Sphere4D a) -> BoundingBox4D
    get_bounding_box(Sphere5D a) -> BoundingBox5D
    get_bounding_box(Sphere6D a) -> BoundingBox6D
    get_bounding_box(SphereKD a) -> BoundingBoxKD
    """
  return _IMP_algebra.get_bounding_box(*args)

def get_uniform_surface_cover(*args):
  """
    get_uniform_surface_cover(Cylinder3D cyl, int number_of_points) -> IMP::algebra::Vector3Ds
    get_uniform_surface_cover(SpherePatch3D sph, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
    get_uniform_surface_cover(Cone3D cone, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
    get_uniform_surface_cover(IMP::algebra::Sphere3Ds const & _in, double points_per_square_angstrom) -> IMP::algebra::Vector3Ds
    get_uniform_surface_cover(Sphere1D a, unsigned int const & b) -> IMP::algebra::Vector1Ds
    get_uniform_surface_cover(Sphere2D a, unsigned int const & b) -> IMP::algebra::Vector2Ds
    get_uniform_surface_cover(Sphere3D a, unsigned int const & b) -> IMP::algebra::Vector3Ds
    get_uniform_surface_cover(Sphere4D a, unsigned int const & b) -> IMP::algebra::Vector4Ds
    get_uniform_surface_cover(Sphere5D a, unsigned int const & b) -> IMP::algebra::Vector5Ds
    get_uniform_surface_cover(Sphere6D a, unsigned int const & b) -> IMP::algebra::Vector6Ds
    get_uniform_surface_cover(SphereKD a, unsigned int const & b) -> IMP::algebra::VectorKDs
    """
  return _IMP_algebra.get_uniform_surface_cover(*args)

def get_grid_interior_cover_by_spacing(*args):
  """
    get_grid_interior_cover_by_spacing(BoundingBox1D a, double const & b) -> IMP::algebra::Vector1Ds
    get_grid_interior_cover_by_spacing(BoundingBox2D a, double const & b) -> IMP::algebra::Vector2Ds
    get_grid_interior_cover_by_spacing(BoundingBox3D a, double const & b) -> IMP::algebra::Vector3Ds
    get_grid_interior_cover_by_spacing(BoundingBox4D a, double const & b) -> IMP::algebra::Vector4Ds
    get_grid_interior_cover_by_spacing(BoundingBox5D a, double const & b) -> IMP::algebra::Vector5Ds
    get_grid_interior_cover_by_spacing(BoundingBox6D a, double const & b) -> IMP::algebra::Vector6Ds
    get_grid_interior_cover_by_spacing(BoundingBoxKD a, double const & b) -> IMP::algebra::VectorKDs
    """
  return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
class _AxisAnglePair(object):
    """Proxy of C++ std::pair<(IMP::algebra::VectorD<(3)>,double)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self) -> _AxisAnglePair
        __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self, Vector3D first, double second) -> _AxisAnglePair
        __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self, _AxisAnglePair p) -> _AxisAnglePair
        """
        this = _IMP_algebra.new__AxisAnglePair(*args)
        try: self.this.append(this)
        except: self.this = this
    first = _swig_property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set)
    second = _swig_property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
    __del__ = lambda self : None;
_AxisAnglePair_swigregister = _IMP_algebra._AxisAnglePair_swigregister
_AxisAnglePair_swigregister(_AxisAnglePair)


def get_transformation_aligning_first_to_second(*args):
  """get_transformation_aligning_first_to_second(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & source, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & target) -> Transformation3D"""
  return _IMP_algebra.get_transformation_aligning_first_to_second(*args)

def get_rmsd_transforming_first(*args):
  """get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
  return _IMP_algebra.get_rmsd_transforming_first(*args)

def get_rmsd(*args):
  """get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
  return _IMP_algebra.get_rmsd(*args)

def get_weighted_rmsd_transforming_first(*args):
  """
    get_weighted_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, 
        IMP::Floats const & weights) -> double
    """
  return _IMP_algebra.get_weighted_rmsd_transforming_first(*args)

def get_weighted_rmsd(*args):
  """get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
  return _IMP_algebra.get_weighted_rmsd(*args)
LinearFit=LinearFit2D
ParabolicFit=ParabolicFit2D


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

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

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