algebra/__init__.py

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


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




import typing
import _IMP_algebra

import builtins as __builtin__

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


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


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


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


import weakref

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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_algebra.delete_IMP_ALGEBRA_SwigPyIterator

    def value(self):
        r"""value(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
        return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register IMP_ALGEBRA_SwigPyIterator in _IMP_algebra:
_IMP_algebra.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_KERNEL_HAS_LOG4CXX = _IMP_algebra.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_algebra.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_algebra.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_algebra.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_algebra.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_algebra.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_KERNEL_HAS_BOOST_SYSTEM

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_algebra.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_algebra.IMPKERNEL_SHOW_WARNINGS


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

class _ostream(object):
    r"""Proxy of C++ std::ostream class."""

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

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

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

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

import IMP
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_NUMPY = _IMP_algebra.IMP_CGAL_HAS_NUMPY

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_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_algebra.IMP_ALGEBRA_HAS_NUMPY

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(o):
    r"""_object_cast_to_VectorKDMetric(Object o) -> VectorKDMetric"""
    return _IMP_algebra._object_cast_to_VectorKDMetric(o)

_object_types.append("EuclideanVectorKDMetric")


def _object_cast_to_EuclideanVectorKDMetric(o):
    r"""_object_cast_to_EuclideanVectorKDMetric(Object o) -> EuclideanVectorKDMetric"""
    return _IMP_algebra._object_cast_to_EuclideanVectorKDMetric(o)

_object_types.append("MaxVectorKDMetric")


def _object_cast_to_MaxVectorKDMetric(o):
    r"""_object_cast_to_MaxVectorKDMetric(Object o) -> MaxVectorKDMetric"""
    return _IMP_algebra._object_cast_to_MaxVectorKDMetric(o)

_object_types.append("DynamicNearestNeighbor3D")


def _object_cast_to_DynamicNearestNeighbor3D(o):
    r"""_object_cast_to_DynamicNearestNeighbor3D(Object o) -> DynamicNearestNeighbor3D"""
    return _IMP_algebra._object_cast_to_DynamicNearestNeighbor3D(o)

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


Line3Ds=list
_plural_types.append("Line3Ds")
_value_types.append("Line3D")


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


UnitSimplex1Ds=list
_plural_types.append("UnitSimplex1Ds")
_value_types.append("UnitSimplex1D")


UnitSimplex2Ds=list
_plural_types.append("UnitSimplex2Ds")
_value_types.append("UnitSimplex2D")


UnitSimplex3Ds=list
_plural_types.append("UnitSimplex3Ds")
_value_types.append("UnitSimplex3D")


UnitSimplex4Ds=list
_plural_types.append("UnitSimplex4Ds")
_value_types.append("UnitSimplex4D")


UnitSimplex5Ds=list
_plural_types.append("UnitSimplex5Ds")
_value_types.append("UnitSimplex5D")


UnitSimplex6Ds=list
_plural_types.append("UnitSimplex6Ds")
_value_types.append("UnitSimplex6D")


UnitSimplex1Ds=list
_plural_types.append("UnitSimplex1Ds")
_value_types.append("UnitSimplexD<1>")


UnitSimplex2Ds=list
_plural_types.append("UnitSimplex2Ds")
_value_types.append("UnitSimplexD<2>")


UnitSimplex3Ds=list
_plural_types.append("UnitSimplex3Ds")
_value_types.append("UnitSimplexD<3>")


UnitSimplex4Ds=list
_plural_types.append("UnitSimplex4Ds")
_value_types.append("UnitSimplexD<4>")


UnitSimplex5Ds=list
_plural_types.append("UnitSimplex5Ds")
_value_types.append("UnitSimplexD<5>")


UnitSimplex6Ds=list
_plural_types.append("UnitSimplex6Ds")
_value_types.append("UnitSimplexD<6>")


UnitSimplexKDs=list
_plural_types.append("UnitSimplexKDs")
_value_types.append("UnitSimplexKD")


UnitSimplexKDs=list
_plural_types.append("UnitSimplexKDs")
_value_types.append("UnitSimplexD<-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(o):
    r"""_object_cast_to_NearestNeighbor1D(Object o) -> NearestNeighbor1D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor1D(o)

_object_types.append("NearestNeighbor2D")


def _object_cast_to_NearestNeighbor2D(o):
    r"""_object_cast_to_NearestNeighbor2D(Object o) -> NearestNeighbor2D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor2D(o)

_object_types.append("NearestNeighbor3D")


def _object_cast_to_NearestNeighbor3D(o):
    r"""_object_cast_to_NearestNeighbor3D(Object o) -> NearestNeighbor3D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor3D(o)

_object_types.append("NearestNeighbor4D")


def _object_cast_to_NearestNeighbor4D(o):
    r"""_object_cast_to_NearestNeighbor4D(Object o) -> NearestNeighbor4D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor4D(o)

_object_types.append("NearestNeighbor5D")


def _object_cast_to_NearestNeighbor5D(o):
    r"""_object_cast_to_NearestNeighbor5D(Object o) -> NearestNeighbor5D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor5D(o)

_object_types.append("NearestNeighbor6D")


def _object_cast_to_NearestNeighbor6D(o):
    r"""_object_cast_to_NearestNeighbor6D(Object o) -> NearestNeighbor6D"""
    return _IMP_algebra._object_cast_to_NearestNeighbor6D(o)

_object_types.append("NearestNeighborKD")


def _object_cast_to_NearestNeighborKD(o):
    r"""_object_cast_to_NearestNeighborKD(Object o) -> NearestNeighborKD"""
    return _IMP_algebra._object_cast_to_NearestNeighborKD(o)

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 Rotation3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Rotation3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Rotation3D self, Rotation3D rot) -> Rotation3D
        __init__(Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
        __init__(Rotation3D self) -> Rotation3D
        __init__(Rotation3D self, double a, double b, double c, double d) -> Rotation3D
        """
        _IMP_algebra.Rotation3D_swiginit(self, _IMP_algebra.new_Rotation3D(*args))
    __swig_destroy__ = _IMP_algebra.delete_Rotation3D

    def get_rotated_no_cache(self, o):
        r"""get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, o)

    def get_rotated_one_coordinate_no_cache(self, o, coord):
        r"""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, o, coord)

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

    def get_rotated_adjoint(self, v, Dw):
        r"""get_rotated_adjoint(Rotation3D self, Vector3D v, Vector3D Dw) -> _RotatedVector3DAdjoint"""
        return _IMP_algebra.Rotation3D_get_rotated_adjoint(self, v, Dw)

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

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

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

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

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

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

    def __truediv__(self, *args):
        return _IMP_algebra.Rotation3D___truediv__(self, *args)



    def get_gradient_of_rotated(self, v, i, wrt_unnorm=False):
        r"""get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=False) -> Vector3D"""
        return _IMP_algebra.Rotation3D_get_gradient_of_rotated(self, v, i, wrt_unnorm)

    def get_jacobian_of_rotated(self, v, wrt_unnorm=False):
        r"""get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
        return _IMP_algebra.Rotation3D_get_jacobian_of_rotated(self, v, wrt_unnorm)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Rotation3D self) -> PyObject *"""
        return _IMP_algebra.Rotation3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Rotation3D self, PyObject * p)"""
        return _IMP_algebra.Rotation3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register Rotation3D in _IMP_algebra:
_IMP_algebra.Rotation3D_swigregister(Rotation3D)

def get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm=False):
    r"""get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
    return _IMP_algebra.get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm)

def get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm=False):
    r"""get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
    return _IMP_algebra.get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm)

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

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

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

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

def get_rotation_from_matrix(*args):
    r"""
    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(Eigen::Matrix3d m) -> Rotation3D
    """
    return _IMP_algebra.get_rotation_from_matrix(*args)

def get_random_rotation_3d(*args):
    r"""
    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(num_points):
    r"""get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
    return _IMP_algebra.get_uniform_cover_rotations_3d(num_points)

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

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

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

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

def get_rotation_from_fixed_zyz(Rot, Tilt, Psi):
    r"""get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
    return _IMP_algebra.get_rotation_from_fixed_zyz(Rot, Tilt, Psi)
class FixedXYZ(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::FixedXYZ class."""

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

    def __init__(self, *args):
        r"""
        __init__(FixedXYZ self) -> FixedXYZ
        __init__(FixedXYZ self, double x, double y, double z) -> FixedXYZ
        """
        _IMP_algebra.FixedXYZ_swiginit(self, _IMP_algebra.new_FixedXYZ(*args))

    def get_x(self):
        r"""get_x(FixedXYZ self) -> double"""
        return _IMP_algebra.FixedXYZ_get_x(self)

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(FixedXYZ self) -> PyObject *"""
        return _IMP_algebra.FixedXYZ__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FixedXYZ self, PyObject * p)"""
        return _IMP_algebra.FixedXYZ__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_FixedXYZ

# Register FixedXYZ in _IMP_algebra:
_IMP_algebra.FixedXYZ_swigregister(FixedXYZ)

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

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

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

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

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

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

def get_edges(arg1):
    r"""get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
    return _IMP_algebra.get_edges(arg1)
class Transformation3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Transformation3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Transformation3D self, Transformation3D arg2) -> Transformation3D
        __init__(Transformation3D self) -> Transformation3D
        __init__(Transformation3D self, Rotation3D r, Vector3D t=IMP::Vector3D(0, 0, 0)) -> Transformation3D
        __init__(Transformation3D self, Vector3D t) -> Transformation3D
        """
        _IMP_algebra.Transformation3D_swiginit(self, _IMP_algebra.new_Transformation3D(*args))
    __swig_destroy__ = _IMP_algebra.delete_Transformation3D

    def get_transformed(self, o):
        r"""get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
        return _IMP_algebra.Transformation3D_get_transformed(self, o)

    def get_transformed_adjoint(self, v, Dw):
        r"""get_transformed_adjoint(Transformation3D self, Vector3D v, Vector3D Dw) -> _TransformedVector3DAdjoint"""
        return _IMP_algebra.Transformation3D_get_transformed_adjoint(self, v, Dw)

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

    def __truediv__(self, *args):
        return _IMP_algebra.Transformation3D___truediv__(self, *args)



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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Transformation3D self) -> PyObject *"""
        return _IMP_algebra.Transformation3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Transformation3D self, PyObject * p)"""
        return _IMP_algebra.Transformation3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register Transformation3D in _IMP_algebra:
_IMP_algebra.Transformation3D_swigregister(Transformation3D)

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

def compose_adjoint(*args):
    r"""
    compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
    compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
    """
    return _IMP_algebra.compose_adjoint(*args)

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

def get_random_local_transformation(origin, max_translation=5., max_angle_in_rad=0.26):
    r"""get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D"""
    return _IMP_algebra.get_random_local_transformation(origin, max_translation, max_angle_in_rad)
class Rotation2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::Rotation2D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Rotation2D self) -> Rotation2D
        __init__(Rotation2D self, double angle) -> Rotation2D
        """
        _IMP_algebra.Rotation2D_swiginit(self, _IMP_algebra.new_Rotation2D(*args))

    def get_rotated(self, *args):
        r"""
        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):
        r"""get_inverse(Rotation2D self) -> Rotation2D"""
        return _IMP_algebra.Rotation2D_get_inverse(self)

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Rotation2D self) -> PyObject *"""
        return _IMP_algebra.Rotation2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Rotation2D self, PyObject * p)"""
        return _IMP_algebra.Rotation2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Rotation2D

# Register Rotation2D in _IMP_algebra:
_IMP_algebra.Rotation2D_swigregister(Rotation2D)

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

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

def get_rotation_to_x_axis(v):
    r"""get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
    return _IMP_algebra.get_rotation_to_x_axis(v)
class Transformation2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::Transformation2D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Transformation2D self, Transformation2D arg2) -> Transformation2D
        __init__(Transformation2D self) -> Transformation2D
        __init__(Transformation2D self, Rotation2D r, Vector2D t=IMP::Vector2D(0.0, 0.0)) -> Transformation2D
        __init__(Transformation2D self, Vector2D t) -> Transformation2D
        """
        _IMP_algebra.Transformation2D_swiginit(self, _IMP_algebra.new_Transformation2D(*args))
    __swig_destroy__ = _IMP_algebra.delete_Transformation2D

    def get_transformed(self, o):
        r"""get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
        return _IMP_algebra.Transformation2D_get_transformed(self, o)

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

    def __truediv__(self, *args):
        return _IMP_algebra.Transformation2D___truediv__(self, *args)



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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Transformation2D self) -> PyObject *"""
        return _IMP_algebra.Transformation2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Transformation2D self, PyObject * p)"""
        return _IMP_algebra.Transformation2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register Transformation2D in _IMP_algebra:
_IMP_algebra.Transformation2D_swigregister(Transformation2D)

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

def get_rotation_about_point(*args):
    r"""
    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):
    r"""
    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(d):
    r"""get_unit_sphere_kd(unsigned int d) -> SphereKD"""
    return _IMP_algebra.get_unit_sphere_kd(d)

def get_enclosing_sphere(*args):
    r"""
    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(volume):
    r"""get_ball_radius_from_volume_3d(double volume) -> double"""
    return _IMP_algebra.get_ball_radius_from_volume_3d(volume)

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

def get_simplified_from_volume(_in, maximum_allowed_error_angstroms):
    r"""get_simplified_from_volume(IMP::algebra::Sphere3Ds _in, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
    return _IMP_algebra.get_simplified_from_volume(_in, maximum_allowed_error_angstroms)

def get_triangle_3d(s):
    r"""get_triangle_3d(UnitSimplex3D s) -> Triangle3D"""
    return _IMP_algebra.get_triangle_3d(s)
class _UnitSimplexBaseKD(IMP._GeometricPrimitiveKD):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< -1 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBaseKD self) -> int"""
        return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
        return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBaseKD self, VectorKD p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBaseKD_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBaseKD

# Register _UnitSimplexBaseKD in _IMP_algebra:
_IMP_algebra._UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
class _UnitSimplexBase1D(IMP._GeometricPrimitive1D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 1 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase1D self) -> int"""
        return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
        return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase1D self, Vector1D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase1D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase1D

# Register _UnitSimplexBase1D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
class _UnitSimplexBase2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 2 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase2D self) -> int"""
        return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
        return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase2D self, Vector2D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase2D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase2D

# Register _UnitSimplexBase2D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
class _UnitSimplexBase3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 3 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase3D self) -> int"""
        return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
        return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase3D self, Vector3D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase3D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase3D

# Register _UnitSimplexBase3D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
class _UnitSimplexBase4D(IMP._GeometricPrimitive4D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 4 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase4D self) -> int"""
        return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
        return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase4D self, Vector4D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase4D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase4D

# Register _UnitSimplexBase4D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
class _UnitSimplexBase5D(IMP._GeometricPrimitive5D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 5 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase5D self) -> int"""
        return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
        return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase5D self, Vector5D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase5D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase5D

