kinematics/__init__.py

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





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

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

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

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

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


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


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

    def incr(self, n=1):
        """
        incr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        incr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        decr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator
        __sub__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_KINEMATICS_SwigPyIterator_swigregister = _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_swigregister
IMP_KINEMATICS_SwigPyIterator_swigregister(IMP_KINEMATICS_SwigPyIterator)

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

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

DEFAULT_CHECK = _IMP_kinematics.DEFAULT_CHECK
NONE = _IMP_kinematics.NONE
USAGE = _IMP_kinematics.USAGE
USAGE_AND_INTERNAL = _IMP_kinematics.USAGE_AND_INTERNAL

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

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

_ostream_swigregister = _IMP_kinematics._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_kinematics.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_kinematics.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_kinematics.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_kinematics.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_kinematics.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_kinematics.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_kinematics.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_kinematics.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_kinematics.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_kinematics.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_kinematics.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_CGAL
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_kinematics.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_CORE_HAS_IMP_BASE = _IMP_kinematics.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_kinematics.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_kinematics.IMP_CORE_HAS_CGAL
IMPCORE_SHOW_WARNINGS = _IMP_kinematics.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_CGAL
IMPCONTAINER_SHOW_WARNINGS = _IMP_kinematics.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_kinematics.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_kinematics.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_kinematics.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_kinematics.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_kinematics.IMP_ATOM_HAS_CGAL
IMPATOM_SHOW_WARNINGS = _IMP_kinematics.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_kinematics.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_kinematics.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_kinematics.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_KINEMATICS_HAS_IMP_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_CGAL
IMP_KINEMATICS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_DISPLAY
IMP_KINEMATICS_HAS_IMP_KERNEL = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_KERNEL
IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR
IMP_KINEMATICS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_FILESYSTEM
IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS
IMP_KINEMATICS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_RANDOM
IMP_KINEMATICS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_REGEX
IMP_KINEMATICS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_SYSTEM
IMP_KINEMATICS_HAS_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_CGAL
IMPKINEMATICS_SHOW_WARNINGS = _IMP_kinematics.IMPKINEMATICS_SHOW_WARNINGS
class VectorOfDoubles(_object):
    """Proxy of C++ std::vector<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorOfDoubles, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VectorOfDoubles, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(VectorOfDoubles self) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.VectorOfDoubles_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(VectorOfDoubles self) -> bool"""
        return _IMP_kinematics.VectorOfDoubles___nonzero__(self)

    def __bool__(self):
        """__bool__(VectorOfDoubles self) -> bool"""
        return _IMP_kinematics.VectorOfDoubles___bool__(self)

    def __len__(self):
        """__len__(VectorOfDoubles self) -> std::vector< double >::size_type"""
        return _IMP_kinematics.VectorOfDoubles___len__(self)

    def pop(self):
        """pop(VectorOfDoubles self) -> std::vector< double >::value_type"""
        return _IMP_kinematics.VectorOfDoubles_pop(self)

    def __getslice__(self, *args):
        """__getslice__(VectorOfDoubles self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> VectorOfDoubles"""
        return _IMP_kinematics.VectorOfDoubles___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(VectorOfDoubles self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, 
            VectorOfDoubles v=std::vector< double,std::allocator< double > >())
        __setslice__(VectorOfDoubles self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        """
        return _IMP_kinematics.VectorOfDoubles___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(VectorOfDoubles self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _IMP_kinematics.VectorOfDoubles___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(VectorOfDoubles self, std::vector< double >::difference_type i)
        __delitem__(VectorOfDoubles self, PySliceObject * slice)
        """
        return _IMP_kinematics.VectorOfDoubles___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(VectorOfDoubles self, PySliceObject * slice) -> VectorOfDoubles
        __getitem__(VectorOfDoubles self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _IMP_kinematics.VectorOfDoubles___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(VectorOfDoubles self, PySliceObject * slice, VectorOfDoubles v)
        __setitem__(VectorOfDoubles self, PySliceObject * slice)
        __setitem__(VectorOfDoubles self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _IMP_kinematics.VectorOfDoubles___setitem__(self, *args)

    def append(self, *args):
        """append(VectorOfDoubles self, std::vector< double >::value_type const & x)"""
        return _IMP_kinematics.VectorOfDoubles_append(self, *args)

    def empty(self):
        """empty(VectorOfDoubles self) -> bool"""
        return _IMP_kinematics.VectorOfDoubles_empty(self)

    def size(self):
        """size(VectorOfDoubles self) -> std::vector< double >::size_type"""
        return _IMP_kinematics.VectorOfDoubles_size(self)

    def clear(self):
        """clear(VectorOfDoubles self)"""
        return _IMP_kinematics.VectorOfDoubles_clear(self)

    def swap(self, *args):
        """swap(VectorOfDoubles self, VectorOfDoubles v)"""
        return _IMP_kinematics.VectorOfDoubles_swap(self, *args)

    def get_allocator(self):
        """get_allocator(VectorOfDoubles self) -> std::vector< double >::allocator_type"""
        return _IMP_kinematics.VectorOfDoubles_get_allocator(self)

    def begin(self):
        """begin(VectorOfDoubles self) -> std::vector< double >::iterator"""
        return _IMP_kinematics.VectorOfDoubles_begin(self)

    def end(self):
        """end(VectorOfDoubles self) -> std::vector< double >::iterator"""
        return _IMP_kinematics.VectorOfDoubles_end(self)

    def rbegin(self):
        """rbegin(VectorOfDoubles self) -> std::vector< double >::reverse_iterator"""
        return _IMP_kinematics.VectorOfDoubles_rbegin(self)

    def rend(self):
        """rend(VectorOfDoubles self) -> std::vector< double >::reverse_iterator"""
        return _IMP_kinematics.VectorOfDoubles_rend(self)

    def pop_back(self):
        """pop_back(VectorOfDoubles self)"""
        return _IMP_kinematics.VectorOfDoubles_pop_back(self)

    def erase(self, *args):
        """
        erase(VectorOfDoubles self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(VectorOfDoubles self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _IMP_kinematics.VectorOfDoubles_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(double)> self) -> VectorOfDoubles
        __init__(std::vector<(double)> self, VectorOfDoubles arg2) -> VectorOfDoubles
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> VectorOfDoubles
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> VectorOfDoubles
        """
        this = _IMP_kinematics.new_VectorOfDoubles(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(VectorOfDoubles self, std::vector< double >::value_type const & x)"""
        return _IMP_kinematics.VectorOfDoubles_push_back(self, *args)

    def front(self):
        """front(VectorOfDoubles self) -> std::vector< double >::value_type const &"""
        return _IMP_kinematics.VectorOfDoubles_front(self)

    def back(self):
        """back(VectorOfDoubles self) -> std::vector< double >::value_type const &"""
        return _IMP_kinematics.VectorOfDoubles_back(self)

    def assign(self, *args):
        """assign(VectorOfDoubles self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _IMP_kinematics.VectorOfDoubles_assign(self, *args)

    def resize(self, *args):
        """
        resize(VectorOfDoubles self, std::vector< double >::size_type new_size)
        resize(VectorOfDoubles self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _IMP_kinematics.VectorOfDoubles_resize(self, *args)

    def insert(self, *args):
        """
        insert(VectorOfDoubles self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(VectorOfDoubles self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _IMP_kinematics.VectorOfDoubles_insert(self, *args)

    def reserve(self, *args):
        """reserve(VectorOfDoubles self, std::vector< double >::size_type n)"""
        return _IMP_kinematics.VectorOfDoubles_reserve(self, *args)

    def capacity(self):
        """capacity(VectorOfDoubles self) -> std::vector< double >::size_type"""
        return _IMP_kinematics.VectorOfDoubles_capacity(self)

    __swig_destroy__ = _IMP_kinematics.delete_VectorOfDoubles
    __del__ = lambda self : None;
VectorOfDoubles_swigregister = _IMP_kinematics.VectorOfDoubles_swigregister
VectorOfDoubles_swigregister(VectorOfDoubles)

_object_types.append("Joint")


def _object_cast_to_Joint(*args):
  """_object_cast_to_Joint(Object o) -> Joint"""
  return _IMP_kinematics._object_cast_to_Joint(*args)
_object_types.append("TransformationJoint")


def _object_cast_to_TransformationJoint(*args):
  """_object_cast_to_TransformationJoint(Object o) -> TransformationJoint"""
  return _IMP_kinematics._object_cast_to_TransformationJoint(*args)
_object_types.append("RevoluteJoint")


def _object_cast_to_RevoluteJoint(*args):
  """_object_cast_to_RevoluteJoint(Object o) -> RevoluteJoint"""
  return _IMP_kinematics._object_cast_to_RevoluteJoint(*args)
_object_types.append("DihedralAngleRevoluteJoint")


def _object_cast_to_DihedralAngleRevoluteJoint(*args):
  """_object_cast_to_DihedralAngleRevoluteJoint(Object o) -> DihedralAngleRevoluteJoint"""
  return _IMP_kinematics._object_cast_to_DihedralAngleRevoluteJoint(*args)
_object_types.append("BondAngleRevoluteJoint")


def _object_cast_to_BondAngleRevoluteJoint(*args):
  """_object_cast_to_BondAngleRevoluteJoint(Object o) -> BondAngleRevoluteJoint"""
  return _IMP_kinematics._object_cast_to_BondAngleRevoluteJoint(*args)
_object_types.append("PrismaticJoint")


def _object_cast_to_PrismaticJoint(*args):
  """_object_cast_to_PrismaticJoint(Object o) -> PrismaticJoint"""
  return _IMP_kinematics._object_cast_to_PrismaticJoint(*args)
_object_types.append("KinematicForest")


def _object_cast_to_KinematicForest(*args):
  """_object_cast_to_KinematicForest(Object o) -> KinematicForest"""
  return _IMP_kinematics._object_cast_to_KinematicForest(*args)
_object_types.append("CompositeJoint")


def _object_cast_to_CompositeJoint(*args):
  """_object_cast_to_CompositeJoint(Object o) -> CompositeJoint"""
  return _IMP_kinematics._object_cast_to_CompositeJoint(*args)
_object_types.append("DOF")


def _object_cast_to_DOF(*args):
  """_object_cast_to_DOF(Object o) -> DOF"""
  return _IMP_kinematics._object_cast_to_DOF(*args)
DOFValuesList=list
_plural_types.append("DOFValuesList")
_value_types.append("DOFValues")

DirectionalDOFs=list
_plural_types.append("DirectionalDOFs")
_value_types.append("DirectionalDOF")

_object_types.append("DOFsSampler")


def _object_cast_to_DOFsSampler(*args):
  """_object_cast_to_DOFsSampler(Object o) -> DOFsSampler"""
  return _IMP_kinematics._object_cast_to_DOFsSampler(*args)
_object_types.append("UniformBackboneSampler")


def _object_cast_to_UniformBackboneSampler(*args):
  """_object_cast_to_UniformBackboneSampler(Object o) -> UniformBackboneSampler"""
  return _IMP_kinematics._object_cast_to_UniformBackboneSampler(*args)
class Joint(IMP.base.Object):
    """Proxy of C++ IMP::kinematics::Joint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Joint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Joint, name)
    def get_version_info(self):
        """get_version_info(Joint self) -> VersionInfo"""
        return _IMP_kinematics.Joint_get_version_info(self)

    __swig_destroy__ = _IMP_kinematics.delete_Joint
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::kinematics::Joint self, RigidBody parent, RigidBody child) -> Joint"""
        this = _IMP_kinematics.new_Joint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_owner_kf(self):
        """get_owner_kf(Joint self) -> KinematicForest"""
        return _IMP_kinematics.Joint_get_owner_kf(self)

    def get_transformation_child_to_parent(self):
        """get_transformation_child_to_parent(Joint self) -> Transformation3D"""
        return _IMP_kinematics.Joint_get_transformation_child_to_parent(self)

    def get_parent_node(self):
        """get_parent_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_parent_node(self)

    def get_child_node(self):
        """get_child_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_child_node(self)

    def __str__(self):
        """__str__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___str__(self)

    def __repr__(self):
        """__repr__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___repr__(self)

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

Joint_swigregister = _IMP_kinematics.Joint_swigregister
Joint_swigregister(Joint)

class TransformationJoint(Joint):
    """Proxy of C++ IMP::kinematics::TransformationJoint class"""
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformationJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransformationJoint, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::TransformationJoint self, RigidBody parent, RigidBody child) -> TransformationJoint"""
        this = _IMP_kinematics.new_TransformationJoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_transformation_child_to_parent(self, *args):
        """set_transformation_child_to_parent(TransformationJoint self, Transformation3D transformation)"""
        return _IMP_kinematics.TransformationJoint_set_transformation_child_to_parent(self, *args)

    def __str__(self):
        """__str__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___str__(self)

    def __repr__(self):
        """__repr__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_TransformationJoint
    __del__ = lambda self : None;
TransformationJoint_swigregister = _IMP_kinematics.TransformationJoint_swigregister
TransformationJoint_swigregister(TransformationJoint)

class PrismaticJoint(Joint):
    """Proxy of C++ IMP::kinematics::PrismaticJoint class"""
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrismaticJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PrismaticJoint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b) -> PrismaticJoint
        __init__(IMP::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child) -> PrismaticJoint
        """
        this = _IMP_kinematics.new_PrismaticJoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_length(self):
        """get_length(PrismaticJoint self) -> double"""
        return _IMP_kinematics.PrismaticJoint_get_length(self)

    def set_length(self, *args):
        """set_length(PrismaticJoint self, double l)"""
        return _IMP_kinematics.PrismaticJoint_set_length(self, *args)

    def __str__(self):
        """__str__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___str__(self)

    def __repr__(self):
        """__repr__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_PrismaticJoint
    __del__ = lambda self : None;
PrismaticJoint_swigregister = _IMP_kinematics.PrismaticJoint_swigregister
PrismaticJoint_swigregister(PrismaticJoint)

class CompositeJoint(Joint):
    """Proxy of C++ IMP::kinematics::CompositeJoint class"""
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompositeJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompositeJoint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kinematics::CompositeJoint self, RigidBody parent, RigidBody child, IMP::kinematics::Joints joints=IMP::kinematics::Joints()) -> CompositeJoint
        __init__(IMP::kinematics::CompositeJoint self, RigidBody parent, RigidBody child) -> CompositeJoint
        """
        this = _IMP_kinematics.new_CompositeJoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_downstream_joint(self, *args):
        """add_downstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_downstream_joint(self, *args)

    def add_upstream_joint(self, *args):
        """add_upstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_upstream_joint(self, *args)

    def set_joints(self, *args):
        """set_joints(CompositeJoint self, IMP::kinematics::Joints joints)"""
        return _IMP_kinematics.CompositeJoint_set_joints(self, *args)

    def get_inner_joints(self):
        """get_inner_joints(CompositeJoint self) -> IMP::kinematics::Joints const &"""
        return _IMP_kinematics.CompositeJoint_get_inner_joints(self)

    def __str__(self):
        """__str__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___str__(self)

    def __repr__(self):
        """__repr__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_CompositeJoint
    __del__ = lambda self : None;
CompositeJoint_swigregister = _IMP_kinematics.CompositeJoint_swigregister
CompositeJoint_swigregister(CompositeJoint)

class RevoluteJoint(Joint):
    """Proxy of C++ IMP::kinematics::RevoluteJoint class"""
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RevoluteJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RevoluteJoint, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::RevoluteJoint self, RigidBody parent, RigidBody child) -> RevoluteJoint"""
        if self.__class__ == RevoluteJoint:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_RevoluteJoint(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != RevoluteJoint:
            import IMP.base
            IMP.base._director_objects.register(self)



    __swig_destroy__ = _IMP_kinematics.delete_RevoluteJoint
    __del__ = lambda self : None;
    def set_angle(self, *args):
        """set_angle(RevoluteJoint self, double angle)"""
        return _IMP_kinematics.RevoluteJoint_set_angle(self, *args)

    def get_angle(self):
        """get_angle(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_angle(self)

    def get_rot_axis_origin(self):
        """get_rot_axis_origin(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_origin(self)

    def get_rot_axis_unit_vector(self):
        """get_rot_axis_unit_vector(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_unit_vector(self)

    def update_child_node_reference_frame(self):
        """update_child_node_reference_frame(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_child_node_reference_frame(self)

    def update_axis_of_rotation_from_cartesian_witnesses(self):
        """update_axis_of_rotation_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_axis_of_rotation_from_cartesian_witnesses(self)

    def get_current_angle_from_cartesian_witnesses(self):
        """get_current_angle_from_cartesian_witnesses(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_current_angle_from_cartesian_witnesses(self)

    def update_joint_from_cartesian_witnesses(self):
        """update_joint_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_joint_from_cartesian_witnesses(self)

    def get_rotation_about_joint_in_parent_coordinates(self):
        """get_rotation_about_joint_in_parent_coordinates(RevoluteJoint self) -> Transformation3D"""
        return _IMP_kinematics.RevoluteJoint_get_rotation_about_joint_in_parent_coordinates(self)

    __swig_setmethods__["angle_"] = _IMP_kinematics.RevoluteJoint_angle__set
    __swig_getmethods__["angle_"] = _IMP_kinematics.RevoluteJoint_angle__get
    if _newclass:angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_angle__get, _IMP_kinematics.RevoluteJoint_angle__set)
    __swig_setmethods__["last_updated_angle_"] = _IMP_kinematics.RevoluteJoint_last_updated_angle__set
    __swig_getmethods__["last_updated_angle_"] = _IMP_kinematics.RevoluteJoint_last_updated_angle__get
    if _newclass:last_updated_angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_last_updated_angle__get, _IMP_kinematics.RevoluteJoint_last_updated_angle__set)
    __swig_setmethods__["rot_axis_unit_vector_"] = _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__set
    __swig_getmethods__["rot_axis_unit_vector_"] = _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__get
    if _newclass:rot_axis_unit_vector_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__get, _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__set)
    __swig_setmethods__["rot_axis_origin_"] = _IMP_kinematics.RevoluteJoint_rot_axis_origin__set
    __swig_getmethods__["rot_axis_origin_"] = _IMP_kinematics.RevoluteJoint_rot_axis_origin__get
    if _newclass:rot_axis_origin_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_origin__get, _IMP_kinematics.RevoluteJoint_rot_axis_origin__set)
    def __str__(self):
        """__str__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___str__(self)

    def __repr__(self):
        """__repr__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___repr__(self)

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

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

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_RevoluteJoint(self)
        return weakref_proxy(self)