# Register _UnitSimplexBase5D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
class _UnitSimplexBase6D(IMP._GeometricPrimitive6D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 6 > class."""

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

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

    def get_dimension(self):
        r"""get_dimension(_UnitSimplexBase6D self) -> int"""
        return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)

    def get_barycenter(self):
        r"""get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
        return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)

    def get_contains(self, *args):
        r"""get_contains(_UnitSimplexBase6D self, Vector6D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
        return _IMP_algebra._UnitSimplexBase6D_get_contains(self, *args)
    __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase6D

# Register _UnitSimplexBase6D in _IMP_algebra:
_IMP_algebra._UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
class BoundingBox1D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 1 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox1D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox1D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox1D self) -> Vector1D"""
        return _IMP_algebra.BoundingBox1D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox1D self) -> Vector1D"""
        return _IMP_algebra.BoundingBox1D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox1D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox1D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox1D self, unsigned int d) -> BoundingBox1D
        __init__(BoundingBox1D self, Vector1D lb, Vector1D ub) -> BoundingBox1D
        __init__(BoundingBox1D self, Vector1D v) -> BoundingBox1D
        __init__(BoundingBox1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
        __init__(BoundingBox1D self) -> BoundingBox1D
        """
        _IMP_algebra.BoundingBox1D_swiginit(self, _IMP_algebra.new_BoundingBox1D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
        return _IMP_algebra.BoundingBox1D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox1D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox1D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D

# Register BoundingBox1D in _IMP_algebra:
_IMP_algebra.BoundingBox1D_swigregister(BoundingBox1D)
class BoundingBox2D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 2 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox2D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox2D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox2D self) -> Vector2D"""
        return _IMP_algebra.BoundingBox2D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox2D self) -> Vector2D"""
        return _IMP_algebra.BoundingBox2D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox2D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox2D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox2D self, unsigned int d) -> BoundingBox2D
        __init__(BoundingBox2D self, Vector2D lb, Vector2D ub) -> BoundingBox2D
        __init__(BoundingBox2D self, Vector2D v) -> BoundingBox2D
        __init__(BoundingBox2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
        __init__(BoundingBox2D self) -> BoundingBox2D
        """
        _IMP_algebra.BoundingBox2D_swiginit(self, _IMP_algebra.new_BoundingBox2D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
        return _IMP_algebra.BoundingBox2D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox2D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox2D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D

# Register BoundingBox2D in _IMP_algebra:
_IMP_algebra.BoundingBox2D_swigregister(BoundingBox2D)
class BoundingBox3D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 3 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox3D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox3D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox3D self) -> Vector3D"""
        return _IMP_algebra.BoundingBox3D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox3D self) -> Vector3D"""
        return _IMP_algebra.BoundingBox3D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox3D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox3D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox3D self, unsigned int d) -> BoundingBox3D
        __init__(BoundingBox3D self, Vector3D lb, Vector3D ub) -> BoundingBox3D
        __init__(BoundingBox3D self, Vector3D v) -> BoundingBox3D
        __init__(BoundingBox3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
        __init__(BoundingBox3D self) -> BoundingBox3D
        """
        _IMP_algebra.BoundingBox3D_swiginit(self, _IMP_algebra.new_BoundingBox3D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
        return _IMP_algebra.BoundingBox3D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox3D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox3D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D

# Register BoundingBox3D in _IMP_algebra:
_IMP_algebra.BoundingBox3D_swigregister(BoundingBox3D)
class BoundingBox4D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 4 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox4D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox4D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox4D self) -> Vector4D"""
        return _IMP_algebra.BoundingBox4D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox4D self) -> Vector4D"""
        return _IMP_algebra.BoundingBox4D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox4D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox4D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox4D self, unsigned int d) -> BoundingBox4D
        __init__(BoundingBox4D self, Vector4D lb, Vector4D ub) -> BoundingBox4D
        __init__(BoundingBox4D self, Vector4D v) -> BoundingBox4D
        __init__(BoundingBox4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
        __init__(BoundingBox4D self) -> BoundingBox4D
        """
        _IMP_algebra.BoundingBox4D_swiginit(self, _IMP_algebra.new_BoundingBox4D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
        return _IMP_algebra.BoundingBox4D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox4D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox4D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D

# Register BoundingBox4D in _IMP_algebra:
_IMP_algebra.BoundingBox4D_swigregister(BoundingBox4D)
class BoundingBox5D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 5 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox5D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox5D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox5D self) -> Vector5D"""
        return _IMP_algebra.BoundingBox5D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox5D self) -> Vector5D"""
        return _IMP_algebra.BoundingBox5D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox5D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox5D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox5D self, unsigned int d) -> BoundingBox5D
        __init__(BoundingBox5D self, Vector5D lb, Vector5D ub) -> BoundingBox5D
        __init__(BoundingBox5D self, Vector5D v) -> BoundingBox5D
        __init__(BoundingBox5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
        __init__(BoundingBox5D self) -> BoundingBox5D
        """
        _IMP_algebra.BoundingBox5D_swiginit(self, _IMP_algebra.new_BoundingBox5D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
        return _IMP_algebra.BoundingBox5D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox5D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox5D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D

# Register BoundingBox5D in _IMP_algebra:
_IMP_algebra.BoundingBox5D_swigregister(BoundingBox5D)
class BoundingBox6D(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< 6 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBox6D self) -> unsigned int"""
        return _IMP_algebra.BoundingBox6D_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBox6D self) -> Vector6D"""
        return _IMP_algebra.BoundingBox6D_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBox6D self) -> Vector6D"""
        return _IMP_algebra.BoundingBox6D_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBox6D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBox6D_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBox6D self, unsigned int d) -> BoundingBox6D
        __init__(BoundingBox6D self, Vector6D lb, Vector6D ub) -> BoundingBox6D
        __init__(BoundingBox6D self, Vector6D v) -> BoundingBox6D
        __init__(BoundingBox6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
        __init__(BoundingBox6D self) -> BoundingBox6D
        """
        _IMP_algebra.BoundingBox6D_swiginit(self, _IMP_algebra.new_BoundingBox6D(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
        return _IMP_algebra.BoundingBox6D___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBox6D self) -> PyObject *"""
        return _IMP_algebra.BoundingBox6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBox6D self, PyObject * p)"""
        return _IMP_algebra.BoundingBox6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D

# Register BoundingBox6D in _IMP_algebra:
_IMP_algebra.BoundingBox6D_swigregister(BoundingBox6D)
class BoundingBoxKD(object):
    r"""Proxy of C++ IMP::algebra::BoundingBoxD< -1 > class."""

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

    def get_dimension(self):
        r"""get_dimension(BoundingBoxKD self) -> unsigned int"""
        return _IMP_algebra.BoundingBoxKD_get_dimension(self)

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

    def get_corner_0(self):
        r"""get_corner_0(BoundingBoxKD self) -> VectorKD"""
        return _IMP_algebra.BoundingBoxKD_get_corner_0(self)

    def get_corner_1(self):
        r"""get_corner_1(BoundingBoxKD self) -> VectorKD"""
        return _IMP_algebra.BoundingBoxKD_get_corner_1(self)

    def get_contains(self, *args):
        r"""
        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):
        r"""show(BoundingBoxKD self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundingBoxKD_show(self, *args)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(BoundingBoxKD self, unsigned int d) -> BoundingBoxKD
        __init__(BoundingBoxKD self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
        __init__(BoundingBoxKD self, VectorKD v) -> BoundingBoxKD
        __init__(BoundingBoxKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
        __init__(BoundingBoxKD self) -> BoundingBoxKD
        """
        _IMP_algebra.BoundingBoxKD_swiginit(self, _IMP_algebra.new_BoundingBoxKD(*args))

    def __getitem__(self, index):
        r"""__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
        return _IMP_algebra.BoundingBoxKD___getitem__(self, index)

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



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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BoundingBoxKD self) -> PyObject *"""
        return _IMP_algebra.BoundingBoxKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundingBoxKD self, PyObject * p)"""
        return _IMP_algebra.BoundingBoxKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD

# Register BoundingBoxKD in _IMP_algebra:
_IMP_algebra.BoundingBoxKD_swigregister(BoundingBoxKD)
class Sphere1D(IMP._GeometricPrimitive1D):
    r"""Proxy of C++ IMP::algebra::SphereD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere1D self) -> Sphere1D
        __init__(Sphere1D self, Vector1D center, double radius) -> Sphere1D
        """
        _IMP_algebra.Sphere1D_swiginit(self, _IMP_algebra.new_Sphere1D(*args))

    def get_radius(self):
        r"""get_radius(Sphere1D self) -> double"""
        return _IMP_algebra.Sphere1D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere1D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere1D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere1D self) -> PyObject *"""
        return _IMP_algebra.Sphere1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere1D self, PyObject * p)"""
        return _IMP_algebra.Sphere1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere1D

# Register Sphere1D in _IMP_algebra:
_IMP_algebra.Sphere1D_swigregister(Sphere1D)
class Sphere2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::SphereD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere2D self) -> Sphere2D
        __init__(Sphere2D self, Vector2D center, double radius) -> Sphere2D
        """
        _IMP_algebra.Sphere2D_swiginit(self, _IMP_algebra.new_Sphere2D(*args))

    def get_radius(self):
        r"""get_radius(Sphere2D self) -> double"""
        return _IMP_algebra.Sphere2D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere2D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere2D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere2D self) -> PyObject *"""
        return _IMP_algebra.Sphere2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere2D self, PyObject * p)"""
        return _IMP_algebra.Sphere2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere2D

# Register Sphere2D in _IMP_algebra:
_IMP_algebra.Sphere2D_swigregister(Sphere2D)
class Sphere3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::SphereD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere3D self) -> Sphere3D
        __init__(Sphere3D self, Vector3D center, double radius) -> Sphere3D
        """
        _IMP_algebra.Sphere3D_swiginit(self, _IMP_algebra.new_Sphere3D(*args))

    def get_radius(self):
        r"""get_radius(Sphere3D self) -> double"""
        return _IMP_algebra.Sphere3D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere3D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere3D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere3D self) -> PyObject *"""
        return _IMP_algebra.Sphere3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere3D self, PyObject * p)"""
        return _IMP_algebra.Sphere3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere3D

# Register Sphere3D in _IMP_algebra:
_IMP_algebra.Sphere3D_swigregister(Sphere3D)
class Sphere4D(IMP._GeometricPrimitive4D):
    r"""Proxy of C++ IMP::algebra::SphereD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere4D self) -> Sphere4D
        __init__(Sphere4D self, Vector4D center, double radius) -> Sphere4D
        """
        _IMP_algebra.Sphere4D_swiginit(self, _IMP_algebra.new_Sphere4D(*args))

    def get_radius(self):
        r"""get_radius(Sphere4D self) -> double"""
        return _IMP_algebra.Sphere4D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere4D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere4D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere4D self) -> PyObject *"""
        return _IMP_algebra.Sphere4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere4D self, PyObject * p)"""
        return _IMP_algebra.Sphere4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere4D

# Register Sphere4D in _IMP_algebra:
_IMP_algebra.Sphere4D_swigregister(Sphere4D)
class Sphere5D(IMP._GeometricPrimitive5D):
    r"""Proxy of C++ IMP::algebra::SphereD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere5D self) -> Sphere5D
        __init__(Sphere5D self, Vector5D center, double radius) -> Sphere5D
        """
        _IMP_algebra.Sphere5D_swiginit(self, _IMP_algebra.new_Sphere5D(*args))

    def get_radius(self):
        r"""get_radius(Sphere5D self) -> double"""
        return _IMP_algebra.Sphere5D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere5D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere5D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere5D self) -> PyObject *"""
        return _IMP_algebra.Sphere5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere5D self, PyObject * p)"""
        return _IMP_algebra.Sphere5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere5D

# Register Sphere5D in _IMP_algebra:
_IMP_algebra.Sphere5D_swigregister(Sphere5D)
class Sphere6D(IMP._GeometricPrimitive6D):
    r"""Proxy of C++ IMP::algebra::SphereD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(Sphere6D self) -> Sphere6D
        __init__(Sphere6D self, Vector6D center, double radius) -> Sphere6D
        """
        _IMP_algebra.Sphere6D_swiginit(self, _IMP_algebra.new_Sphere6D(*args))

    def get_radius(self):
        r"""get_radius(Sphere6D self) -> double"""
        return _IMP_algebra.Sphere6D_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(Sphere6D self, _ostream out=std::cout)"""
        return _IMP_algebra.Sphere6D_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Sphere6D self) -> PyObject *"""
        return _IMP_algebra.Sphere6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Sphere6D self, PyObject * p)"""
        return _IMP_algebra.Sphere6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Sphere6D

# Register Sphere6D in _IMP_algebra:
_IMP_algebra.Sphere6D_swigregister(Sphere6D)
class SphereKD(IMP._GeometricPrimitiveKD):
    r"""Proxy of C++ IMP::algebra::SphereD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SphereKD self) -> SphereKD
        __init__(SphereKD self, VectorKD center, double radius) -> SphereKD
        """
        _IMP_algebra.SphereKD_swiginit(self, _IMP_algebra.new_SphereKD(*args))

    def get_radius(self):
        r"""get_radius(SphereKD self) -> double"""
        return _IMP_algebra.SphereKD_get_radius(self)

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

    def get_contains(self, *args):
        r"""
        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):
        r"""show(SphereKD self, _ostream out=std::cout)"""
        return _IMP_algebra.SphereKD_show(self, *args)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(SphereKD self) -> PyObject *"""
        return _IMP_algebra.SphereKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SphereKD self, PyObject * p)"""
        return _IMP_algebra.SphereKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_SphereKD

# Register SphereKD in _IMP_algebra:
_IMP_algebra.SphereKD_swigregister(SphereKD)
class UnitSimplex1D(_UnitSimplexBase1D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 1 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex1D self) -> UnitSimplex1D"""
        _IMP_algebra.UnitSimplex1D_swiginit(self, _IMP_algebra.new_UnitSimplex1D())

    def show(self, *args):
        r"""show(UnitSimplex1D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex1D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex1D self) -> std::string"""
        return _IMP_algebra.UnitSimplex1D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex1D self) -> std::string"""
        return _IMP_algebra.UnitSimplex1D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex1D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex1D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D

# Register UnitSimplex1D in _IMP_algebra:
_IMP_algebra.UnitSimplex1D_swigregister(UnitSimplex1D)
class UnitSimplex2D(_UnitSimplexBase2D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 2 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex2D self) -> UnitSimplex2D"""
        _IMP_algebra.UnitSimplex2D_swiginit(self, _IMP_algebra.new_UnitSimplex2D())

    def show(self, *args):
        r"""show(UnitSimplex2D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex2D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex2D self) -> std::string"""
        return _IMP_algebra.UnitSimplex2D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex2D self) -> std::string"""
        return _IMP_algebra.UnitSimplex2D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex2D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex2D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D

# Register UnitSimplex2D in _IMP_algebra:
_IMP_algebra.UnitSimplex2D_swigregister(UnitSimplex2D)
class UnitSimplex3D(_UnitSimplexBase3D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 3 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex3D self) -> UnitSimplex3D"""
        _IMP_algebra.UnitSimplex3D_swiginit(self, _IMP_algebra.new_UnitSimplex3D())

    def show(self, *args):
        r"""show(UnitSimplex3D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex3D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex3D self) -> std::string"""
        return _IMP_algebra.UnitSimplex3D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex3D self) -> std::string"""
        return _IMP_algebra.UnitSimplex3D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex3D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex3D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D

# Register UnitSimplex3D in _IMP_algebra:
_IMP_algebra.UnitSimplex3D_swigregister(UnitSimplex3D)
class UnitSimplex4D(_UnitSimplexBase4D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 4 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex4D self) -> UnitSimplex4D"""
        _IMP_algebra.UnitSimplex4D_swiginit(self, _IMP_algebra.new_UnitSimplex4D())

    def show(self, *args):
        r"""show(UnitSimplex4D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex4D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex4D self) -> std::string"""
        return _IMP_algebra.UnitSimplex4D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex4D self) -> std::string"""
        return _IMP_algebra.UnitSimplex4D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex4D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex4D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D

# Register UnitSimplex4D in _IMP_algebra:
_IMP_algebra.UnitSimplex4D_swigregister(UnitSimplex4D)
class UnitSimplex5D(_UnitSimplexBase5D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 5 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex5D self) -> UnitSimplex5D"""
        _IMP_algebra.UnitSimplex5D_swiginit(self, _IMP_algebra.new_UnitSimplex5D())

    def show(self, *args):
        r"""show(UnitSimplex5D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex5D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex5D self) -> std::string"""
        return _IMP_algebra.UnitSimplex5D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex5D self) -> std::string"""
        return _IMP_algebra.UnitSimplex5D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex5D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex5D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D

# Register UnitSimplex5D in _IMP_algebra:
_IMP_algebra.UnitSimplex5D_swigregister(UnitSimplex5D)
class UnitSimplex6D(_UnitSimplexBase6D):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< 6 > class."""

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

    def __init__(self):
        r"""__init__(UnitSimplex6D self) -> UnitSimplex6D"""
        _IMP_algebra.UnitSimplex6D_swiginit(self, _IMP_algebra.new_UnitSimplex6D())

    def show(self, *args):
        r"""show(UnitSimplex6D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplex6D_show(self, *args)

    def __str__(self):
        r"""__str__(UnitSimplex6D self) -> std::string"""
        return _IMP_algebra.UnitSimplex6D___str__(self)

    def __repr__(self):
        r"""__repr__(UnitSimplex6D self) -> std::string"""
        return _IMP_algebra.UnitSimplex6D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
        return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplex6D self) -> PyObject *"""
        return _IMP_algebra.UnitSimplex6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplex6D self, PyObject * p)"""
        return _IMP_algebra.UnitSimplex6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D

# Register UnitSimplex6D in _IMP_algebra:
_IMP_algebra.UnitSimplex6D_swigregister(UnitSimplex6D)
class UnitSimplexKD(_UnitSimplexBaseKD):
    r"""Proxy of C++ IMP::algebra::UnitSimplexD< -1 > class."""

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

    def __init__(self, d=1):
        r"""__init__(UnitSimplexKD self, int d=1) -> UnitSimplexKD"""
        _IMP_algebra.UnitSimplexKD_swiginit(self, _IMP_algebra.new_UnitSimplexKD(d))

    def show(self, *args):
        r"""show(UnitSimplexKD self, _ostream out=std::cout)"""
        return _IMP_algebra.UnitSimplexKD_show(self, *args)

    def _get_as_binary(self):
        r"""_get_as_binary(UnitSimplexKD self) -> PyObject *"""
        return _IMP_algebra.UnitSimplexKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnitSimplexKD self, PyObject * p)"""
        return _IMP_algebra.UnitSimplexKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD

# Register UnitSimplexKD in _IMP_algebra:
_IMP_algebra.UnitSimplexKD_swigregister(UnitSimplexKD)
class ReferenceFrame3D(object):
    r"""Proxy of C++ IMP::algebra::ReferenceFrame3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(ReferenceFrame3D self, ReferenceFrame3D arg2) -> ReferenceFrame3D
        __init__(ReferenceFrame3D self) -> ReferenceFrame3D
        __init__(ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
        """
        _IMP_algebra.ReferenceFrame3D_swiginit(self, _IMP_algebra.new_ReferenceFrame3D(*args))
    __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D

    def get_transformation_to(self):
        r"""get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
        return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
        return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ReferenceFrame3D self, PyObject * p)"""
        return _IMP_algebra.ReferenceFrame3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ReferenceFrame3D in _IMP_algebra:
_IMP_algebra.ReferenceFrame3D_swigregister(ReferenceFrame3D)

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

def get_transformation_from_first_to_second(a, b):
    r"""get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
    return _IMP_algebra.get_transformation_from_first_to_second(a, b)
class SphericalVector3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::SphericalVector3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(SphericalVector3D self) -> SphericalVector3D
        __init__(SphericalVector3D self, Vector3D v) -> SphericalVector3D
        __init__(SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
        """
        _IMP_algebra.SphericalVector3D_swiginit(self, _IMP_algebra.new_SphericalVector3D(*args))

    def get_cartesian_coordinates(self):
        r"""get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
        return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(SphericalVector3D self) -> PyObject *"""
        return _IMP_algebra.SphericalVector3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SphericalVector3D self, PyObject * p)"""
        return _IMP_algebra.SphericalVector3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


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

    def __setitem__(self, index, val):
        r"""__setitem__(SphericalVector3D self, unsigned int index, double val)"""
        return _IMP_algebra.SphericalVector3D___setitem__(self, index, val)
    __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D

# Register SphericalVector3D in _IMP_algebra:
_IMP_algebra.SphericalVector3D_swigregister(SphericalVector3D)

def get_alignments_from_first_to_second(pca1, pca2):
    r"""get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
    return _IMP_algebra.get_alignments_from_first_to_second(pca1, pca2)
class Line3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Line3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Line3D self) -> Line3D
        __init__(Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
        __init__(Line3D self, Segment3D s) -> Line3D
        """
        _IMP_algebra.Line3D_swiginit(self, _IMP_algebra.new_Line3D(*args))

    def get_direction(self):
        r"""get_direction(Line3D self) -> Vector3D"""
        return _IMP_algebra.Line3D_get_direction(self)

    def get_point_on_line(self):
        r"""get_point_on_line(Line3D self) -> Vector3D"""
        return _IMP_algebra.Line3D_get_point_on_line(self)

    def get_moment(self, *args):
        r"""
        get_moment(Line3D self) -> Vector3D
        get_moment(Line3D self, Vector3D v) -> Vector3D
        """
        return _IMP_algebra.Line3D_get_moment(self, *args)

    def get_reciprocal_product(self, l):
        r"""get_reciprocal_product(Line3D self, Line3D l) -> double"""
        return _IMP_algebra.Line3D_get_reciprocal_product(self, l)

    def get_opposite(self):
        r"""get_opposite(Line3D self) -> Line3D"""
        return _IMP_algebra.Line3D_get_opposite(self)

    def get_segment_starting_at(self, v, d):
        r"""get_segment_starting_at(Line3D self, Vector3D v, double d) -> Segment3D"""
        return _IMP_algebra.Line3D_get_segment_starting_at(self, v, d)

    def show(self, *args):
        r"""show(Line3D self, _ostream out=std::cout)"""
        return _IMP_algebra.Line3D_show(self, *args)

    def __str__(self):
        r"""__str__(Line3D self) -> std::string"""
        return _IMP_algebra.Line3D___str__(self)

    def __repr__(self):
        r"""__repr__(Line3D self) -> std::string"""
        return _IMP_algebra.Line3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Line3D self) -> PyObject *"""
        return _IMP_algebra.Line3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Line3D self, PyObject * p)"""
        return _IMP_algebra.Line3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Line3D

# Register Line3D in _IMP_algebra:
_IMP_algebra.Line3D_swigregister(Line3D)

def get_line_3d_geometry(g):
    r"""get_line_3d_geometry(Line3D g) -> Line3D"""
    return _IMP_algebra.get_line_3d_geometry(g)

def get_angle(a, b):
    r"""get_angle(Line3D a, Line3D b) -> double"""
    return _IMP_algebra.get_angle(a, b)

def get_segment_connecting_first_to_second(a, b):
    r"""get_segment_connecting_first_to_second(Line3D a, Line3D b) -> Segment3D"""
    return _IMP_algebra.get_segment_connecting_first_to_second(a, b)
class Segment3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Segment3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Segment3D self) -> Segment3D
        __init__(Segment3D self, Vector3D start, Vector3D end) -> Segment3D
        """
        _IMP_algebra.Segment3D_swiginit(self, _IMP_algebra.new_Segment3D(*args))

    def get_point(self, i):
        if i < 0 or i >= 2:
            raise IMP.UsageException("Invalid point index")
        return _IMP_algebra.Segment3D_get_point(self, i)



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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Segment3D self) -> PyObject *"""
        return _IMP_algebra.Segment3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Segment3D self, PyObject * p)"""
        return _IMP_algebra.Segment3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Segment3D

# Register Segment3D in _IMP_algebra:
_IMP_algebra.Segment3D_swigregister(Segment3D)

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

def get_relative_projection_on_segment(s, p):
    r"""get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
    return _IMP_algebra.get_relative_projection_on_segment(s, p)
class Triangle3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Triangle3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Triangle3D self) -> Triangle3D
        __init__(Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
        """
        _IMP_algebra.Triangle3D_swiginit(self, _IMP_algebra.new_Triangle3D(*args))

    def get_point(self, i):
        r"""get_point(Triangle3D self, unsigned int i) -> Vector3D"""
        return _IMP_algebra.Triangle3D_get_point(self, i)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Triangle3D self) -> PyObject *"""
        return _IMP_algebra.Triangle3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Triangle3D self, PyObject * p)"""
        return _IMP_algebra.Triangle3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Triangle3D

# Register Triangle3D in _IMP_algebra:
_IMP_algebra.Triangle3D_swigregister(Triangle3D)

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

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

def get_are_colinear(p1, p2, p3):
    r"""get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
    return _IMP_algebra.get_are_colinear(p1, p2, p3)
class LinearFit2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::LinearFit2D class."""

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

    def __init__(self, *args):
        r"""
        __init__(LinearFit2D self) -> LinearFit2D
        __init__(LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
        """
        _IMP_algebra.LinearFit2D_swiginit(self, _IMP_algebra.new_LinearFit2D(*args))

    def get_fit_error(self):
        r"""get_fit_error(LinearFit2D self) -> double"""
        return _IMP_algebra.LinearFit2D_get_fit_error(self)

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(LinearFit2D self) -> PyObject *"""
        return _IMP_algebra.LinearFit2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LinearFit2D self, PyObject * p)"""
        return _IMP_algebra.LinearFit2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LinearFit2D

# Register LinearFit2D in _IMP_algebra:
_IMP_algebra.LinearFit2D_swigregister(LinearFit2D)
class ParabolicFit2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::ParabolicFit2D class."""

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

    def __init__(self, *args):
        r"""
        __init__(ParabolicFit2D self) -> ParabolicFit2D
        __init__(ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
        """
        _IMP_algebra.ParabolicFit2D_swiginit(self, _IMP_algebra.new_ParabolicFit2D(*args))

    def get_fit_error(self):
        r"""get_fit_error(ParabolicFit2D self) -> double"""
        return _IMP_algebra.ParabolicFit2D_get_fit_error(self)

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(ParabolicFit2D self) -> PyObject *"""
        return _IMP_algebra.ParabolicFit2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ParabolicFit2D self, PyObject * p)"""
        return _IMP_algebra.ParabolicFit2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D

# Register ParabolicFit2D in _IMP_algebra:
_IMP_algebra.ParabolicFit2D_swigregister(ParabolicFit2D)
class Plane3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Plane3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Plane3D self) -> Plane3D
        __init__(Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
        __init__(Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
        """
        _IMP_algebra.Plane3D_swiginit(self, _IMP_algebra.new_Plane3D(*args))

    def get_point_on_plane(self):
        r"""get_point_on_plane(Plane3D self) -> Vector3D"""
        return _IMP_algebra.Plane3D_get_point_on_plane(self)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Plane3D self) -> PyObject *"""
        return _IMP_algebra.Plane3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Plane3D self, PyObject * p)"""
        return _IMP_algebra.Plane3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Plane3D

# Register Plane3D in _IMP_algebra:
_IMP_algebra.Plane3D_swigregister(Plane3D)

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

def get_plane_3d_geometry(g):
    r"""get_plane_3d_geometry(Plane3D g) -> Plane3D"""
    return _IMP_algebra.get_plane_3d_geometry(g)
class Reflection3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Reflection3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Reflection3D self) -> Reflection3D
        __init__(Reflection3D self, Plane3D pl) -> Reflection3D
        """
        _IMP_algebra.Reflection3D_swiginit(self, _IMP_algebra.new_Reflection3D(*args))

    def get_reflected(self, v):
        r"""get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
        return _IMP_algebra.Reflection3D_get_reflected(self, v)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Reflection3D self) -> PyObject *"""
        return _IMP_algebra.Reflection3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Reflection3D self, PyObject * p)"""
        return _IMP_algebra.Reflection3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Reflection3D

# Register Reflection3D in _IMP_algebra:
_IMP_algebra.Reflection3D_swigregister(Reflection3D)
class Cylinder3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Cylinder3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Cylinder3D self) -> Cylinder3D
        __init__(Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
        """
        _IMP_algebra.Cylinder3D_swiginit(self, _IMP_algebra.new_Cylinder3D(*args))

    def get_radius(self):
        r"""get_radius(Cylinder3D self) -> double"""
        return _IMP_algebra.Cylinder3D_get_radius(self)

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Cylinder3D self) -> PyObject *"""
        return _IMP_algebra.Cylinder3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Cylinder3D self, PyObject * p)"""
        return _IMP_algebra.Cylinder3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Cylinder3D

# Register Cylinder3D in _IMP_algebra:
_IMP_algebra.Cylinder3D_swigregister(Cylinder3D)

def get_cylinder_3d_geometry(g):
    r"""get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
    return _IMP_algebra.get_cylinder_3d_geometry(g)
class Ellipsoid3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Ellipsoid3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Ellipsoid3D self) -> Ellipsoid3D
        __init__(Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
        __init__(Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
        """
        _IMP_algebra.Ellipsoid3D_swiginit(self, _IMP_algebra.new_Ellipsoid3D(*args))

    def get_radii(self):
        r"""get_radii(Ellipsoid3D self) -> Vector3D"""
        return _IMP_algebra.Ellipsoid3D_get_radii(self)

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Ellipsoid3D self) -> PyObject *"""
        return _IMP_algebra.Ellipsoid3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Ellipsoid3D self, PyObject * p)"""
        return _IMP_algebra.Ellipsoid3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D

# Register Ellipsoid3D in _IMP_algebra:
_IMP_algebra.Ellipsoid3D_swigregister(Ellipsoid3D)

def get_ellipsoid_3d_geometry(g):
    r"""get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
    return _IMP_algebra.get_ellipsoid_3d_geometry(g)
class ConnollySurfacePoint(object):
    r"""Proxy of C++ IMP::algebra::ConnollySurfacePoint class."""

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

    def __init__(self, *args):
        r"""
        __init__(ConnollySurfacePoint self) -> ConnollySurfacePoint
        __init__(ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
        """
        _IMP_algebra.ConnollySurfacePoint_swiginit(self, _IMP_algebra.new_ConnollySurfacePoint(*args))

    def get_atom(self, i):
        r"""get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
        return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
        return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConnollySurfacePoint self, PyObject * p)"""
        return _IMP_algebra.ConnollySurfacePoint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint

# Register ConnollySurfacePoint in _IMP_algebra:
_IMP_algebra.ConnollySurfacePoint_swigregister(ConnollySurfacePoint)

def get_connolly_surface(spheres, density, probe_radius):
    r"""get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
    return _IMP_algebra.get_connolly_surface(spheres, density, probe_radius)
class LogEmbedding3D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding3D self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
        __init__(LogEmbedding3D self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
        __init__(LogEmbedding3D self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
        __init__(LogEmbedding3D self) -> LogEmbedding3D
        """
        _IMP_algebra.LogEmbedding3D_swiginit(self, _IMP_algebra.new_LogEmbedding3D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.LogEmbedding3D_set_origin(self, o)

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

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

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)

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

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

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding3D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding3D_show(self, *args)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding3D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding3D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D

# Register LogEmbedding3D in _IMP_algebra:
_IMP_algebra.LogEmbedding3D_swigregister(LogEmbedding3D)
class LogEmbeddingKD(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbeddingKD self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
        __init__(LogEmbeddingKD self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
        __init__(LogEmbeddingKD self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
        __init__(LogEmbeddingKD self) -> LogEmbeddingKD
        """
        _IMP_algebra.LogEmbeddingKD_swiginit(self, _IMP_algebra.new_LogEmbeddingKD(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)

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

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

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)

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

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

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbeddingKD self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbeddingKD_show(self, *args)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
        return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbeddingKD self, PyObject * p)"""
        return _IMP_algebra.LogEmbeddingKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD

# Register LogEmbeddingKD in _IMP_algebra:
_IMP_algebra.LogEmbeddingKD_swigregister(LogEmbeddingKD)
class DenseFloatLogGridKD(object):
    r"""Proxy of C++ IMP::algebra::DenseFloatLogGridKD class."""

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

    def __init__(self, sz, le):
        r"""__init__(DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
        _IMP_algebra.DenseFloatLogGridKD_swiginit(self, _IMP_algebra.new_DenseFloatLogGridKD(sz, le))

    def add_voxel(self, i, q):
        r"""add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
        return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, i, q)

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

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
        get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
        """
        return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)

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

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

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
        return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, v)

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

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

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

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

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

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

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

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

# Register DenseFloatLogGridKD in _IMP_algebra:
_IMP_algebra.DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
class DenseIntLogGrid3D(object):
    r"""Proxy of C++ IMP::algebra::DenseIntLogGrid3D class."""

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

    def __init__(self, sz, le):
        r"""__init__(DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
        _IMP_algebra.DenseIntLogGrid3D_swiginit(self, _IMP_algebra.new_DenseIntLogGrid3D(sz, le))

    def add_voxel(self, i, q):
        r"""add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, i, q)

    def __getitem__(self, *args):
        r"""
        __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
        __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
        """
        return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(DenseIntLogGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
        return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        r"""
        get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, v)

    def get_index(self, v):
        r"""get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)

    def get_origin(self):
        r"""get_origin(DenseIntLogGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)

    def get_has_index(self, v):
        r"""get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, v)

    def __str__(self):
        r"""__str__(DenseIntLogGrid3D self) -> std::string"""
        return _IMP_algebra.DenseIntLogGrid3D___str__(self)

    def __repr__(self):
        r"""__repr__(DenseIntLogGrid3D self) -> std::string"""
        return _IMP_algebra.DenseIntLogGrid3D___repr__(self)

    def show(self, *args):
        r"""show(DenseIntLogGrid3D self, _ostream out=std::cout)"""
        return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)
    __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D