RevoluteJoint_swigregister = _IMP_kinematics.RevoluteJoint_swigregister
RevoluteJoint_swigregister(RevoluteJoint)

class DihedralAngleRevoluteJoint(RevoluteJoint):
    """Proxy of C++ IMP::kinematics::DihedralAngleRevoluteJoint class"""
    __swig_setmethods__ = {}
    for _s in [RevoluteJoint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DihedralAngleRevoluteJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [RevoluteJoint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DihedralAngleRevoluteJoint, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::DihedralAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c, XYZ d) -> DihedralAngleRevoluteJoint"""
        this = _IMP_kinematics.new_DihedralAngleRevoluteJoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___str__(self)

    def __repr__(self):
        """__repr__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_DihedralAngleRevoluteJoint
    __del__ = lambda self : None;
DihedralAngleRevoluteJoint_swigregister = _IMP_kinematics.DihedralAngleRevoluteJoint_swigregister
DihedralAngleRevoluteJoint_swigregister(DihedralAngleRevoluteJoint)

class BondAngleRevoluteJoint(RevoluteJoint):
    """Proxy of C++ IMP::kinematics::BondAngleRevoluteJoint class"""
    __swig_setmethods__ = {}
    for _s in [RevoluteJoint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondAngleRevoluteJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [RevoluteJoint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondAngleRevoluteJoint, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::BondAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c) -> BondAngleRevoluteJoint"""
        this = _IMP_kinematics.new_BondAngleRevoluteJoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___str__(self)

    def __repr__(self):
        """__repr__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_BondAngleRevoluteJoint
    __del__ = lambda self : None;
BondAngleRevoluteJoint_swigregister = _IMP_kinematics.BondAngleRevoluteJoint_swigregister
BondAngleRevoluteJoint_swigregister(BondAngleRevoluteJoint)

class KinematicForest(IMP.base.Object):
    """Proxy of C++ IMP::kinematics::KinematicForest class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KinematicForest, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KinematicForest, name)
    def get_version_info(self):
        """get_version_info(KinematicForest self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForest_get_version_info(self)

    __swig_destroy__ = _IMP_kinematics.delete_KinematicForest
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::kinematics::KinematicForest self, Model m) -> KinematicForest
        __init__(IMP::kinematics::KinematicForest self, Model m, Hierarchy hierarchy) -> KinematicForest
        """
        this = _IMP_kinematics.new_KinematicForest(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_edge(self, *args):
        """
        add_edge(KinematicForest self, RigidBody parent, RigidBody child) -> Joint
        add_edge(KinematicForest self, Joint joint)
        """
        return _IMP_kinematics.KinematicForest_add_edge(self, *args)

    def add_rigid_bodies_in_chain(self, *args):
        """add_rigid_bodies_in_chain(KinematicForest self, IMP::core::RigidBodies rbs)"""
        return _IMP_kinematics.KinematicForest_add_rigid_bodies_in_chain(self, *args)

    def reset_root(self, *args):
        """reset_root(KinematicForest self, Particle new_root)"""
        return _IMP_kinematics.KinematicForest_reset_root(self, *args)

    def update_all_internal_coordinates(self):
        """update_all_internal_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_internal_coordinates(self)

    def update_all_external_coordinates(self):
        """update_all_external_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_external_coordinates(self)

    def get_ordered_joints(self):
        """get_ordered_joints(KinematicForest self) -> IMP::kinematics::Joints"""
        return _IMP_kinematics.KinematicForest_get_ordered_joints(self)

    def mark_internal_coordinates_changed(self):
        """mark_internal_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_internal_coordinates_changed(self)

    def mark_external_coordinates_changed(self):
        """mark_external_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_external_coordinates_changed(self)

    def set_coordinates_safe(self, *args):
        """set_coordinates_safe(KinematicForest self, RigidBody rb, Vector3D c)"""
        return _IMP_kinematics.KinematicForest_set_coordinates_safe(self, *args)

    def get_coordinates_safe(self, *args):
        """get_coordinates_safe(KinematicForest self, RigidBody rb) -> Vector3D"""
        return _IMP_kinematics.KinematicForest_get_coordinates_safe(self, *args)

    def get_is_member(self, *args):
        """get_is_member(KinematicForest self, RigidBody rb) -> bool"""
        return _IMP_kinematics.KinematicForest_get_is_member(self, *args)

    def get_reference_frame_safe(self, *args):
        """get_reference_frame_safe(KinematicForest self, RigidBody rb) -> ReferenceFrame3D"""
        return _IMP_kinematics.KinematicForest_get_reference_frame_safe(self, *args)

    def set_reference_frame_safe(self, *args):
        """set_reference_frame_safe(KinematicForest self, RigidBody rb, ReferenceFrame3D r)"""
        return _IMP_kinematics.KinematicForest_set_reference_frame_safe(self, *args)

    def __str__(self):
        """__str__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___str__(self)

    def __repr__(self):
        """__repr__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___repr__(self)

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

KinematicForest_swigregister = _IMP_kinematics.KinematicForest_swigregister
KinematicForest_swigregister(KinematicForest)

class DOF(IMP.base.Object):
    """Proxy of C++ IMP::kinematics::DOF class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DOF, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DOF, name)
    def get_version_info(self):
        """get_version_info(DOF self) -> VersionInfo"""
        return _IMP_kinematics.DOF_get_version_info(self)

    __swig_destroy__ = _IMP_kinematics.delete_DOF
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::kinematics::DOF self, double v) -> DOF
        __init__(IMP::kinematics::DOF self, double v, double min, double max, double step_size) -> DOF
        """
        this = _IMP_kinematics.new_DOF(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self):
        """get_value(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_value(self)

    def set_value(self, *args):
        """set_value(DOF self, double v)"""
        return _IMP_kinematics.DOF_set_value(self, *args)

    def get_range(self):
        """get_range(DOF self) -> std::pair< double,double >"""
        return _IMP_kinematics.DOF_get_range(self)

    def set_range(self, *args):
        """set_range(DOF self, std::pair< double,double > range)"""
        return _IMP_kinematics.DOF_set_range(self, *args)

    def get_step_size(self):
        """get_step_size(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_step_size(self)

    def set_step_size(self, *args):
        """set_step_size(DOF self, double step_size)"""
        return _IMP_kinematics.DOF_set_step_size(self, *args)

    def get_number_of_steps(self, *args):
        """
        get_number_of_steps(DOF self, double value) -> int
        get_number_of_steps(DOF self, double value1, double value2) -> int
        """
        return _IMP_kinematics.DOF_get_number_of_steps(self, *args)

    def __str__(self):
        """__str__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___str__(self)

    def __repr__(self):
        """__repr__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___repr__(self)

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

DOF_swigregister = _IMP_kinematics.DOF_swigregister
DOF_swigregister(DOF)

class DOFValues(VectorOfDoubles):
    """Proxy of C++ IMP::kinematics::DOFValues class"""
    __swig_setmethods__ = {}
    for _s in [VectorOfDoubles]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DOFValues, name, value)
    __swig_getmethods__ = {}
    for _s in [VectorOfDoubles]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DOFValues, name)
    def __init__(self, *args): 
        """
        __init__(IMP::kinematics::DOFValues self, IMP::kinematics::DOFs const & dofs) -> DOFValues
        __init__(IMP::kinematics::DOFValues self) -> DOFValues
        """
        this = _IMP_kinematics.new_DOFValues(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_distance2(self, *args):
        """get_distance2(DOFValues self, DOFValues other_dof_values) -> double"""
        return _IMP_kinematics.DOFValues_get_distance2(self, *args)

    def get_distance(self, *args):
        """get_distance(DOFValues self, DOFValues other_dof_values) -> double"""
        return _IMP_kinematics.DOFValues_get_distance(self, *args)

    def show(self, *args):
        """
        show(DOFValues self, _ostream out=std::cout)
        show(DOFValues self)
        """
        return _IMP_kinematics.DOFValues_show(self, *args)

    def __str__(self):
        """__str__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___str__(self)

    def __repr__(self):
        """__repr__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___repr__(self)

    __swig_destroy__ = _IMP_kinematics.delete_DOFValues
    __del__ = lambda self : None;
DOFValues_swigregister = _IMP_kinematics.DOFValues_swigregister
DOFValues_swigregister(DOFValues)

class DirectionalDOF(_object):
    """Proxy of C++ IMP::kinematics::DirectionalDOF class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirectionalDOF, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DirectionalDOF, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::DirectionalDOF self, IMP::kinematics::DOFs const & dofs) -> DirectionalDOF"""
        this = _IMP_kinematics.new_DirectionalDOF(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_end_points(self, *args):
        """set_end_points(DirectionalDOF self, DOFValues q1, DOFValues q2)"""
        return _IMP_kinematics.DirectionalDOF_set_end_points(self, *args)

    def get_dofs_values(self):
        """get_dofs_values(DirectionalDOF self) -> DOFValues"""
        return _IMP_kinematics.DirectionalDOF_get_dofs_values(self)

    def get_value(self):
        """get_value(DirectionalDOF self) -> double"""
        return _IMP_kinematics.DirectionalDOF_get_value(self)

    def show(self, *args):
        """
        show(DirectionalDOF self, _ostream out=std::cout)
        show(DirectionalDOF self)
        """
        return _IMP_kinematics.DirectionalDOF_show(self, *args)

    def __str__(self):
        """__str__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___str__(self)

    def __repr__(self):
        """__repr__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___repr__(self)

    __swig_destroy__ = _IMP_kinematics.delete_DirectionalDOF
    __del__ = lambda self : None;
DirectionalDOF_swigregister = _IMP_kinematics.DirectionalDOF_swigregister
DirectionalDOF_swigregister(DirectionalDOF)

class DOFsSampler(IMP.base.Object):
    """Proxy of C++ IMP::kinematics::DOFsSampler class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DOFsSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DOFsSampler, name)
    def get_type_name(self):
        """get_type_name(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler_get_type_name(self)

    def get_version_info(self):
        """get_version_info(DOFsSampler self) -> VersionInfo"""
        return _IMP_kinematics.DOFsSampler_get_version_info(self)

    __swig_destroy__ = _IMP_kinematics.delete_DOFsSampler
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::kinematics::DOFsSampler self, IMP::kinematics::DOFs dofs) -> DOFsSampler"""
        if self.__class__ == DOFsSampler:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_DOFsSampler(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != DOFsSampler:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_sample(self):
        """get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_get_sample(self)

    def apply(self, *args):
        """apply(DOFsSampler self, DOFValues values)"""
        return _IMP_kinematics.DOFsSampler_apply(self, *args)

    def apply_last_sample(self):
        """apply_last_sample(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_apply_last_sample(self)

    def sample_and_apply(self):
        """sample_and_apply(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_sample_and_apply(self)

    def get_dofs(self):
        """get_dofs(DOFsSampler self) -> IMP::kinematics::DOFs const &"""
        return _IMP_kinematics.DOFsSampler_get_dofs(self)

    def get_dof(self, *args):
        """get_dof(DOFsSampler self, unsigned int i) -> DOF"""
        return _IMP_kinematics.DOFsSampler_get_dof(self, *args)

    def get_number_of_dofs(self):
        """get_number_of_dofs(DOFsSampler self) -> unsigned int"""
        return _IMP_kinematics.DOFsSampler_get_number_of_dofs(self)

    def do_get_sample(self):
        """do_get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_do_get_sample(self)

    def __str__(self):
        """__str__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___str__(self)

    def __repr__(self):
        """__repr__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___repr__(self)

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

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

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_DOFsSampler(self)
        return weakref_proxy(self)
DOFsSampler_swigregister = _IMP_kinematics.DOFsSampler_swigregister
DOFsSampler_swigregister(DOFsSampler)

class UniformBackboneSampler(DOFsSampler):
    """Proxy of C++ IMP::kinematics::UniformBackboneSampler class"""
    __swig_setmethods__ = {}
    for _s in [DOFsSampler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniformBackboneSampler, name, value)
    __swig_getmethods__ = {}
    for _s in [DOFsSampler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniformBackboneSampler, name)
    def __init__(self, *args): 
        """__init__(IMP::kinematics::UniformBackboneSampler self, IMP::kinematics::DihedralAngleRevoluteJoints joints, IMP::kinematics::DOFs dofs) -> UniformBackboneSampler"""
        this = _IMP_kinematics.new_UniformBackboneSampler(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___str__(self)

    def __repr__(self):
        """__repr__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_UniformBackboneSampler
    __del__ = lambda self : None;
UniformBackboneSampler_swigregister = _IMP_kinematics.UniformBackboneSampler_swigregister
UniformBackboneSampler_swigregister(UniformBackboneSampler)


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

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

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

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