# Register DenseIntLogGrid3D in _IMP_algebra:
_IMP_algebra.DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
class DenseDoubleGrid3D(object):
    r"""Proxy of C++ IMP::algebra::DenseGrid3D< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DenseDoubleGrid3D self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
        __init__(DenseDoubleGrid3D self) -> DenseDoubleGrid3D
        """
        _IMP_algebra.DenseDoubleGrid3D_swiginit(self, _IMP_algebra.new_DenseDoubleGrid3D(*args))

    def add_voxel(self, i, q):
        r"""add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, i, q)

    def __getitem__(self, *args):
        r"""
        __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
        __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
        """
        return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(DenseDoubleGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
        return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        r"""
        get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, v)

    def get_index(self, v):
        r"""get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)

    def get_origin(self):
        r"""get_origin(DenseDoubleGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)

    def get_has_index(self, v):
        r"""get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, v)

    def __str__(self):
        r"""__str__(DenseDoubleGrid3D self) -> std::string"""
        return _IMP_algebra.DenseDoubleGrid3D___str__(self)

    def __repr__(self):
        r"""__repr__(DenseDoubleGrid3D self) -> std::string"""
        return _IMP_algebra.DenseDoubleGrid3D___repr__(self)

    def show(self, *args):
        r"""show(DenseDoubleGrid3D self, _ostream out=std::cout)"""
        return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)
    __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D

# Register DenseDoubleGrid3D in _IMP_algebra:
_IMP_algebra.DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
class DenseFloatGrid3D(object):
    r"""Proxy of C++ IMP::algebra::DenseGrid3D< float > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DenseFloatGrid3D self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
        __init__(DenseFloatGrid3D self) -> DenseFloatGrid3D
        """
        _IMP_algebra.DenseFloatGrid3D_swiginit(self, _IMP_algebra.new_DenseFloatGrid3D(*args))

    def add_voxel(self, i, q):
        r"""add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, i, q)

    def __getitem__(self, *args):
        r"""
        __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
        __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
        """
        return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(DenseFloatGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
        return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        r"""
        get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        """
        return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, v)

    def get_index(self, v):
        r"""get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)

    def get_origin(self):
        r"""get_origin(DenseFloatGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DenseFloatGrid3D self) -> unsigned int"""
        return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
        return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)

    def get_has_index(self, v):
        r"""get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, v)

    def __str__(self):
        r"""__str__(DenseFloatGrid3D self) -> std::string"""
        return _IMP_algebra.DenseFloatGrid3D___str__(self)

    def __repr__(self):
        r"""__repr__(DenseFloatGrid3D self) -> std::string"""
        return _IMP_algebra.DenseFloatGrid3D___repr__(self)

    def show(self, *args):
        r"""show(DenseFloatGrid3D self, _ostream out=std::cout)"""
        return _IMP_algebra.DenseFloatGrid3D_show(self, *args)
    __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D

# Register DenseFloatGrid3D in _IMP_algebra:
_IMP_algebra.DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
class SparseUnboundedIntGrid3D(object):
    r"""Proxy of C++ IMP::algebra::SparseUnboundedGrid3D< int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SparseUnboundedIntGrid3D self, double side, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
        __init__(SparseUnboundedIntGrid3D self, Vector3D sides, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
        __init__(SparseUnboundedIntGrid3D self) -> SparseUnboundedIntGrid3D
        """
        _IMP_algebra.SparseUnboundedIntGrid3D_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGrid3D(*args))

    def add_voxel(self, i, q):
        r"""add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, i, q)

    def __getitem__(self, *args):
        r"""
        __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
        __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        r"""
        get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
        """
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, v)

    def get_index(self, v):
        r"""get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)

    def get_origin(self):
        r"""get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)

    def get_unit_cell(self):
        r"""get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)

    def get_has_index(self, v):
        r"""get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, v)

    def __str__(self):
        r"""__str__(SparseUnboundedIntGrid3D self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)

    def __repr__(self):
        r"""__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)

    def show(self, *args):
        r"""show(SparseUnboundedIntGrid3D self, _ostream out=std::cout)"""
        return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)
    __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D

# Register SparseUnboundedIntGrid3D in _IMP_algebra:
_IMP_algebra.SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
class SparseUnboundedIntGridKD(object):
    r"""Proxy of C++ IMP::algebra::SparseUnboundedGridD< -1,int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SparseUnboundedIntGridKD self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
        __init__(SparseUnboundedIntGridKD self) -> SparseUnboundedIntGridKD
        """
        _IMP_algebra.SparseUnboundedIntGridKD_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGridKD(*args))

    def add_voxel(self, i, q):
        r"""add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, i, q)

    def __getitem__(self, *args):
        r"""
        __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
        __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
        """
        return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""
        get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
        get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)

    def get_extended_indexes(self, *args):
        r"""
        get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
        get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
        """
        return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)

    def get_center(self, *args):
        r"""
        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, v):
        r"""get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, v)

    def get_index(self, v):
        r"""get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)

    def get_origin(self):
        r"""get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)

    def get_unit_cell(self):
        r"""get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)

    def get_has_index(self, v):
        r"""get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
        return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, v)

    def __str__(self):
        r"""__str__(SparseUnboundedIntGridKD self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)

    def __repr__(self):
        r"""__repr__(SparseUnboundedIntGridKD self) -> std::string"""
        return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)

    def show(self, *args):
        r"""show(SparseUnboundedIntGridKD self, _ostream out=std::cout)"""
        return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)
    __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD

# Register SparseUnboundedIntGridKD in _IMP_algebra:
_IMP_algebra.SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
class GridIndex1D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex1D self) -> GridIndex1D
        __init__(GridIndex1D self, int x) -> GridIndex1D
        __init__(GridIndex1D self, int x, int y) -> GridIndex1D
        __init__(GridIndex1D self, int x, int y, int z) -> GridIndex1D
        __init__(GridIndex1D self, int i, int j, int k, int l) -> GridIndex1D
        __init__(GridIndex1D self, int i, int j, int k, int l, int m) -> GridIndex1D
        __init__(GridIndex1D self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
        """
        _IMP_algebra.GridIndex1D_swiginit(self, _IMP_algebra.new_GridIndex1D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex1D self) -> unsigned int"""
        return _IMP_algebra.GridIndex1D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex1D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex1D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex1D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex1D self) -> unsigned int"""
        return _IMP_algebra.GridIndex1D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex1D self, GridIndex1D o) -> bool"""
        return _IMP_algebra.GridIndex1D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex1D self) -> std::size_t"""
        return _IMP_algebra.GridIndex1D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex1D self) -> std::string"""
        return _IMP_algebra.GridIndex1D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex1D self) -> std::string"""
        return _IMP_algebra.GridIndex1D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex1D self) -> PyObject *"""
        return _IMP_algebra.GridIndex1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex1D self, PyObject * p)"""
        return _IMP_algebra.GridIndex1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex1D

# Register GridIndex1D in _IMP_algebra:
_IMP_algebra.GridIndex1D_swigregister(GridIndex1D)
class GridIndex2D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex2D self) -> GridIndex2D
        __init__(GridIndex2D self, int x) -> GridIndex2D
        __init__(GridIndex2D self, int x, int y) -> GridIndex2D
        __init__(GridIndex2D self, int x, int y, int z) -> GridIndex2D
        __init__(GridIndex2D self, int i, int j, int k, int l) -> GridIndex2D
        __init__(GridIndex2D self, int i, int j, int k, int l, int m) -> GridIndex2D
        __init__(GridIndex2D self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
        """
        _IMP_algebra.GridIndex2D_swiginit(self, _IMP_algebra.new_GridIndex2D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex2D self) -> unsigned int"""
        return _IMP_algebra.GridIndex2D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex2D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex2D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex2D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex2D self) -> unsigned int"""
        return _IMP_algebra.GridIndex2D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex2D self, GridIndex2D o) -> bool"""
        return _IMP_algebra.GridIndex2D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex2D self) -> std::size_t"""
        return _IMP_algebra.GridIndex2D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex2D self) -> std::string"""
        return _IMP_algebra.GridIndex2D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex2D self) -> std::string"""
        return _IMP_algebra.GridIndex2D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex2D self) -> PyObject *"""
        return _IMP_algebra.GridIndex2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex2D self, PyObject * p)"""
        return _IMP_algebra.GridIndex2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex2D

# Register GridIndex2D in _IMP_algebra:
_IMP_algebra.GridIndex2D_swigregister(GridIndex2D)
class GridIndex3D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex3D self) -> GridIndex3D
        __init__(GridIndex3D self, int x) -> GridIndex3D
        __init__(GridIndex3D self, int x, int y) -> GridIndex3D
        __init__(GridIndex3D self, int x, int y, int z) -> GridIndex3D
        __init__(GridIndex3D self, int i, int j, int k, int l) -> GridIndex3D
        __init__(GridIndex3D self, int i, int j, int k, int l, int m) -> GridIndex3D
        __init__(GridIndex3D self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
        """
        _IMP_algebra.GridIndex3D_swiginit(self, _IMP_algebra.new_GridIndex3D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex3D self) -> unsigned int"""
        return _IMP_algebra.GridIndex3D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex3D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex3D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex3D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex3D self) -> unsigned int"""
        return _IMP_algebra.GridIndex3D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex3D self, GridIndex3D o) -> bool"""
        return _IMP_algebra.GridIndex3D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex3D self) -> std::size_t"""
        return _IMP_algebra.GridIndex3D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex3D self) -> std::string"""
        return _IMP_algebra.GridIndex3D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex3D self) -> std::string"""
        return _IMP_algebra.GridIndex3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex3D self) -> PyObject *"""
        return _IMP_algebra.GridIndex3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex3D self, PyObject * p)"""
        return _IMP_algebra.GridIndex3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex3D

# Register GridIndex3D in _IMP_algebra:
_IMP_algebra.GridIndex3D_swigregister(GridIndex3D)
class GridIndex4D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex4D self) -> GridIndex4D
        __init__(GridIndex4D self, int x) -> GridIndex4D
        __init__(GridIndex4D self, int x, int y) -> GridIndex4D
        __init__(GridIndex4D self, int x, int y, int z) -> GridIndex4D
        __init__(GridIndex4D self, int i, int j, int k, int l) -> GridIndex4D
        __init__(GridIndex4D self, int i, int j, int k, int l, int m) -> GridIndex4D
        __init__(GridIndex4D self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
        """
        _IMP_algebra.GridIndex4D_swiginit(self, _IMP_algebra.new_GridIndex4D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex4D self) -> unsigned int"""
        return _IMP_algebra.GridIndex4D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex4D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex4D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex4D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex4D self) -> unsigned int"""
        return _IMP_algebra.GridIndex4D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex4D self, GridIndex4D o) -> bool"""
        return _IMP_algebra.GridIndex4D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex4D self) -> std::size_t"""
        return _IMP_algebra.GridIndex4D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex4D self) -> std::string"""
        return _IMP_algebra.GridIndex4D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex4D self) -> std::string"""
        return _IMP_algebra.GridIndex4D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex4D self) -> PyObject *"""
        return _IMP_algebra.GridIndex4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex4D self, PyObject * p)"""
        return _IMP_algebra.GridIndex4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex4D

# Register GridIndex4D in _IMP_algebra:
_IMP_algebra.GridIndex4D_swigregister(GridIndex4D)
class GridIndex5D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex5D self) -> GridIndex5D
        __init__(GridIndex5D self, int x) -> GridIndex5D
        __init__(GridIndex5D self, int x, int y) -> GridIndex5D
        __init__(GridIndex5D self, int x, int y, int z) -> GridIndex5D
        __init__(GridIndex5D self, int i, int j, int k, int l) -> GridIndex5D
        __init__(GridIndex5D self, int i, int j, int k, int l, int m) -> GridIndex5D
        __init__(GridIndex5D self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
        """
        _IMP_algebra.GridIndex5D_swiginit(self, _IMP_algebra.new_GridIndex5D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex5D self) -> unsigned int"""
        return _IMP_algebra.GridIndex5D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex5D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex5D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex5D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex5D self) -> unsigned int"""
        return _IMP_algebra.GridIndex5D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex5D self, GridIndex5D o) -> bool"""
        return _IMP_algebra.GridIndex5D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex5D self) -> std::size_t"""
        return _IMP_algebra.GridIndex5D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex5D self) -> std::string"""
        return _IMP_algebra.GridIndex5D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex5D self) -> std::string"""
        return _IMP_algebra.GridIndex5D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex5D self) -> PyObject *"""
        return _IMP_algebra.GridIndex5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex5D self, PyObject * p)"""
        return _IMP_algebra.GridIndex5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex5D

# Register GridIndex5D in _IMP_algebra:
_IMP_algebra.GridIndex5D_swigregister(GridIndex5D)
class GridIndex6D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndex6D self) -> GridIndex6D
        __init__(GridIndex6D self, int x) -> GridIndex6D
        __init__(GridIndex6D self, int x, int y) -> GridIndex6D
        __init__(GridIndex6D self, int x, int y, int z) -> GridIndex6D
        __init__(GridIndex6D self, int i, int j, int k, int l) -> GridIndex6D
        __init__(GridIndex6D self, int i, int j, int k, int l, int m) -> GridIndex6D
        __init__(GridIndex6D self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
        """
        _IMP_algebra.GridIndex6D_swiginit(self, _IMP_algebra.new_GridIndex6D(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndex6D self) -> unsigned int"""
        return _IMP_algebra.GridIndex6D_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndex6D___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndex6D self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndex6D_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndex6D self) -> unsigned int"""
        return _IMP_algebra.GridIndex6D___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndex6D self, GridIndex6D o) -> bool"""
        return _IMP_algebra.GridIndex6D___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndex6D self) -> std::size_t"""
        return _IMP_algebra.GridIndex6D___hash__(self)

    def __str__(self):
        r"""__str__(GridIndex6D self) -> std::string"""
        return _IMP_algebra.GridIndex6D___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndex6D self) -> std::string"""
        return _IMP_algebra.GridIndex6D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndex6D self) -> PyObject *"""
        return _IMP_algebra.GridIndex6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndex6D self, PyObject * p)"""
        return _IMP_algebra.GridIndex6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndex6D

# Register GridIndex6D in _IMP_algebra:
_IMP_algebra.GridIndex6D_swigregister(GridIndex6D)
class GridIndexKD(IMP._Value):
    r"""Proxy of C++ IMP::algebra::GridIndexD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(GridIndexKD self) -> GridIndexKD
        __init__(GridIndexKD self, int x) -> GridIndexKD
        __init__(GridIndexKD self, int x, int y) -> GridIndexKD
        __init__(GridIndexKD self, int x, int y, int z) -> GridIndexKD
        __init__(GridIndexKD self, int i, int j, int k, int l) -> GridIndexKD
        __init__(GridIndexKD self, int i, int j, int k, int l, int m) -> GridIndexKD
        __init__(GridIndexKD self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
        """
        _IMP_algebra.GridIndexKD_swiginit(self, _IMP_algebra.new_GridIndexKD(*args))

    def get_dimension(self):
        r"""get_dimension(GridIndexKD self) -> unsigned int"""
        return _IMP_algebra.GridIndexKD_get_dimension(self)

    def __getitem__(self, i):
        r"""__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
        return _IMP_algebra.GridIndexKD___getitem__(self, i)

    def show(self, *args):
        r"""show(GridIndexKD self, _ostream out=std::cout)"""
        return _IMP_algebra.GridIndexKD_show(self, *args)

    def __len__(self):
        r"""__len__(GridIndexKD self) -> unsigned int"""
        return _IMP_algebra.GridIndexKD___len__(self)

    def __eq__(self, o):
        r"""__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___ge__(self, o)

    def __le__(self, o):
        r"""__le__(GridIndexKD self, GridIndexKD o) -> bool"""
        return _IMP_algebra.GridIndexKD___le__(self, o)

    def __hash__(self):
        r"""__hash__(GridIndexKD self) -> std::size_t"""
        return _IMP_algebra.GridIndexKD___hash__(self)

    def __str__(self):
        r"""__str__(GridIndexKD self) -> std::string"""
        return _IMP_algebra.GridIndexKD___str__(self)

    def __repr__(self):
        r"""__repr__(GridIndexKD self) -> std::string"""
        return _IMP_algebra.GridIndexKD___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(GridIndexKD self) -> PyObject *"""
        return _IMP_algebra.GridIndexKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridIndexKD self, PyObject * p)"""
        return _IMP_algebra.GridIndexKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_GridIndexKD

# Register GridIndexKD in _IMP_algebra:
_IMP_algebra.GridIndexKD_swigregister(GridIndexKD)
class ExtendedGridIndex1D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex1D self, IMP::Ints vals) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int x) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int x, int y) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int x, int y, int z) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int i, int j, int k, int l) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
        __init__(ExtendedGridIndex1D self) -> ExtendedGridIndex1D
        """
        _IMP_algebra.ExtendedGridIndex1D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex1D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex1D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex1D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex1D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex1D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex1D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
        return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
        return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex1D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex1D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex1D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex1D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex1D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D

# Register ExtendedGridIndex1D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
class ExtendedGridIndex2D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex2D self, IMP::Ints vals) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int x) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int x, int y) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int x, int y, int z) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int i, int j, int k, int l) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
        __init__(ExtendedGridIndex2D self) -> ExtendedGridIndex2D
        """
        _IMP_algebra.ExtendedGridIndex2D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex2D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex2D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex2D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex2D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex2D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex2D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
        return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
        return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex2D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex2D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex2D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex2D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex2D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D

# Register ExtendedGridIndex2D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
class ExtendedGridIndex3D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex3D self, IMP::Ints vals) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int x) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int x, int y) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int x, int y, int z) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int i, int j, int k, int l) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
        __init__(ExtendedGridIndex3D self) -> ExtendedGridIndex3D
        """
        _IMP_algebra.ExtendedGridIndex3D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex3D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex3D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex3D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex3D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex3D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex3D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
        return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
        return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex3D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex3D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex3D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex3D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D

# Register ExtendedGridIndex3D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
class ExtendedGridIndex4D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex4D self, IMP::Ints vals) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int x) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int x, int y) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int x, int y, int z) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int i, int j, int k, int l) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
        __init__(ExtendedGridIndex4D self) -> ExtendedGridIndex4D
        """
        _IMP_algebra.ExtendedGridIndex4D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex4D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex4D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex4D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex4D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex4D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex4D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
        return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
        return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex4D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex4D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex4D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex4D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex4D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D

# Register ExtendedGridIndex4D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
class ExtendedGridIndex5D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex5D self, IMP::Ints vals) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int x) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int x, int y) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int x, int y, int z) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int i, int j, int k, int l) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
        __init__(ExtendedGridIndex5D self) -> ExtendedGridIndex5D
        """
        _IMP_algebra.ExtendedGridIndex5D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex5D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex5D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex5D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex5D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex5D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex5D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
        return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
        return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex5D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex5D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex5D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex5D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex5D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D

# Register ExtendedGridIndex5D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
class ExtendedGridIndex6D(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndex6D self, IMP::Ints vals) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int x) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int x, int y) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int x, int y, int z) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int i, int j, int k, int l) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
        __init__(ExtendedGridIndex6D self) -> ExtendedGridIndex6D
        """
        _IMP_algebra.ExtendedGridIndex6D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex6D(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
        return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndex6D self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndex6D self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndex6D___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndex6D self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndex6D___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
        return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
        return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndex6D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex6D___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndex6D self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndex6D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndex6D self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndex6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D

# Register ExtendedGridIndex6D in _IMP_algebra:
_IMP_algebra.ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
class ExtendedGridIndexKD(IMP._Value):
    r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(ExtendedGridIndexKD self, IMP::Ints vals) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int x) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int x, int y) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int x, int y, int z) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int i, int j, int k, int l) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
        __init__(ExtendedGridIndexKD self) -> ExtendedGridIndexKD
        """
        _IMP_algebra.ExtendedGridIndexKD_swiginit(self, _IMP_algebra.new_ExtendedGridIndexKD(*args))

    def get_dimension(self):
        r"""get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)

    def __eq__(self, o):
        r"""__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
        return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)

    def __setitem__(self, i, v):
        r"""__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
        return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, i, v)

    def __getitem__(self, i):
        r"""__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
        return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)

    def show(self, *args):
        r"""show(ExtendedGridIndexKD self, _ostream out=std::cout)"""
        return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)

    def __len__(self):
        r"""__len__(ExtendedGridIndexKD self) -> unsigned int"""
        return _IMP_algebra.ExtendedGridIndexKD___len__(self)

    def __hash__(self):
        r"""__hash__(ExtendedGridIndexKD self) -> std::size_t"""
        return _IMP_algebra.ExtendedGridIndexKD___hash__(self)

    def get_uniform_offset(self, ii):
        r"""get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
        return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, ii)

    def get_offset(self, i, j, k):
        r"""get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
        return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, i, j, k)

    def __str__(self):
        r"""__str__(ExtendedGridIndexKD self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndexKD___str__(self)

    def __repr__(self):
        r"""__repr__(ExtendedGridIndexKD self) -> std::string"""
        return _IMP_algebra.ExtendedGridIndexKD___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
        return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ExtendedGridIndexKD self, PyObject * p)"""
        return _IMP_algebra.ExtendedGridIndexKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD

# Register ExtendedGridIndexKD in _IMP_algebra:
_IMP_algebra.ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
class BoundedGridRange1D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 1 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange1D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange1D self) -> BoundedGridRange1D
        __init__(BoundedGridRange1D self, IMP::Ints const & counts) -> BoundedGridRange1D
        """
        _IMP_algebra.BoundedGridRange1D_swiginit(self, _IMP_algebra.new_BoundedGridRange1D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange1D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange1D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange1D self) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
        return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
        return _IMP_algebra.BoundedGridRange1D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
        return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange1D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange1D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange1D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange1D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange1D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D

# Register BoundedGridRange1D in _IMP_algebra:
_IMP_algebra.BoundedGridRange1D_swigregister(BoundedGridRange1D)
class BoundedGridRange2D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 2 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange2D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange2D self) -> BoundedGridRange2D
        __init__(BoundedGridRange2D self, IMP::Ints const & counts) -> BoundedGridRange2D
        """
        _IMP_algebra.BoundedGridRange2D_swiginit(self, _IMP_algebra.new_BoundedGridRange2D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange2D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange2D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange2D self) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
        return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
        return _IMP_algebra.BoundedGridRange2D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
        return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange2D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange2D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange2D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange2D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange2D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D

# Register BoundedGridRange2D in _IMP_algebra:
_IMP_algebra.BoundedGridRange2D_swigregister(BoundedGridRange2D)
class BoundedGridRange3D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 3 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange3D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange3D self) -> BoundedGridRange3D
        __init__(BoundedGridRange3D self, IMP::Ints const & counts) -> BoundedGridRange3D
        """
        _IMP_algebra.BoundedGridRange3D_swiginit(self, _IMP_algebra.new_BoundedGridRange3D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange3D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange3D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
        return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
        return _IMP_algebra.BoundedGridRange3D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
        return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange3D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange3D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange3D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange3D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange3D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D

# Register BoundedGridRange3D in _IMP_algebra:
_IMP_algebra.BoundedGridRange3D_swigregister(BoundedGridRange3D)
class BoundedGridRange4D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 4 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange4D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange4D self) -> BoundedGridRange4D
        __init__(BoundedGridRange4D self, IMP::Ints const & counts) -> BoundedGridRange4D
        """
        _IMP_algebra.BoundedGridRange4D_swiginit(self, _IMP_algebra.new_BoundedGridRange4D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange4D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange4D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange4D self) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
        return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
        return _IMP_algebra.BoundedGridRange4D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
        return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange4D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange4D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange4D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange4D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange4D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D

# Register BoundedGridRange4D in _IMP_algebra:
_IMP_algebra.BoundedGridRange4D_swigregister(BoundedGridRange4D)
class BoundedGridRange5D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 5 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange5D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange5D self) -> BoundedGridRange5D
        __init__(BoundedGridRange5D self, IMP::Ints const & counts) -> BoundedGridRange5D
        """
        _IMP_algebra.BoundedGridRange5D_swiginit(self, _IMP_algebra.new_BoundedGridRange5D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange5D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange5D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange5D self) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
        return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
        return _IMP_algebra.BoundedGridRange5D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
        return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange5D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange5D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange5D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange5D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange5D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D

# Register BoundedGridRange5D in _IMP_algebra:
_IMP_algebra.BoundedGridRange5D_swigregister(BoundedGridRange5D)
class BoundedGridRange6D(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 6 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRange6D_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRange6D self) -> BoundedGridRange6D
        __init__(BoundedGridRange6D self, IMP::Ints const & counts) -> BoundedGridRange6D
        """
        _IMP_algebra.BoundedGridRange6D_swiginit(self, _IMP_algebra.new_BoundedGridRange6D(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRange6D self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRange6D_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRange6D self) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
        return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
        return _IMP_algebra.BoundedGridRange6D_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
        return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRange6D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange6D___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRange6D self) -> std::string"""
        return _IMP_algebra.BoundedGridRange6D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
        return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRange6D self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRange6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D

# Register BoundedGridRange6D in _IMP_algebra:
_IMP_algebra.BoundedGridRange6D_swigregister(BoundedGridRange6D)
class BoundedGridRangeKD(object):
    r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< -1 > class."""

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

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()

    def __init__(self, *args):
        r"""
        __init__(BoundedGridRangeKD self) -> BoundedGridRangeKD
        __init__(BoundedGridRangeKD self, IMP::Ints const & counts) -> BoundedGridRangeKD
        """
        _IMP_algebra.BoundedGridRangeKD_swiginit(self, _IMP_algebra.new_BoundedGridRangeKD(*args))

    def get_number_of_voxels(self, *args):
        r"""
        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):
        r"""get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)

    def show(self, *args):
        r"""show(BoundedGridRangeKD self, _ostream out=std::cout)"""
        return _IMP_algebra.BoundedGridRangeKD_show(self, *args)

    def get_all_indexes(self):
        r"""get_all_indexes(BoundedGridRangeKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)

    def get_indexes(self, lb, ub):
        r"""get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, lb, ub)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
        return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, lb, ub)

    def get_index(self, v):
        r"""get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)

    def get_has_index(self, v):
        r"""get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
        return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, v)

    def get_minimum_extended_index(self):
        r"""get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)

    def get_maximum_extended_index(self):
        r"""get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
        return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)

    def __str__(self):
        r"""__str__(BoundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.BoundedGridRangeKD___str__(self)

    def __repr__(self):
        r"""__repr__(BoundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.BoundedGridRangeKD___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
        return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
        return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BoundedGridRangeKD self, PyObject * p)"""
        return _IMP_algebra.BoundedGridRangeKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD

# Register BoundedGridRangeKD in _IMP_algebra:
_IMP_algebra.BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
class UnboundedGridRange1D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange1D self) -> UnboundedGridRange1D
        __init__(UnboundedGridRange1D self, IMP::Ints const & arg2) -> UnboundedGridRange1D
        """
        _IMP_algebra.UnboundedGridRange1D_swiginit(self, _IMP_algebra.new_UnboundedGridRange1D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange1D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange1D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
        return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange1D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange1D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange1D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange1D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange1D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D

# Register UnboundedGridRange1D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
class UnboundedGridRange2D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange2D self) -> UnboundedGridRange2D
        __init__(UnboundedGridRange2D self, IMP::Ints const & arg2) -> UnboundedGridRange2D
        """
        _IMP_algebra.UnboundedGridRange2D_swiginit(self, _IMP_algebra.new_UnboundedGridRange2D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange2D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange2D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
        return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange2D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange2D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange2D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange2D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange2D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D

# Register UnboundedGridRange2D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
class UnboundedGridRange3D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange3D self) -> UnboundedGridRange3D
        __init__(UnboundedGridRange3D self, IMP::Ints const & arg2) -> UnboundedGridRange3D
        """
        _IMP_algebra.UnboundedGridRange3D_swiginit(self, _IMP_algebra.new_UnboundedGridRange3D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange3D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange3D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
        return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange3D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange3D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange3D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange3D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange3D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D

# Register UnboundedGridRange3D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
class UnboundedGridRange4D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange4D self) -> UnboundedGridRange4D
        __init__(UnboundedGridRange4D self, IMP::Ints const & arg2) -> UnboundedGridRange4D
        """
        _IMP_algebra.UnboundedGridRange4D_swiginit(self, _IMP_algebra.new_UnboundedGridRange4D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange4D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange4D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
        return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange4D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange4D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange4D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange4D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange4D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D

# Register UnboundedGridRange4D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
class UnboundedGridRange5D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange5D self) -> UnboundedGridRange5D
        __init__(UnboundedGridRange5D self, IMP::Ints const & arg2) -> UnboundedGridRange5D
        """
        _IMP_algebra.UnboundedGridRange5D_swiginit(self, _IMP_algebra.new_UnboundedGridRange5D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange5D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange5D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
        return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange5D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange5D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange5D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange5D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange5D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D

# Register UnboundedGridRange5D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
class UnboundedGridRange6D(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRange6D self) -> UnboundedGridRange6D
        __init__(UnboundedGridRange6D self, IMP::Ints const & arg2) -> UnboundedGridRange6D
        """
        _IMP_algebra.UnboundedGridRange6D_swiginit(self, _IMP_algebra.new_UnboundedGridRange6D(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRange6D self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRange6D_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
        return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRange6D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange6D___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRange6D self) -> std::string"""
        return _IMP_algebra.UnboundedGridRange6D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRange6D self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRange6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D

# Register UnboundedGridRange6D in _IMP_algebra:
_IMP_algebra.UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
class UnboundedGridRangeKD(object):
    r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(UnboundedGridRangeKD self) -> UnboundedGridRangeKD
        __init__(UnboundedGridRangeKD self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
        """
        _IMP_algebra.UnboundedGridRangeKD_swiginit(self, _IMP_algebra.new_UnboundedGridRangeKD(*args))

    def set_number_of_voxels(self, arg2):
        r"""set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
        return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, arg2)

    def get_number_of_voxels(self, arg2):
        r"""get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
        return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, arg2)

    @staticmethod
    def get_is_bounded():
        r"""get_is_bounded() -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()

    def get_has_index(self, arg2):
        r"""get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, arg2)

    def show(self, *args):
        r"""show(UnboundedGridRangeKD self, _ostream out=std::cout)"""
        return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)

    def get_extended_indexes(self, lb, ub):
        r"""get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
        return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, lb, ub)

    def __str__(self):
        r"""__str__(UnboundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.UnboundedGridRangeKD___str__(self)

    def __repr__(self):
        r"""__repr__(UnboundedGridRangeKD self) -> std::string"""
        return _IMP_algebra.UnboundedGridRangeKD___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
        return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
        return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnboundedGridRangeKD self, PyObject * p)"""
        return _IMP_algebra.UnboundedGridRangeKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD

# Register UnboundedGridRangeKD in _IMP_algebra:
_IMP_algebra.UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
class DefaultEmbedding1D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding1D self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
        __init__(DefaultEmbedding1D self) -> DefaultEmbedding1D
        """
        _IMP_algebra.DefaultEmbedding1D_swiginit(self, _IMP_algebra.new_DefaultEmbedding1D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding1D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
        return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding1D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding1D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding1D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding1D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding1D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding1D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding1D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D

# Register DefaultEmbedding1D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
class DefaultEmbedding2D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding2D self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
        __init__(DefaultEmbedding2D self) -> DefaultEmbedding2D
        """
        _IMP_algebra.DefaultEmbedding2D_swiginit(self, _IMP_algebra.new_DefaultEmbedding2D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding2D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
        return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding2D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding2D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding2D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding2D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding2D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding2D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding2D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D

# Register DefaultEmbedding2D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
class DefaultEmbedding3D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding3D self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
        __init__(DefaultEmbedding3D self) -> DefaultEmbedding3D
        """
        _IMP_algebra.DefaultEmbedding3D_swiginit(self, _IMP_algebra.new_DefaultEmbedding3D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding3D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
        return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
        return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding3D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding3D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding3D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding3D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding3D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding3D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding3D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D

# Register DefaultEmbedding3D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
class DefaultEmbedding4D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding4D self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
        __init__(DefaultEmbedding4D self) -> DefaultEmbedding4D
        """
        _IMP_algebra.DefaultEmbedding4D_swiginit(self, _IMP_algebra.new_DefaultEmbedding4D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding4D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
        return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding4D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding4D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding4D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding4D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding4D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding4D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding4D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D

# Register DefaultEmbedding4D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
class DefaultEmbedding5D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding5D self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
        __init__(DefaultEmbedding5D self) -> DefaultEmbedding5D
        """
        _IMP_algebra.DefaultEmbedding5D_swiginit(self, _IMP_algebra.new_DefaultEmbedding5D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding5D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
        return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding5D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding5D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding5D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding5D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding5D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding5D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding5D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D

# Register DefaultEmbedding5D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
class DefaultEmbedding6D(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbedding6D self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
        __init__(DefaultEmbedding6D self) -> DefaultEmbedding6D
        """
        _IMP_algebra.DefaultEmbedding6D_swiginit(self, _IMP_algebra.new_DefaultEmbedding6D(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbedding6D self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
        return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbedding6D self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbedding6D_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbedding6D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding6D___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbedding6D self) -> std::string"""
        return _IMP_algebra.DefaultEmbedding6D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
        return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbedding6D self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbedding6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D

# Register DefaultEmbedding6D in _IMP_algebra:
_IMP_algebra.DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
class DefaultEmbeddingKD(object):
    r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(DefaultEmbeddingKD self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
        __init__(DefaultEmbeddingKD self) -> DefaultEmbeddingKD
        """
        _IMP_algebra.DefaultEmbeddingKD_swiginit(self, _IMP_algebra.new_DefaultEmbeddingKD(*args))

    def set_origin(self, o):
        r"""set_origin(DefaultEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
        return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)

    def set_unit_cell(self, o):
        r"""set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
        return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, o)

    def get_inverse_unit_cell(self):
        r"""get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)

    def get_unit_cell(self):
        r"""get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
        return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DefaultEmbeddingKD self, _ostream out=std::cout)"""
        return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)

    def __str__(self):
        r"""__str__(DefaultEmbeddingKD self) -> std::string"""
        return _IMP_algebra.DefaultEmbeddingKD___str__(self)

    def __repr__(self):
        r"""__repr__(DefaultEmbeddingKD self) -> std::string"""
        return _IMP_algebra.DefaultEmbeddingKD___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
        return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
        return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DefaultEmbeddingKD self, PyObject * p)"""
        return _IMP_algebra.DefaultEmbeddingKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD

# Register DefaultEmbeddingKD in _IMP_algebra:
_IMP_algebra.DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
class LogEmbedding1D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding1D self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
        __init__(LogEmbedding1D self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
        __init__(LogEmbedding1D self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
        __init__(LogEmbedding1D self) -> LogEmbedding1D
        """
        _IMP_algebra.LogEmbedding1D_swiginit(self, _IMP_algebra.new_LogEmbedding1D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding1D self, Vector1D o)"""
        return _IMP_algebra.LogEmbedding1D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(LogEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.LogEmbedding1D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(LogEmbedding1D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding1D_get_dimension(self)

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding1D self) -> Vector1D"""
        return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
        return _IMP_algebra.LogEmbedding1D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
        return _IMP_algebra.LogEmbedding1D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding1D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding1D_show(self, *args)

    def __str__(self):
        r"""__str__(LogEmbedding1D self) -> std::string"""
        return _IMP_algebra.LogEmbedding1D___str__(self)

    def __repr__(self):
        r"""__repr__(LogEmbedding1D self) -> std::string"""
        return _IMP_algebra.LogEmbedding1D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding1D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding1D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D

# Register LogEmbedding1D in _IMP_algebra:
_IMP_algebra.LogEmbedding1D_swigregister(LogEmbedding1D)
class LogEmbedding2D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding2D self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
        __init__(LogEmbedding2D self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
        __init__(LogEmbedding2D self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
        __init__(LogEmbedding2D self) -> LogEmbedding2D
        """
        _IMP_algebra.LogEmbedding2D_swiginit(self, _IMP_algebra.new_LogEmbedding2D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding2D self, Vector2D o)"""
        return _IMP_algebra.LogEmbedding2D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(LogEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.LogEmbedding2D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(LogEmbedding2D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding2D_get_dimension(self)

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding2D self) -> Vector2D"""
        return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
        return _IMP_algebra.LogEmbedding2D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
        return _IMP_algebra.LogEmbedding2D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding2D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding2D_show(self, *args)

    def __str__(self):
        r"""__str__(LogEmbedding2D self) -> std::string"""
        return _IMP_algebra.LogEmbedding2D___str__(self)

    def __repr__(self):
        r"""__repr__(LogEmbedding2D self) -> std::string"""
        return _IMP_algebra.LogEmbedding2D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding2D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding2D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D

# Register LogEmbedding2D in _IMP_algebra:
_IMP_algebra.LogEmbedding2D_swigregister(LogEmbedding2D)
class LogEmbedding4D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding4D self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
        __init__(LogEmbedding4D self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
        __init__(LogEmbedding4D self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
        __init__(LogEmbedding4D self) -> LogEmbedding4D
        """
        _IMP_algebra.LogEmbedding4D_swiginit(self, _IMP_algebra.new_LogEmbedding4D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding4D self, Vector4D o)"""
        return _IMP_algebra.LogEmbedding4D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(LogEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.LogEmbedding4D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(LogEmbedding4D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding4D_get_dimension(self)

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding4D self) -> Vector4D"""
        return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
        return _IMP_algebra.LogEmbedding4D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
        return _IMP_algebra.LogEmbedding4D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding4D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding4D_show(self, *args)

    def __str__(self):
        r"""__str__(LogEmbedding4D self) -> std::string"""
        return _IMP_algebra.LogEmbedding4D___str__(self)

    def __repr__(self):
        r"""__repr__(LogEmbedding4D self) -> std::string"""
        return _IMP_algebra.LogEmbedding4D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding4D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding4D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D

# Register LogEmbedding4D in _IMP_algebra:
_IMP_algebra.LogEmbedding4D_swigregister(LogEmbedding4D)
class LogEmbedding5D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding5D self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
        __init__(LogEmbedding5D self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
        __init__(LogEmbedding5D self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
        __init__(LogEmbedding5D self) -> LogEmbedding5D
        """
        _IMP_algebra.LogEmbedding5D_swiginit(self, _IMP_algebra.new_LogEmbedding5D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding5D self, Vector5D o)"""
        return _IMP_algebra.LogEmbedding5D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(LogEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.LogEmbedding5D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(LogEmbedding5D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding5D_get_dimension(self)

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding5D self) -> Vector5D"""
        return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
        return _IMP_algebra.LogEmbedding5D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
        return _IMP_algebra.LogEmbedding5D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding5D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding5D_show(self, *args)

    def __str__(self):
        r"""__str__(LogEmbedding5D self) -> std::string"""
        return _IMP_algebra.LogEmbedding5D___str__(self)

    def __repr__(self):
        r"""__repr__(LogEmbedding5D self) -> std::string"""
        return _IMP_algebra.LogEmbedding5D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding5D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding5D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D

# Register LogEmbedding5D in _IMP_algebra:
_IMP_algebra.LogEmbedding5D_swigregister(LogEmbedding5D)
class LogEmbedding6D(object):
    r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(LogEmbedding6D self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
        __init__(LogEmbedding6D self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
        __init__(LogEmbedding6D self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
        __init__(LogEmbedding6D self) -> LogEmbedding6D
        """
        _IMP_algebra.LogEmbedding6D_swiginit(self, _IMP_algebra.new_LogEmbedding6D(*args))

    def set_origin(self, o):
        r"""set_origin(LogEmbedding6D self, Vector6D o)"""
        return _IMP_algebra.LogEmbedding6D_set_origin(self, o)

    def get_origin(self):
        r"""get_origin(LogEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.LogEmbedding6D_get_origin(self)

    def get_dimension(self):
        r"""get_dimension(LogEmbedding6D self) -> unsigned int"""
        return _IMP_algebra.LogEmbedding6D_get_dimension(self)

    def set_unit_cell(self, *args):
        r"""
        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):
        r"""get_unit_cell(LogEmbedding6D self) -> Vector6D"""
        return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)

    def get_extended_index(self, o):
        r"""get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
        return _IMP_algebra.LogEmbedding6D_get_extended_index(self, o)

    def get_index(self, o):
        r"""get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
        return _IMP_algebra.LogEmbedding6D_get_index(self, o)

    def get_center(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(LogEmbedding6D self, _ostream out=std::cout)"""
        return _IMP_algebra.LogEmbedding6D_show(self, *args)

    def __str__(self):
        r"""__str__(LogEmbedding6D self) -> std::string"""
        return _IMP_algebra.LogEmbedding6D___str__(self)

    def __repr__(self):
        r"""__repr__(LogEmbedding6D self) -> std::string"""
        return _IMP_algebra.LogEmbedding6D___repr__(self)

    def __eq__(self, arg2):
        r"""__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
        return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)

    def _get_as_binary(self):
        r"""_get_as_binary(LogEmbedding6D self) -> PyObject *"""
        return _IMP_algebra.LogEmbedding6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogEmbedding6D self, PyObject * p)"""
        return _IMP_algebra.LogEmbedding6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D

# Register LogEmbedding6D in _IMP_algebra:
_IMP_algebra.LogEmbedding6D_swigregister(LogEmbedding6D)
class SpherePatch3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::SpherePatch3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(SpherePatch3D self) -> SpherePatch3D
        __init__(SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
        """
        _IMP_algebra.SpherePatch3D_swiginit(self, _IMP_algebra.new_SpherePatch3D(*args))

    def get_contains(self, p):
        r"""get_contains(SpherePatch3D self, Vector3D p) -> bool"""
        return _IMP_algebra.SpherePatch3D_get_contains(self, p)

    def get_plane(self):
        r"""get_plane(SpherePatch3D self) -> Plane3D"""
        return _IMP_algebra.SpherePatch3D_get_plane(self)

    def get_sphere(self):
        r"""get_sphere(SpherePatch3D self) -> Sphere3D"""
        return _IMP_algebra.SpherePatch3D_get_sphere(self)

    def show(self, *args):
        r"""show(SpherePatch3D self, _ostream out=std::cout)"""
        return _IMP_algebra.SpherePatch3D_show(self, *args)

    def get_boundary_point(self):
        r"""get_boundary_point(SpherePatch3D self) -> Vector3D"""
        return _IMP_algebra.SpherePatch3D_get_boundary_point(self)

    def __str__(self):
        r"""__str__(SpherePatch3D self) -> std::string"""
        return _IMP_algebra.SpherePatch3D___str__(self)

    def __repr__(self):
        r"""__repr__(SpherePatch3D self) -> std::string"""
        return _IMP_algebra.SpherePatch3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SpherePatch3D self) -> PyObject *"""
        return _IMP_algebra.SpherePatch3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SpherePatch3D self, PyObject * p)"""
        return _IMP_algebra.SpherePatch3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D

# Register SpherePatch3D in _IMP_algebra:
_IMP_algebra.SpherePatch3D_swigregister(SpherePatch3D)

def get_area(*args):
    r"""
    get_area(Plane3D g) -> double
    get_area(SpherePatch3D g) -> double
    """
    return _IMP_algebra.get_area(*args)

def get_sphere_patch_3d_geometry(g):
    r"""get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
    return _IMP_algebra.get_sphere_patch_3d_geometry(g)
class Cone3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Cone3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Cone3D self) -> Cone3D
        __init__(Cone3D self, Segment3D s, double radius) -> Cone3D
        """
        _IMP_algebra.Cone3D_swiginit(self, _IMP_algebra.new_Cone3D(*args))

    def get_tip(self):
        r"""get_tip(Cone3D self) -> Vector3D"""
        return _IMP_algebra.Cone3D_get_tip(self)

    def get_direction(self):
        r"""get_direction(Cone3D self) -> Vector3D"""
        return _IMP_algebra.Cone3D_get_direction(self)

    def get_height(self):
        r"""get_height(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_height(self)

    def get_angle(self):
        r"""get_angle(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_angle(self)

    def get_radius(self):
        r"""get_radius(Cone3D self) -> double"""
        return _IMP_algebra.Cone3D_get_radius(self)

    def get_contains(self, v):
        r"""get_contains(Cone3D self, Vector3D v) -> bool"""
        return _IMP_algebra.Cone3D_get_contains(self, v)

    def get_base_plane(self):
        r"""get_base_plane(Cone3D self) -> Plane3D"""
        return _IMP_algebra.Cone3D_get_base_plane(self)

    def show(self, *args):
        r"""show(Cone3D self, _ostream out=std::cout)"""
        return _IMP_algebra.Cone3D_show(self, *args)

    def __str__(self):
        r"""__str__(Cone3D self) -> std::string"""
        return _IMP_algebra.Cone3D___str__(self)

    def __repr__(self):
        r"""__repr__(Cone3D self) -> std::string"""
        return _IMP_algebra.Cone3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Cone3D self) -> PyObject *"""
        return _IMP_algebra.Cone3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Cone3D self, PyObject * p)"""
        return _IMP_algebra.Cone3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Cone3D

# Register Cone3D in _IMP_algebra:
_IMP_algebra.Cone3D_swigregister(Cone3D)

def get_surface_area(*args):
    r"""
    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):
    r"""
    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(g):
    r"""get_cone_3d_geometry(Cone3D g) -> Cone3D"""
    return _IMP_algebra.get_cone_3d_geometry(g)

def write_pts(vs, out):
    r"""write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
    return _IMP_algebra.write_pts(vs, out)

def read_pts(input):
    r"""read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
    return _IMP_algebra.read_pts(input)

def write_spheres(vs, out):
    r"""write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
    return _IMP_algebra.write_spheres(vs, out)

def read_spheres(input):
    r"""read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
    return _IMP_algebra.read_spheres(input)

def get_random_vector_on_unit_sphere():
    r"""get_random_vector_on_unit_sphere() -> Vector3D"""
    return _IMP_algebra.get_random_vector_on_unit_sphere()

def get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle):
    r"""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(cyl, number_of_cycles, number_of_points_on_cycle)

def get_random_chain(*args):
    r"""get_random_chain(unsigned int n, double r, Vector3D start=IMP::Vector3D(0, 0, 0), IMP::algebra::Sphere3Ds const & obstacles=IMP::algebra::Sphere3Ds()) -> IMP::algebra::Vector3Ds"""
    return _IMP_algebra.get_random_chain(*args)

def reversed_read(dest, size, nitems, f, reverse):
    r"""reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
    return _IMP_algebra.reversed_read(dest, size, nitems, f, reverse)

def reversed_write(src, size, nitems, f, reverse=False):
    r"""reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)"""
    return _IMP_algebra.reversed_write(src, size, nitems, f, reverse)

def get_is_big_endian():
    r"""get_is_big_endian() -> bool"""
    return _IMP_algebra.get_is_big_endian()

def get_is_little_endian():
    r"""get_is_little_endian() -> bool"""
    return _IMP_algebra.get_is_little_endian()

def get_shortest_segment(*args):
    r"""
    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.Object):
    r"""Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class."""

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

    def __init__(self, vs, query_estimate=1):
        r"""__init__(DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D"""
        _IMP_algebra.DynamicNearestNeighbor3D_swiginit(self, _IMP_algebra.new_DynamicNearestNeighbor3D(vs, query_estimate))

    def get_in_ball(self, id, distance):
        r"""get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
        return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, id, distance)

    def set_coordinates(self, id, nc):
        r"""set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
        return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, id, nc)

    def get_version_info(self):
        r"""get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
        return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_DynamicNearestNeighbor3D

    def __str__(self):
        r"""__str__(DynamicNearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)

    def __repr__(self):
        r"""__repr__(DynamicNearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)

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


# Register DynamicNearestNeighbor3D in _IMP_algebra:
_IMP_algebra.DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
class VectorKDMetric(IMP.Object):
    r"""Proxy of C++ IMP::algebra::VectorKDMetric class."""

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

    def __init__(self, name):
        r"""__init__(VectorKDMetric self, std::string name) -> VectorKDMetric"""
        if self.__class__ == VectorKDMetric:
            _self = None
        else:
            _self = self
        _IMP_algebra.VectorKDMetric_swiginit(self, _IMP_algebra.new_VectorKDMetric(_self, name))

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




    def get_distance(self, a, b):
        r"""get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
        return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)

    def get_centroid(self, vs):
        r"""get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
        return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)

    def __str__(self):
        r"""__str__(VectorKDMetric self) -> std::string"""
        return _IMP_algebra.VectorKDMetric___str__(self)

    def __repr__(self):
        r"""__repr__(VectorKDMetric self) -> std::string"""
        return _IMP_algebra.VectorKDMetric___repr__(self)

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


    def do_show(self, out):
        pass

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

    __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
    def __disown__(self):
        self.this.disown()
        _IMP_algebra.disown_VectorKDMetric(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(VectorKDMetric self)"""
        return _IMP_algebra.VectorKDMetric_do_destroy(self)

# Register VectorKDMetric in _IMP_algebra:
_IMP_algebra.VectorKDMetric_swigregister(VectorKDMetric)
class EuclideanVectorKDMetric(VectorKDMetric):
    r"""Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class."""

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

    def __init__(self, *args):
        r"""__init__(EuclideanVectorKDMetric self, std::string name="EuclideanVectorKDMetric%1%") -> EuclideanVectorKDMetric"""
        _IMP_algebra.EuclideanVectorKDMetric_swiginit(self, _IMP_algebra.new_EuclideanVectorKDMetric(*args))

    def get_version_info(self):
        r"""get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
        return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_EuclideanVectorKDMetric

    def __str__(self):
        r"""__str__(EuclideanVectorKDMetric self) -> std::string"""
        return _IMP_algebra.EuclideanVectorKDMetric___str__(self)

    def __repr__(self):
        r"""__repr__(EuclideanVectorKDMetric self) -> std::string"""
        return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(EuclideanVectorKDMetric self) -> PyObject *"""
        return _IMP_algebra.EuclideanVectorKDMetric__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(EuclideanVectorKDMetric self, PyObject * p)"""
        return _IMP_algebra.EuclideanVectorKDMetric__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register EuclideanVectorKDMetric in _IMP_algebra:
_IMP_algebra.EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
class MaxVectorKDMetric(VectorKDMetric):
    r"""Proxy of C++ IMP::algebra::MaxVectorKDMetric class."""

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

    def __init__(self, *args):
        r"""__init__(MaxVectorKDMetric self, std::string name="MaxVectorKDMetric%1%") -> MaxVectorKDMetric"""
        _IMP_algebra.MaxVectorKDMetric_swiginit(self, _IMP_algebra.new_MaxVectorKDMetric(*args))

    def get_version_info(self):
        r"""get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
        return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_MaxVectorKDMetric

    def __str__(self):
        r"""__str__(MaxVectorKDMetric self) -> std::string"""
        return _IMP_algebra.MaxVectorKDMetric___str__(self)

    def __repr__(self):
        r"""__repr__(MaxVectorKDMetric self) -> std::string"""
        return _IMP_algebra.MaxVectorKDMetric___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(MaxVectorKDMetric self) -> PyObject *"""
        return _IMP_algebra.MaxVectorKDMetric__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(MaxVectorKDMetric self, PyObject * p)"""
        return _IMP_algebra.MaxVectorKDMetric__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register MaxVectorKDMetric in _IMP_algebra:
_IMP_algebra.MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
class Gaussian3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::Gaussian3D class."""

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

    def __init__(self, *args):
        r"""
        __init__(Gaussian3D self) -> Gaussian3D
        __init__(Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
        """
        _IMP_algebra.Gaussian3D_swiginit(self, _IMP_algebra.new_Gaussian3D(*args))

    def get_reference_frame(self):
        r"""get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
        return _IMP_algebra.Gaussian3D_get_reference_frame(self)

    def get_variances(self):
        r"""get_variances(Gaussian3D self) -> Vector3D"""
        return _IMP_algebra.Gaussian3D_get_variances(self)

    def get_center(self):
        r"""get_center(Gaussian3D self) -> Vector3D"""
        return _IMP_algebra.Gaussian3D_get_center(self)

    def show(self, *args):
        r"""show(Gaussian3D self, _ostream out=std::cout)"""
        return _IMP_algebra.Gaussian3D_show(self, *args)

    def __str__(self):
        r"""__str__(Gaussian3D self) -> std::string"""
        return _IMP_algebra.Gaussian3D___str__(self)

    def __repr__(self):
        r"""__repr__(Gaussian3D self) -> std::string"""
        return _IMP_algebra.Gaussian3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Gaussian3D self) -> PyObject *"""
        return _IMP_algebra.Gaussian3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Gaussian3D self, PyObject * p)"""
        return _IMP_algebra.Gaussian3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_Gaussian3D

# Register Gaussian3D in _IMP_algebra:
_IMP_algebra.Gaussian3D_swigregister(Gaussian3D)

def get_covariance(g):
    r"""get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
    return _IMP_algebra.get_covariance(g)

def get_gaussian_from_covariance(covariance, center):
    r"""get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
    return _IMP_algebra.get_gaussian_from_covariance(covariance, center)

def get_rasterized(gmm, weights, cell_width, bb):
    r"""get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D"""
    return _IMP_algebra.get_rasterized(gmm, weights, cell_width, bb)

def get_rasterized_fast(gmm, weights, cell_width, bb, factor=2.5):
    r"""get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb, double factor=2.5) -> DenseDoubleGrid3D"""
    return _IMP_algebra.get_rasterized_fast(gmm, weights, cell_width, bb, factor)

def _pass_matrix_xf(m):
    r"""_pass_matrix_xf(Eigen::MatrixXf const & m) -> Eigen::MatrixXf"""
    return _IMP_algebra._pass_matrix_xf(m)

def _pass_matrix_xd(m):
    r"""_pass_matrix_xd(Eigen::MatrixXd const & m) -> Eigen::MatrixXd"""
    return _IMP_algebra._pass_matrix_xd(m)

def _pass_matrix_3d(m):
    r"""_pass_matrix_3d(Eigen::Matrix3d const & m) -> Eigen::Matrix3d"""
    return _IMP_algebra._pass_matrix_3d(m)

def _pass_array_xd(m):
    r"""_pass_array_xd(Eigen::ArrayXXd const & m) -> Eigen::ArrayXXd"""
    return _IMP_algebra._pass_array_xd(m)

def _pass_vector_xd(m):
    r"""_pass_vector_xd(Eigen::VectorXd const & m) -> Eigen::VectorXd"""
    return _IMP_algebra._pass_vector_xd(m)
class NearestNeighbor1D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 1 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D"""
        _IMP_algebra.NearestNeighbor1D_swiginit(self, _IMP_algebra.new_NearestNeighbor1D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor1D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor1D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor1D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor1D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor1D

    def __str__(self):
        r"""__str__(NearestNeighbor1D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor1D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor1D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor1D___repr__(self)

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


# Register NearestNeighbor1D in _IMP_algebra:
_IMP_algebra.NearestNeighbor1D_swigregister(NearestNeighbor1D)
class NearestNeighbor2D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 2 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D"""
        _IMP_algebra.NearestNeighbor2D_swiginit(self, _IMP_algebra.new_NearestNeighbor2D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor2D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor2D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor2D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor2D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor2D

    def __str__(self):
        r"""__str__(NearestNeighbor2D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor2D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor2D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor2D___repr__(self)

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


# Register NearestNeighbor2D in _IMP_algebra:
_IMP_algebra.NearestNeighbor2D_swigregister(NearestNeighbor2D)
class NearestNeighbor3D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 3 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D"""
        _IMP_algebra.NearestNeighbor3D_swiginit(self, _IMP_algebra.new_NearestNeighbor3D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor3D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor3D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor3D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor3D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor3D

    def __str__(self):
        r"""__str__(NearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor3D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor3D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor3D___repr__(self)

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


# Register NearestNeighbor3D in _IMP_algebra:
_IMP_algebra.NearestNeighbor3D_swigregister(NearestNeighbor3D)
class NearestNeighbor4D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 4 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D"""
        _IMP_algebra.NearestNeighbor4D_swiginit(self, _IMP_algebra.new_NearestNeighbor4D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor4D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor4D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor4D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor4D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor4D

    def __str__(self):
        r"""__str__(NearestNeighbor4D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor4D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor4D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor4D___repr__(self)

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


# Register NearestNeighbor4D in _IMP_algebra:
_IMP_algebra.NearestNeighbor4D_swigregister(NearestNeighbor4D)
class NearestNeighbor5D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 5 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D"""
        _IMP_algebra.NearestNeighbor5D_swiginit(self, _IMP_algebra.new_NearestNeighbor5D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor5D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor5D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor5D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor5D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor5D

    def __str__(self):
        r"""__str__(NearestNeighbor5D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor5D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor5D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor5D___repr__(self)

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


# Register NearestNeighbor5D in _IMP_algebra:
_IMP_algebra.NearestNeighbor5D_swigregister(NearestNeighbor5D)
class NearestNeighbor6D(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< 6 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighbor6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D"""
        _IMP_algebra.NearestNeighbor6D_swiginit(self, _IMP_algebra.new_NearestNeighbor6D(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighbor6D self, std::string fname)"""
        return _IMP_algebra.NearestNeighbor6D_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighbor6D self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighbor6D_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor6D

    def __str__(self):
        r"""__str__(NearestNeighbor6D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor6D___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighbor6D self) -> std::string"""
        return _IMP_algebra.NearestNeighbor6D___repr__(self)

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


# Register NearestNeighbor6D in _IMP_algebra:
_IMP_algebra.NearestNeighbor6D_swigregister(NearestNeighbor6D)
class NearestNeighborKD(IMP.Object):
    r"""Proxy of C++ IMP::algebra::NearestNeighborD< -1 > class."""

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

    def __init__(self, vs, epsilon=0):
        r"""__init__(NearestNeighborKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD"""
        _IMP_algebra.NearestNeighborKD_swiginit(self, _IMP_algebra.new_NearestNeighborKD(vs, epsilon))

    def set_query_log(self, fname):
        r"""set_query_log(NearestNeighborKD self, std::string fname)"""
        return _IMP_algebra.NearestNeighborKD_set_query_log(self, fname)

    def get_nearest_neighbor(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(NearestNeighborKD self) -> VersionInfo"""
        return _IMP_algebra.NearestNeighborKD_get_version_info(self)
    __swig_destroy__ = _IMP_algebra.delete_NearestNeighborKD

    def __str__(self):
        r"""__str__(NearestNeighborKD self) -> std::string"""
        return _IMP_algebra.NearestNeighborKD___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighborKD self) -> std::string"""
        return _IMP_algebra.NearestNeighborKD___repr__(self)

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


# Register NearestNeighborKD in _IMP_algebra:
_IMP_algebra.NearestNeighborKD_swigregister(NearestNeighborKD)

def get_transformation_aligning_pair(set_from, set_to):
    r"""get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
    return _IMP_algebra.get_transformation_aligning_pair(set_from, set_to)
class PrincipalComponentAnalysis1D(IMP._GeometricPrimitive1D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis1D self) -> PrincipalComponentAnalysis1D
        __init__(PrincipalComponentAnalysis1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
        """
        _IMP_algebra.PrincipalComponentAnalysis1D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis1D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis1D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis1D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis1D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D

# Register PrincipalComponentAnalysis1D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
class PrincipalComponentAnalysis2D(IMP._GeometricPrimitive2D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 2 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis2D self) -> PrincipalComponentAnalysis2D
        __init__(PrincipalComponentAnalysis2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
        """
        _IMP_algebra.PrincipalComponentAnalysis2D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis2D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis2D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis2D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis2D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D

# Register PrincipalComponentAnalysis2D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
class PrincipalComponentAnalysis3D(IMP._GeometricPrimitive3D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 3 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis3D self) -> PrincipalComponentAnalysis3D
        __init__(PrincipalComponentAnalysis3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
        """
        _IMP_algebra.PrincipalComponentAnalysis3D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis3D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis3D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis3D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis3D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D

# Register PrincipalComponentAnalysis3D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
class PrincipalComponentAnalysis4D(IMP._GeometricPrimitive4D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 4 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis4D self) -> PrincipalComponentAnalysis4D
        __init__(PrincipalComponentAnalysis4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
        """
        _IMP_algebra.PrincipalComponentAnalysis4D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis4D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis4D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis4D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis4D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D

# Register PrincipalComponentAnalysis4D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
class PrincipalComponentAnalysis5D(IMP._GeometricPrimitive5D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 5 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis5D self) -> PrincipalComponentAnalysis5D
        __init__(PrincipalComponentAnalysis5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
        """
        _IMP_algebra.PrincipalComponentAnalysis5D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis5D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis5D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis5D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis5D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D

# Register PrincipalComponentAnalysis5D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
class PrincipalComponentAnalysis6D(IMP._GeometricPrimitive6D):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 6 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysis6D self) -> PrincipalComponentAnalysis6D
        __init__(PrincipalComponentAnalysis6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
        """
        _IMP_algebra.PrincipalComponentAnalysis6D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis6D(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysis6D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysis6D self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysis6D__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D

# Register PrincipalComponentAnalysis6D in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
class PrincipalComponentAnalysisKD(IMP._GeometricPrimitiveKD):
    r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< -1 > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrincipalComponentAnalysisKD self) -> PrincipalComponentAnalysisKD
        __init__(PrincipalComponentAnalysisKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
        """
        _IMP_algebra.PrincipalComponentAnalysisKD_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysisKD(*args))

    def get_principal_components(self):
        r"""get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)

    def get_principal_component(self, i):
        r"""get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, i)

    def get_principal_values(self):
        r"""get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)

    def get_principal_value(self, i):
        r"""get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, i)

    def get_centroid(self):
        r"""get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)

    def set_centroid(self, cntr):
        r"""set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)

    def show(self, *args):
        r"""show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)"""
        return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)

    def __eq__(self, o):
        r"""__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)

    def __le__(self, o):
        r"""__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)

    def __str__(self):
        r"""__str__(PrincipalComponentAnalysisKD self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)

    def __repr__(self):
        r"""__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
        return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
        return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PrincipalComponentAnalysisKD self, PyObject * p)"""
        return _IMP_algebra.PrincipalComponentAnalysisKD__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD

# Register PrincipalComponentAnalysisKD in _IMP_algebra:
_IMP_algebra.PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)

def get_principal_components(*args):
    r"""
    get_principal_components(IMP::Vector< IMP::Vector1D,std::allocator< IMP::Vector1D > > const & a) -> PrincipalComponentAnalysis1D
    get_principal_components(IMP::Vector< IMP::Vector2D,std::allocator< IMP::Vector2D > > const & a) -> PrincipalComponentAnalysis2D
    get_principal_components(IMP::Vector< IMP::Vector3D,std::allocator< IMP::Vector3D > > const & a) -> PrincipalComponentAnalysis3D
    get_principal_components(IMP::Vector< IMP::Vector4D,std::allocator< IMP::Vector4D > > const & a) -> PrincipalComponentAnalysis4D
    get_principal_components(IMP::Vector< IMP::Vector5D,std::allocator< IMP::Vector5D > > const & a) -> PrincipalComponentAnalysis5D
    get_principal_components(IMP::Vector< IMP::Vector6D,std::allocator< IMP::Vector6D > > const & a) -> PrincipalComponentAnalysis6D
    get_principal_components(IMP::Vector< IMP::VectorKD,std::allocator< IMP::VectorKD > > const & a) -> PrincipalComponentAnalysisKD
    """
    return _IMP_algebra.get_principal_components(*args)

def get_distance(*args):
    r"""
    get_distance()
    get_distance(Rotation3D r0, Rotation3D r1) -> double
    get_distance(Line3D s, Vector3D p) -> double
    get_distance(Line3D a, Line3D b) -> 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):
    r"""
    get_squared_distance()
    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_unit_bounding_box_1d():
    r"""get_unit_bounding_box_1d() -> BoundingBox1D"""
    return _IMP_algebra.get_unit_bounding_box_1d()

def get_unit_bounding_box_2d():
    r"""get_unit_bounding_box_2d() -> BoundingBox2D"""
    return _IMP_algebra.get_unit_bounding_box_2d()

def get_unit_bounding_box_3d():
    r"""get_unit_bounding_box_3d() -> BoundingBox3D"""
    return _IMP_algebra.get_unit_bounding_box_3d()

def get_unit_bounding_box_4d():
    r"""get_unit_bounding_box_4d() -> BoundingBox4D"""
    return _IMP_algebra.get_unit_bounding_box_4d()

def get_unit_bounding_box_5d():
    r"""get_unit_bounding_box_5d() -> BoundingBox5D"""
    return _IMP_algebra.get_unit_bounding_box_5d()

def get_unit_bounding_box_6d():
    r"""get_unit_bounding_box_6d() -> BoundingBox6D"""
    return _IMP_algebra.get_unit_bounding_box_6d()

def get_cube_1d(radius):
    r"""get_cube_1d(double radius) -> BoundingBox1D"""
    return _IMP_algebra.get_cube_1d(radius)

def get_cube_2d(radius):
    r"""get_cube_2d(double radius) -> BoundingBox2D"""
    return _IMP_algebra.get_cube_2d(radius)

def get_cube_3d(radius):
    r"""get_cube_3d(double radius) -> BoundingBox3D"""
    return _IMP_algebra.get_cube_3d(radius)

def get_cube_4d(radius):
    r"""get_cube_4d(double radius) -> BoundingBox4D"""
    return _IMP_algebra.get_cube_4d(radius)

def get_cube_5d(radius):
    r"""get_cube_5d(double radius) -> BoundingBox5D"""
    return _IMP_algebra.get_cube_5d(radius)

def get_cube_6d(radius):
    r"""get_cube_6d(double radius) -> BoundingBox6D"""
    return _IMP_algebra.get_cube_6d(radius)

def get_unit_sphere_1d():
    r"""get_unit_sphere_1d() -> Sphere1D"""
    return _IMP_algebra.get_unit_sphere_1d()

def get_unit_sphere_2d():
    r"""get_unit_sphere_2d() -> Sphere2D"""
    return _IMP_algebra.get_unit_sphere_2d()

def get_unit_sphere_3d():
    r"""get_unit_sphere_3d() -> Sphere3D"""
    return _IMP_algebra.get_unit_sphere_3d()

def get_unit_sphere_4d():
    r"""get_unit_sphere_4d() -> Sphere4D"""
    return _IMP_algebra.get_unit_sphere_4d()

def get_unit_sphere_5d():
    r"""get_unit_sphere_5d() -> Sphere5D"""
    return _IMP_algebra.get_unit_sphere_5d()

def get_unit_sphere_6d():
    r"""get_unit_sphere_6d() -> Sphere6D"""
    return _IMP_algebra.get_unit_sphere_6d()

def get_interiors_intersect(*args):
    r"""
    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):
    r"""
    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(UnitSimplex1D a) -> Vector1D
    get_random_vector_on(UnitSimplex2D a) -> Vector2D
    get_random_vector_on(UnitSimplex3D a) -> Vector3D
    get_random_vector_on(UnitSimplex4D a) -> Vector4D
    get_random_vector_on(UnitSimplex5D a) -> Vector5D
    get_random_vector_on(UnitSimplex6D a) -> Vector6D
    get_random_vector_on(UnitSimplexKD 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):
    r"""
    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):
    r"""
    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):
    r"""
    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):
    r"""
    get_bounding_box(Line3D g) -> BoundingBox3D
    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):
    r"""
    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):
    r"""
    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)

def get_projected(*args):
    r"""
    get_projected(Line3D l, Vector3D p) -> Vector3D
    get_projected(Line3D l, Segment3D s) -> Segment3D
    get_projected(UnitSimplex1D a, Vector1D b) -> Vector1D
    get_projected(UnitSimplex2D a, Vector2D b) -> Vector2D
    get_projected(UnitSimplex3D a, Vector3D b) -> Vector3D
    get_projected(UnitSimplex4D a, Vector4D b) -> Vector4D
    get_projected(UnitSimplex5D a, Vector5D b) -> Vector5D
    get_projected(UnitSimplex6D a, Vector6D b) -> Vector6D
    get_projected(UnitSimplexKD a, VectorKD b) -> VectorKD
    """
    return _IMP_algebra.get_projected(*args)

def get_vertices(*args):
    r"""
    get_vertices(BoundingBox1D a) -> IMP::Vector< IMP::Vector1D,std::allocator< IMP::Vector1D > >
    get_vertices(BoundingBox2D a) -> IMP::Vector< IMP::Vector2D,std::allocator< IMP::Vector2D > >
    get_vertices(BoundingBox3D a) -> IMP::Vector< IMP::Vector3D,std::allocator< IMP::Vector3D > >
    get_vertices(BoundingBox4D a) -> IMP::Vector< IMP::Vector4D,std::allocator< IMP::Vector4D > >
    get_vertices(BoundingBox5D a) -> IMP::Vector< IMP::Vector5D,std::allocator< IMP::Vector5D > >
    get_vertices(BoundingBox6D a) -> IMP::Vector< IMP::Vector6D,std::allocator< IMP::Vector6D > >
    get_vertices(BoundingBoxKD a) -> IMP::Vector< IMP::VectorKD,std::allocator< IMP::VectorKD > >
    get_vertices(UnitSimplex1D a) -> IMP::Vector< IMP::Vector1D,std::allocator< IMP::Vector1D > >
    get_vertices(UnitSimplex2D a) -> IMP::Vector< IMP::Vector2D,std::allocator< IMP::Vector2D > >
    get_vertices(UnitSimplex3D a) -> IMP::Vector< IMP::Vector3D,std::allocator< IMP::Vector3D > >
    get_vertices(UnitSimplex4D a) -> IMP::Vector< IMP::Vector4D,std::allocator< IMP::Vector4D > >
    get_vertices(UnitSimplex5D a) -> IMP::Vector< IMP::Vector5D,std::allocator< IMP::Vector5D > >
    get_vertices(UnitSimplex6D a) -> IMP::Vector< IMP::Vector6D,std::allocator< IMP::Vector6D > >
    get_vertices(UnitSimplexKD a) -> IMP::Vector< IMP::VectorKD,std::allocator< IMP::VectorKD > >
    """
    return _IMP_algebra.get_vertices(*args)

def get_increasing_from_embedded(*args):
    r"""
    get_increasing_from_embedded(UnitSimplex1D a, Vector1D b) -> Vector1D
    get_increasing_from_embedded(UnitSimplex2D a, Vector2D b) -> Vector2D
    get_increasing_from_embedded(UnitSimplex3D a, Vector3D b) -> Vector3D
    get_increasing_from_embedded(UnitSimplex4D a, Vector4D b) -> Vector4D
    get_increasing_from_embedded(UnitSimplex5D a, Vector5D b) -> Vector5D
    get_increasing_from_embedded(UnitSimplex6D a, Vector6D b) -> Vector6D
    get_increasing_from_embedded(UnitSimplexKD a, VectorKD b) -> VectorKD
    """
    return _IMP_algebra.get_increasing_from_embedded(*args)

def get_embedded_from_increasing(*args):
    r"""
    get_embedded_from_increasing(UnitSimplex1D a, Vector1D b) -> Vector1D
    get_embedded_from_increasing(UnitSimplex2D a, Vector2D b) -> Vector2D
    get_embedded_from_increasing(UnitSimplex3D a, Vector3D b) -> Vector3D
    get_embedded_from_increasing(UnitSimplex4D a, Vector4D b) -> Vector4D
    get_embedded_from_increasing(UnitSimplex5D a, Vector5D b) -> Vector5D
    get_embedded_from_increasing(UnitSimplex6D a, Vector6D b) -> Vector6D
    get_embedded_from_increasing(UnitSimplexKD a, VectorKD b) -> VectorKD
    """
    return _IMP_algebra.get_embedded_from_increasing(*args)
class _AxisAnglePair(object):
    r"""Proxy of C++ std::pair< IMP::VectorD< 3 >,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_AxisAnglePair self) -> _AxisAnglePair
        __init__(_AxisAnglePair self, Vector3D first, double second) -> _AxisAnglePair
        __init__(_AxisAnglePair self, _AxisAnglePair other) -> _AxisAnglePair
        """
        _IMP_algebra._AxisAnglePair_swiginit(self, _IMP_algebra.new__AxisAnglePair(*args))
    first = property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set, doc=r"""first : IMP::VectorD<(3)>""")
    second = property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set, doc=r"""second : double""")
    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

# Register _AxisAnglePair in _IMP_algebra:
_IMP_algebra._AxisAnglePair_swigregister(_AxisAnglePair)

def get_transformation_aligning_first_to_second(source, target):
    r"""get_transformation_aligning_first_to_second(IMP::Vector< IMP::VectorD< 3 >,std::allocator< IMP::VectorD< 3 > > > const & source, IMP::Vector< IMP::VectorD< 3 >,std::allocator< IMP::VectorD< 3 > > > const & target) -> Transformation3D"""
    return _IMP_algebra.get_transformation_aligning_first_to_second(source, target)
class _RotatedVector3DAdjoint(object):
    r"""Proxy of C++ std::pair< IMP::VectorD< 3 >,IMP::VectorD< 4 > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_RotatedVector3DAdjoint self) -> _RotatedVector3DAdjoint
        __init__(_RotatedVector3DAdjoint self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
        __init__(_RotatedVector3DAdjoint self, _RotatedVector3DAdjoint other) -> _RotatedVector3DAdjoint
        """
        _IMP_algebra._RotatedVector3DAdjoint_swiginit(self, _IMP_algebra.new__RotatedVector3DAdjoint(*args))
    first = property(_IMP_algebra._RotatedVector3DAdjoint_first_get, _IMP_algebra._RotatedVector3DAdjoint_first_set, doc=r"""first : IMP::VectorD<(3)>""")
    second = property(_IMP_algebra._RotatedVector3DAdjoint_second_get, _IMP_algebra._RotatedVector3DAdjoint_second_set, doc=r"""second : IMP::VectorD<(4)>""")
    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__RotatedVector3DAdjoint

# Register _RotatedVector3DAdjoint in _IMP_algebra:
_IMP_algebra._RotatedVector3DAdjoint_swigregister(_RotatedVector3DAdjoint)
class _ComposeRotation3DAdjoint(object):
    r"""Proxy of C++ std::pair< IMP::VectorD< 4 >,IMP::VectorD< 4 > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_ComposeRotation3DAdjoint self) -> _ComposeRotation3DAdjoint
        __init__(_ComposeRotation3DAdjoint self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
        __init__(_ComposeRotation3DAdjoint self, _ComposeRotation3DAdjoint other) -> _ComposeRotation3DAdjoint
        """
        _IMP_algebra._ComposeRotation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeRotation3DAdjoint(*args))
    first = property(_IMP_algebra._ComposeRotation3DAdjoint_first_get, _IMP_algebra._ComposeRotation3DAdjoint_first_set, doc=r"""first : IMP::VectorD<(4)>""")
    second = property(_IMP_algebra._ComposeRotation3DAdjoint_second_get, _IMP_algebra._ComposeRotation3DAdjoint_second_set, doc=r"""second : IMP::VectorD<(4)>""")
    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__ComposeRotation3DAdjoint

# Register _ComposeRotation3DAdjoint in _IMP_algebra:
_IMP_algebra._ComposeRotation3DAdjoint_swigregister(_ComposeRotation3DAdjoint)
class _Transformation3DAdjoint(object):
    r"""Proxy of C++ std::pair< IMP::VectorD< 4 >,IMP::VectorD< 3 > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_Transformation3DAdjoint self) -> _Transformation3DAdjoint
        __init__(_Transformation3DAdjoint self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
        __init__(_Transformation3DAdjoint self, _Transformation3DAdjoint other) -> _Transformation3DAdjoint
        """
        _IMP_algebra._Transformation3DAdjoint_swiginit(self, _IMP_algebra.new__Transformation3DAdjoint(*args))
    first = property(_IMP_algebra._Transformation3DAdjoint_first_get, _IMP_algebra._Transformation3DAdjoint_first_set, doc=r"""first : IMP::VectorD<(4)>""")
    second = property(_IMP_algebra._Transformation3DAdjoint_second_get, _IMP_algebra._Transformation3DAdjoint_second_set, doc=r"""second : IMP::VectorD<(3)>""")
    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__Transformation3DAdjoint

# Register _Transformation3DAdjoint in _IMP_algebra:
_IMP_algebra._Transformation3DAdjoint_swigregister(_Transformation3DAdjoint)
class _TransformedVector3DAdjoint(object):
    r"""Proxy of C++ std::pair< IMP::VectorD< 3 >,std::pair< IMP::VectorD< 4 >,IMP::VectorD< 3 > > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_TransformedVector3DAdjoint self) -> _TransformedVector3DAdjoint
        __init__(_TransformedVector3DAdjoint self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
        __init__(_TransformedVector3DAdjoint self, _TransformedVector3DAdjoint other) -> _TransformedVector3DAdjoint
        """
        _IMP_algebra._TransformedVector3DAdjoint_swiginit(self, _IMP_algebra.new__TransformedVector3DAdjoint(*args))
    first = property(_IMP_algebra._TransformedVector3DAdjoint_first_get, _IMP_algebra._TransformedVector3DAdjoint_first_set, doc=r"""first : IMP::VectorD<(3)>""")
    second = property(_IMP_algebra._TransformedVector3DAdjoint_second_get, _IMP_algebra._TransformedVector3DAdjoint_second_set, doc=r"""second : std::pair<(IMP::VectorD<(4)>,IMP::VectorD<(3)>)>""")
    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__TransformedVector3DAdjoint

# Register _TransformedVector3DAdjoint in _IMP_algebra:
_IMP_algebra._TransformedVector3DAdjoint_swigregister(_TransformedVector3DAdjoint)
class _ComposeTransformation3DAdjoint(object):
    r"""Proxy of C++ std::pair< std::pair< IMP::VectorD< 4 >,IMP::VectorD< 3 > >,std::pair< IMP::VectorD< 4 >,IMP::VectorD< 3 > > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_ComposeTransformation3DAdjoint self) -> _ComposeTransformation3DAdjoint
        __init__(_ComposeTransformation3DAdjoint self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
        __init__(_ComposeTransformation3DAdjoint self, _ComposeTransformation3DAdjoint other) -> _ComposeTransformation3DAdjoint
        """
        _IMP_algebra._ComposeTransformation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeTransformation3DAdjoint(*args))
    first = property(_IMP_algebra._ComposeTransformation3DAdjoint_first_get, _IMP_algebra._ComposeTransformation3DAdjoint_first_set, doc=r"""first : std::pair<(IMP::VectorD<(4)>,IMP::VectorD<(3)>)>""")
    second = property(_IMP_algebra._ComposeTransformation3DAdjoint_second_get, _IMP_algebra._ComposeTransformation3DAdjoint_second_set, doc=r"""second : std::pair<(IMP::VectorD<(4)>,IMP::VectorD<(3)>)>""")
    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__ComposeTransformation3DAdjoint

# Register _ComposeTransformation3DAdjoint in _IMP_algebra:
_IMP_algebra._ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)

def get_rmsd_transforming_first(tr, v0, v1):
    r"""get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
    return _IMP_algebra.get_rmsd_transforming_first(tr, v0, v1)

def get_rmsd(v0, v1):
    r"""get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
    return _IMP_algebra.get_rmsd(v0, v1)

def get_weighted_rmsd_transforming_first(tr, v0, v1, weights):
    r"""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(tr, v0, v1, weights)

def get_weighted_rmsd(v0, v1, weights):
    r"""get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
    return _IMP_algebra.get_weighted_rmsd(v0, v1, weights)

LinearFit=LinearFit2D
ParabolicFit=ParabolicFit2D


def __setup_vector_d_aliases():
    for n in "123456K":
        for func in ('get_basis_vector', 'get_zero_vector',
                     'get_ones_vector'):
            funcname = func + "_" + n.lower() + 'd'
            globals()[funcname] = getattr(IMP, funcname)
        for cls in ('Vector' + n + 'D', 'Vector' + n + 'Ds'):
            globals()[cls] = getattr(IMP, cls)

__setup_vector_d_aliases()

get_vector_product = IMP.get_vector_product
get_orthogonal_vector = IMP.get_orthogonal_vector
get_centroid = IMP.get_centroid
get_radius_of_gyration = IMP.get_radius_of_gyration


def get_module_name():
    r"""get_module_name() -> std::string const"""
    return _IMP_algebra.get_module_name()

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

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

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

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