example/__init__.py

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





from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_example', [dirname(__file__)])
        except ImportError:
            import _IMP_example
            return _IMP_example
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_example', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_example = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_example
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_EXAMPLE_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_EXAMPLE_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_EXAMPLE_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_EXAMPLE_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_example.delete_IMP_EXAMPLE_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_EXAMPLE_SwigPyIterator self) -> PyObject *"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_EXAMPLE_SwigPyIterator self, size_t n=1) -> IMP_EXAMPLE_SwigPyIterator
        incr(IMP_EXAMPLE_SwigPyIterator self) -> IMP_EXAMPLE_SwigPyIterator
        """
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_EXAMPLE_SwigPyIterator self, size_t n=1) -> IMP_EXAMPLE_SwigPyIterator
        decr(IMP_EXAMPLE_SwigPyIterator self) -> IMP_EXAMPLE_SwigPyIterator
        """
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_EXAMPLE_SwigPyIterator self, IMP_EXAMPLE_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_EXAMPLE_SwigPyIterator self, IMP_EXAMPLE_SwigPyIterator x) -> bool"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_EXAMPLE_SwigPyIterator self) -> IMP_EXAMPLE_SwigPyIterator"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_EXAMPLE_SwigPyIterator self) -> PyObject *"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_EXAMPLE_SwigPyIterator self) -> PyObject *"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_EXAMPLE_SwigPyIterator self) -> PyObject *"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_EXAMPLE_SwigPyIterator self, ptrdiff_t n) -> IMP_EXAMPLE_SwigPyIterator"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_EXAMPLE_SwigPyIterator self, IMP_EXAMPLE_SwigPyIterator x) -> bool"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_EXAMPLE_SwigPyIterator self, IMP_EXAMPLE_SwigPyIterator x) -> bool"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_EXAMPLE_SwigPyIterator self, ptrdiff_t n) -> IMP_EXAMPLE_SwigPyIterator"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_EXAMPLE_SwigPyIterator self, ptrdiff_t n) -> IMP_EXAMPLE_SwigPyIterator"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_EXAMPLE_SwigPyIterator self, ptrdiff_t n) -> IMP_EXAMPLE_SwigPyIterator"""
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_EXAMPLE_SwigPyIterator self, ptrdiff_t n) -> IMP_EXAMPLE_SwigPyIterator
        __sub__(IMP_EXAMPLE_SwigPyIterator self, IMP_EXAMPLE_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_example.IMP_EXAMPLE_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_EXAMPLE_SwigPyIterator_swigregister = _IMP_example.IMP_EXAMPLE_SwigPyIterator_swigregister
IMP_EXAMPLE_SwigPyIterator_swigregister(IMP_EXAMPLE_SwigPyIterator)

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

IMP_DEBUG = _IMP_example.IMP_DEBUG
IMP_RELEASE = _IMP_example.IMP_RELEASE
IMP_SILENT = _IMP_example.IMP_SILENT
IMP_PROGRESS = _IMP_example.IMP_PROGRESS
IMP_TERSE = _IMP_example.IMP_TERSE
IMP_VERBOSE = _IMP_example.IMP_VERBOSE
IMP_MEMORY = _IMP_example.IMP_MEMORY
IMP_NONE = _IMP_example.IMP_NONE
IMP_USAGE = _IMP_example.IMP_USAGE
IMP_INTERNAL = _IMP_example.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_example.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_example.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_example.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_example.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_example.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_example.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_example.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_example.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_example.DEFAULT_CHECK
NONE = _IMP_example.NONE
USAGE = _IMP_example.USAGE
USAGE_AND_INTERNAL = _IMP_example.USAGE_AND_INTERNAL

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

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_example.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_example._ostream_write(self, *args)

_ostream_swigregister = _IMP_example._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_example.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_example.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_example.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_example.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_example.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_example.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_example.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_example.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_example.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_example.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_example.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_example.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_example.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_example.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_example.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_example.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_example.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_example.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_example.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_example.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_example.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_example.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_example.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_example.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_example.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_example.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_example.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_example.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_example.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_example.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_example.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_example.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_example.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_example.IMP_STATISTICS_HAS_CGAL
IMPSTATISTICS_SHOW_WARNINGS = _IMP_example.IMPSTATISTICS_SHOW_WARNINGS
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_example.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_example.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_example.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_example.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_example.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_example.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_example.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_example.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_example.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_example.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_example.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_example.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_example.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_example.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_example.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_example.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_example.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_example.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_example.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_example.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_example.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_example.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_example.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_example.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_example.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_example.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_example.IMP_ATOM_HAS_CGAL
IMP_ATOM_HAS_HDF5 = _IMP_example.IMP_ATOM_HAS_HDF5
IMPATOM_SHOW_WARNINGS = _IMP_example.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_example.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_example.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_example.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_RMF_HAS_IMP_BASE = _IMP_example.IMP_RMF_HAS_IMP_BASE
IMP_RMF_HAS_IMP_CGAL = _IMP_example.IMP_RMF_HAS_IMP_CGAL
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_example.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_RMF_HAS_BOOST_FILESYSTEM
IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
IMP_RMF_HAS_BOOST_RANDOM = _IMP_example.IMP_RMF_HAS_BOOST_RANDOM
IMP_RMF_HAS_BOOST_REGEX = _IMP_example.IMP_RMF_HAS_BOOST_REGEX
IMP_RMF_HAS_BOOST_SYSTEM = _IMP_example.IMP_RMF_HAS_BOOST_SYSTEM
IMP_RMF_HAS_CGAL = _IMP_example.IMP_RMF_HAS_CGAL
IMP_RMF_HAS_HDF5 = _IMP_example.IMP_RMF_HAS_HDF5
IMPRMF_SHOW_WARNINGS = _IMP_example.IMPRMF_SHOW_WARNINGS
import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_example.IMP_DOMINO_HAS_IMP_ATOM
IMP_DOMINO_HAS_IMP_BASE = _IMP_example.IMP_DOMINO_HAS_IMP_BASE
IMP_DOMINO_HAS_IMP_CGAL = _IMP_example.IMP_DOMINO_HAS_IMP_CGAL
IMP_DOMINO_HAS_IMP_KERNEL = _IMP_example.IMP_DOMINO_HAS_IMP_KERNEL
IMP_DOMINO_HAS_IMP_RMF = _IMP_example.IMP_DOMINO_HAS_IMP_RMF
IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_example.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_DOMINO_HAS_BOOST_FILESYSTEM
IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_example.IMP_DOMINO_HAS_BOOST_RANDOM
IMP_DOMINO_HAS_BOOST_REGEX = _IMP_example.IMP_DOMINO_HAS_BOOST_REGEX
IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_example.IMP_DOMINO_HAS_BOOST_SYSTEM
IMP_DOMINO_HAS_CGAL = _IMP_example.IMP_DOMINO_HAS_CGAL
IMP_DOMINO_HAS_HDF5 = _IMP_example.IMP_DOMINO_HAS_HDF5
IMP_DOMINO_HAS_RMF = _IMP_example.IMP_DOMINO_HAS_RMF
IMPDOMINO_SHOW_WARNINGS = _IMP_example.IMPDOMINO_SHOW_WARNINGS
import RMF_HDF5
import IMP.domino
IMP_EXAMPLE_HAS_IMP_ALGEBRA = _IMP_example.IMP_EXAMPLE_HAS_IMP_ALGEBRA
IMP_EXAMPLE_HAS_IMP_BASE = _IMP_example.IMP_EXAMPLE_HAS_IMP_BASE
IMP_EXAMPLE_HAS_IMP_CGAL = _IMP_example.IMP_EXAMPLE_HAS_IMP_CGAL
IMP_EXAMPLE_HAS_IMP_DISPLAY = _IMP_example.IMP_EXAMPLE_HAS_IMP_DISPLAY
IMP_EXAMPLE_HAS_IMP_KERNEL = _IMP_example.IMP_EXAMPLE_HAS_IMP_KERNEL
IMP_EXAMPLE_HAS_IMP_RMF = _IMP_example.IMP_EXAMPLE_HAS_IMP_RMF
IMP_EXAMPLE_HAS_IMP_SCORE_FUNCTOR = _IMP_example.IMP_EXAMPLE_HAS_IMP_SCORE_FUNCTOR
IMP_EXAMPLE_HAS_IMP_STATISTICS = _IMP_example.IMP_EXAMPLE_HAS_IMP_STATISTICS
IMP_EXAMPLE_HAS_BOOST_FILESYSTEM = _IMP_example.IMP_EXAMPLE_HAS_BOOST_FILESYSTEM
IMP_EXAMPLE_HAS_BOOST_GRAPH = _IMP_example.IMP_EXAMPLE_HAS_BOOST_GRAPH
IMP_EXAMPLE_HAS_BOOST_PROGRAMOPTIONS = _IMP_example.IMP_EXAMPLE_HAS_BOOST_PROGRAMOPTIONS
IMP_EXAMPLE_HAS_BOOST_RANDOM = _IMP_example.IMP_EXAMPLE_HAS_BOOST_RANDOM
IMP_EXAMPLE_HAS_BOOST_REGEX = _IMP_example.IMP_EXAMPLE_HAS_BOOST_REGEX
IMP_EXAMPLE_HAS_BOOST_SYSTEM = _IMP_example.IMP_EXAMPLE_HAS_BOOST_SYSTEM
IMP_EXAMPLE_HAS_CGAL = _IMP_example.IMP_EXAMPLE_HAS_CGAL
IMP_EXAMPLE_HAS_HDF5 = _IMP_example.IMP_EXAMPLE_HAS_HDF5
IMP_EXAMPLE_HAS_RMF = _IMP_example.IMP_EXAMPLE_HAS_RMF
IMP_EXAMPLE_HAS_EXAMPLEDEPENDENCY = _IMP_example.IMP_EXAMPLE_HAS_EXAMPLEDEPENDENCY
IMPEXAMPLE_SHOW_WARNINGS = _IMP_example.IMPEXAMPLE_SHOW_WARNINGS
_object_types.append("ExampleRestraint")


def _object_cast_to_ExampleRestraint(*args):
  """_object_cast_to_ExampleRestraint(Object o) -> ExampleRestraint"""
  return _IMP_example._object_cast_to_ExampleRestraint(*args)
def ExampleDecorators(l=[]):
    return [ExampleDecorator(x) for x in l]
_plural_types.append("ExampleDecorators")

_value_types.append("ExampleDecorator")

_object_types.append("ExampleUnaryFunction")


def _object_cast_to_ExampleUnaryFunction(*args):
  """_object_cast_to_ExampleUnaryFunction(Object o) -> ExampleUnaryFunction"""
  return _IMP_example._object_cast_to_ExampleUnaryFunction(*args)
_object_types.append("ExampleSingletonModifier")


def _object_cast_to_ExampleSingletonModifier(*args):
  """_object_cast_to_ExampleSingletonModifier(Object o) -> ExampleSingletonModifier"""
  return _IMP_example._object_cast_to_ExampleSingletonModifier(*args)
_object_types.append("ExamplePairScore")


def _object_cast_to_ExamplePairScore(*args):
  """_object_cast_to_ExamplePairScore(Object o) -> ExamplePairScore"""
  return _IMP_example._object_cast_to_ExamplePairScore(*args)
_object_types.append("ExampleSubsetFilterTable")


def _object_cast_to_ExampleSubsetFilterTable(*args):
  """_object_cast_to_ExampleSubsetFilterTable(Object o) -> ExampleSubsetFilterTable"""
  return _IMP_example._object_cast_to_ExampleSubsetFilterTable(*args)
_object_types.append("ExampleConstraint")


def _object_cast_to_ExampleConstraint(*args):
  """_object_cast_to_ExampleConstraint(Object o) -> ExampleConstraint"""
  return _IMP_example._object_cast_to_ExampleConstraint(*args)
_object_types.append("ExampleObject")


def _object_cast_to_ExampleObject(*args):
  """_object_cast_to_ExampleObject(Object o) -> ExampleObject"""
  return _IMP_example._object_cast_to_ExampleObject(*args)
ExampleTemplateClass3Ds=list
_plural_types.append("ExampleTemplateClass3Ds")
_value_types.append("ExampleTemplateClass3D")

def create_model_and_particles():
  m= IMP.Model()
  sc= IMP.container.ListSingletonContainer(m)
  b= IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0),
                               IMP.algebra.Vector3D(10,10,10))
  for i in range(0,100):
     p= IMP.Particle(m)
     sc.add_particle(p)
     d=IMP.core.XYZR.setup_particle(p, IMP.algebra.Sphere3D(IMP.algebra.get_random_vector_in(b), 1))
     d.set_coordinates_are_optimized(True)
  return (m, sc)

class ExampleRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::example::ExampleRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleRestraint self, Model m, IMP::kernel::ParticleIndex p, double k) -> ExampleRestraint"""
        this = _IMP_example.new_ExampleRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(ExampleRestraint self, ScoreAccumulator sa)"""
        return _IMP_example.ExampleRestraint_do_add_score_and_derivatives(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(ExampleRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExampleRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(ExampleRestraint self) -> VersionInfo"""
        return _IMP_example.ExampleRestraint_get_version_info(self)

    def __str__(self):
        """__str__(ExampleRestraint self) -> std::string"""
        return _IMP_example.ExampleRestraint___str__(self)

    def __repr__(self):
        """__repr__(ExampleRestraint self) -> std::string"""
        return _IMP_example.ExampleRestraint___repr__(self)

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

ExampleRestraint_swigregister = _IMP_example.ExampleRestraint_swigregister
ExampleRestraint_swigregister(ExampleRestraint)

class ExampleDecorator(IMP.kernel.Decorator):
    """Proxy of C++ IMP::example::ExampleDecorator class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleDecorator, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleDecorator, name)
    def get_decorator_name(self):
        """get_decorator_name(ExampleDecorator self) -> std::string"""
        return _IMP_example.ExampleDecorator_get_decorator_name(self)

    def set_decorator_name(self, *args):
        """set_decorator_name(ExampleDecorator self, std::string nm)"""
        return _IMP_example.ExampleDecorator_set_decorator_name(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::example::ExampleDecorator self) -> ExampleDecorator
        __init__(IMP::example::ExampleDecorator self, Model m, ::IMP::kernel::ParticleIndex id) -> ExampleDecorator
        __init__(IMP::example::ExampleDecorator self, _ParticleAdaptor d) -> ExampleDecorator
        """
        this = _IMP_example.new_ExampleDecorator(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_is_setup(*args):
        """
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_example.ExampleDecorator_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def show(self, *args):
        """
        show(ExampleDecorator self, _ostream out=std::cout)
        show(ExampleDecorator self)
        """
        return _IMP_example.ExampleDecorator_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, std::string name) -> ExampleDecorator
        setup_particle(_ParticleAdaptor decorator, std::string name) -> ExampleDecorator
        """
        return _IMP_example.ExampleDecorator_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def add_attribute(self, *args):
        """
        add_attribute(ExampleDecorator self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(ExampleDecorator self, FloatKey a0, IMP::Float a1)
        add_attribute(ExampleDecorator self, IntKey a0, IMP::Int a1)
        add_attribute(ExampleDecorator self, StringKey a0, IMP::String a1)
        add_attribute(ExampleDecorator self, ParticleIndexKey a0, Particle a1)
        add_attribute(ExampleDecorator self, ObjectKey a0, Object a1)
        """
        return _IMP_example.ExampleDecorator_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(ExampleDecorator self, FloatKey a0) -> IMP::Float
        get_value(ExampleDecorator self, IntKey a0) -> IMP::Int
        get_value(ExampleDecorator self, StringKey a0) -> IMP::String
        get_value(ExampleDecorator self, ParticleIndexKey a0) -> Particle
        get_value(ExampleDecorator self, ObjectKey a0) -> Object
        """
        return _IMP_example.ExampleDecorator_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(ExampleDecorator self, FloatKey a0, IMP::Float a1)
        set_value(ExampleDecorator self, IntKey a0, IMP::Int a1)
        set_value(ExampleDecorator self, StringKey a0, IMP::String a1)
        set_value(ExampleDecorator self, ParticleIndexKey a0, Particle a1)
        set_value(ExampleDecorator self, ObjectKey a0, Object a1)
        """
        return _IMP_example.ExampleDecorator_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(ExampleDecorator self, FloatKey a0)
        remove_attribute(ExampleDecorator self, IntKey a0)
        remove_attribute(ExampleDecorator self, StringKey a0)
        remove_attribute(ExampleDecorator self, ParticleIndexKey a0)
        remove_attribute(ExampleDecorator self, ObjectKey a0)
        """
        return _IMP_example.ExampleDecorator_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(ExampleDecorator self, FloatKey a0) -> bool
        has_attribute(ExampleDecorator self, IntKey a0) -> bool
        has_attribute(ExampleDecorator self, StringKey a0) -> bool
        has_attribute(ExampleDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(ExampleDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_example.ExampleDecorator_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(ExampleDecorator self, FloatKey a0) -> double"""
        return _IMP_example.ExampleDecorator_get_derivative(self, *args)

    def get_name(self):
        """get_name(ExampleDecorator self) -> std::string"""
        return _IMP_example.ExampleDecorator_get_name(self)

    def clear_caches(self):
        """clear_caches(ExampleDecorator self)"""
        return _IMP_example.ExampleDecorator_clear_caches(self)

    def set_name(self, *args):
        """set_name(ExampleDecorator self, std::string a0)"""
        return _IMP_example.ExampleDecorator_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(ExampleDecorator self, IMP::base::CheckLevel a0)"""
        return _IMP_example.ExampleDecorator_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(ExampleDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_example.ExampleDecorator_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(ExampleDecorator self, FloatKey a0, bool a1)"""
        return _IMP_example.ExampleDecorator_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(ExampleDecorator self, FloatKey a0) -> bool"""
        return _IMP_example.ExampleDecorator_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(ExampleDecorator self) -> IMP::base::CheckLevel"""
        return _IMP_example.ExampleDecorator_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(ExampleDecorator self, ExampleDecorator o) -> bool
        __eq__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(ExampleDecorator self, ExampleDecorator o) -> bool
        __ne__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(ExampleDecorator self, ExampleDecorator o) -> bool
        __le__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(ExampleDecorator self, ExampleDecorator o) -> bool
        __lt__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(ExampleDecorator self, ExampleDecorator o) -> bool
        __ge__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(ExampleDecorator self, ExampleDecorator o) -> bool
        __gt__(ExampleDecorator self, Particle d) -> bool
        """
        return _IMP_example.ExampleDecorator___gt__(self, *args)

    def __str__(self):
        """__str__(ExampleDecorator self) -> std::string"""
        return _IMP_example.ExampleDecorator___str__(self)

    def __repr__(self):
        """__repr__(ExampleDecorator self) -> std::string"""
        return _IMP_example.ExampleDecorator___repr__(self)

    __swig_destroy__ = _IMP_example.delete_ExampleDecorator
    __del__ = lambda self : None;
ExampleDecorator_swigregister = _IMP_example.ExampleDecorator_swigregister
ExampleDecorator_swigregister(ExampleDecorator)

def ExampleDecorator_get_is_setup(*args):
  """
    get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    ExampleDecorator_get_is_setup(_ParticleAdaptor p) -> bool
    """
  return _IMP_example.ExampleDecorator_get_is_setup(*args)

def ExampleDecorator_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, std::string name) -> ExampleDecorator
    ExampleDecorator_setup_particle(_ParticleAdaptor decorator, std::string name) -> ExampleDecorator
    """
  return _IMP_example.ExampleDecorator_setup_particle(*args)


def __lshift__(*args):
  """__lshift__(_ostream out, ExampleDecorator n) -> _ostream"""
  return _IMP_example.__lshift__(*args)
class ExampleUnaryFunction(IMP.kernel.UnaryFunction):
    """Proxy of C++ IMP::example::ExampleUnaryFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleUnaryFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.UnaryFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleUnaryFunction, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleUnaryFunction self, IMP::Float center, IMP::Float k) -> ExampleUnaryFunction"""
        this = _IMP_example.new_ExampleUnaryFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ExampleUnaryFunction self) -> VersionInfo"""
        return _IMP_example.ExampleUnaryFunction_get_version_info(self)

    def __str__(self):
        """__str__(ExampleUnaryFunction self) -> std::string"""
        return _IMP_example.ExampleUnaryFunction___str__(self)

    def __repr__(self):
        """__repr__(ExampleUnaryFunction self) -> std::string"""
        return _IMP_example.ExampleUnaryFunction___repr__(self)

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

ExampleUnaryFunction_swigregister = _IMP_example.ExampleUnaryFunction_swigregister
ExampleUnaryFunction_swigregister(ExampleUnaryFunction)

class ExampleObject(IMP.base.Object):
    """Proxy of C++ IMP::example::ExampleObject class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleObject, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleObject, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleObject self, IMP::Floats const & data) -> ExampleObject"""
        this = _IMP_example.new_ExampleObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_data(self, *args):
        """get_data(ExampleObject self, unsigned int i) -> double"""
        return _IMP_example.ExampleObject_get_data(self, *args)

    def get_version_info(self):
        """get_version_info(ExampleObject self) -> VersionInfo"""
        return _IMP_example.ExampleObject_get_version_info(self)

    def __str__(self):
        """__str__(ExampleObject self) -> std::string"""
        return _IMP_example.ExampleObject___str__(self)

    def __repr__(self):
        """__repr__(ExampleObject self) -> std::string"""
        return _IMP_example.ExampleObject___repr__(self)

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

ExampleObject_swigregister = _IMP_example.ExampleObject_swigregister
ExampleObject_swigregister(ExampleObject)

class ExampleSingletonModifier(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::example::ExampleSingletonModifier class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleSingletonModifier, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleSingletonModifier, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleSingletonModifier self, BoundingBox3D bb) -> ExampleSingletonModifier"""
        this = _IMP_example.new_ExampleSingletonModifier(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(ExampleSingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExampleSingletonModifier_do_get_inputs(self, *args)

    def do_get_outputs(self, *args):
        """do_get_outputs(ExampleSingletonModifier self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExampleSingletonModifier_do_get_outputs(self, *args)

    def get_version_info(self):
        """get_version_info(ExampleSingletonModifier self) -> VersionInfo"""
        return _IMP_example.ExampleSingletonModifier_get_version_info(self)

    def __str__(self):
        """__str__(ExampleSingletonModifier self) -> std::string"""
        return _IMP_example.ExampleSingletonModifier___str__(self)

    def __repr__(self):
        """__repr__(ExampleSingletonModifier self) -> std::string"""
        return _IMP_example.ExampleSingletonModifier___repr__(self)

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

ExampleSingletonModifier_swigregister = _IMP_example.ExampleSingletonModifier_swigregister
ExampleSingletonModifier_swigregister(ExampleSingletonModifier)

class ExamplePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::example::ExamplePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExamplePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExamplePairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExamplePairScore self, double x0, double k) -> ExamplePairScore"""
        this = _IMP_example.new_ExamplePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(ExamplePairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExamplePairScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(ExamplePairScore self) -> VersionInfo"""
        return _IMP_example.ExamplePairScore_get_version_info(self)

    def __str__(self):
        """__str__(ExamplePairScore self) -> std::string"""
        return _IMP_example.ExamplePairScore___str__(self)

    def __repr__(self):
        """__repr__(ExamplePairScore self) -> std::string"""
        return _IMP_example.ExamplePairScore___repr__(self)

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

ExamplePairScore_swigregister = _IMP_example.ExamplePairScore_swigregister
ExamplePairScore_swigregister(ExamplePairScore)

class ExampleSubsetFilterTable(IMP.domino.SubsetFilterTable):
    """Proxy of C++ IMP::example::ExampleSubsetFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [IMP.domino.SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleSubsetFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.domino.SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleSubsetFilterTable, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleSubsetFilterTable self, unsigned int max_diff, IMP::kernel::ParticlesTemp const & pt) -> ExampleSubsetFilterTable"""
        this = _IMP_example.new_ExampleSubsetFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ExampleSubsetFilterTable self) -> VersionInfo"""
        return _IMP_example.ExampleSubsetFilterTable_get_version_info(self)

    def __str__(self):
        """__str__(ExampleSubsetFilterTable self) -> std::string"""
        return _IMP_example.ExampleSubsetFilterTable___str__(self)

    def __repr__(self):
        """__repr__(ExampleSubsetFilterTable self) -> std::string"""
        return _IMP_example.ExampleSubsetFilterTable___repr__(self)

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

ExampleSubsetFilterTable_swigregister = _IMP_example.ExampleSubsetFilterTable_swigregister
ExampleSubsetFilterTable_swigregister(ExampleSubsetFilterTable)

class ExampleConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::example::ExampleConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleConstraint, name)
    def __init__(self, *args): 
        """__init__(IMP::example::ExampleConstraint self, Particle p) -> ExampleConstraint"""
        this = _IMP_example.new_ExampleConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(ExampleConstraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExampleConstraint_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(ExampleConstraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_example.ExampleConstraint_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(ExampleConstraint self) -> VersionInfo"""
        return _IMP_example.ExampleConstraint_get_version_info(self)

    def __str__(self):
        """__str__(ExampleConstraint self) -> std::string"""
        return _IMP_example.ExampleConstraint___str__(self)

    def __repr__(self):
        """__repr__(ExampleConstraint self) -> std::string"""
        return _IMP_example.ExampleConstraint___repr__(self)

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

ExampleConstraint_swigregister = _IMP_example.ExampleConstraint_swigregister
ExampleConstraint_swigregister(ExampleConstraint)


def create_serial_mover(*args):
  """create_serial_mover(IMP::kernel::ParticlesTemp const & ps) -> MonteCarloMover"""
  return _IMP_example.create_serial_mover(*args)

def optimize_balls(*args):
  """
    optimize_balls(IMP::kernel::ParticlesTemp const & ps, IMP::kernel::RestraintsTemp const & rs=IMP::kernel::RestraintsTemp(), 
        IMP::kernel::PairPredicates const & excluded=IMP::kernel::PairPredicates(), 
        IMP::kernel::OptimizerStates const & opt_states=IMP::kernel::OptimizerStates(), 
        IMP::base::LogLevel ll=DEFAULT)
    optimize_balls(IMP::kernel::ParticlesTemp const & ps, IMP::kernel::RestraintsTemp const & rs=IMP::kernel::RestraintsTemp(), 
        IMP::kernel::PairPredicates const & excluded=IMP::kernel::PairPredicates(), 
        IMP::kernel::OptimizerStates const & opt_states=IMP::kernel::OptimizerStates())
    optimize_balls(IMP::kernel::ParticlesTemp const & ps, IMP::kernel::RestraintsTemp const & rs=IMP::kernel::RestraintsTemp(), 
        IMP::kernel::PairPredicates const & excluded=IMP::kernel::PairPredicates())
    optimize_balls(IMP::kernel::ParticlesTemp const & ps, IMP::kernel::RestraintsTemp const & rs=IMP::kernel::RestraintsTemp())
    optimize_balls(IMP::kernel::ParticlesTemp const & ps)
    """
  return _IMP_example.optimize_balls(*args)

def optimize_assembly(*args):
  """
    optimize_assembly(Model m, IMP::kernel::ParticlesTemp const & components, IMP::kernel::RestraintsTemp const & interactions, 
        IMP::kernel::RestraintsTemp const & other_restraints, 
        BoundingBox3D bb, PairScore ev, double cutoff, IMP::kernel::PairPredicates const & excluded=IMP::kernel::PairPredicates())
    optimize_assembly(Model m, IMP::kernel::ParticlesTemp const & components, IMP::kernel::RestraintsTemp const & interactions, 
        IMP::kernel::RestraintsTemp const & other_restraints, 
        BoundingBox3D bb, PairScore ev, double cutoff)
    """
  return _IMP_example.optimize_assembly(*args)

def get_number_of_incidences(*args):
  """get_number_of_incidences(IMP::kernel::ParticlesTemp const & psa, IMP::kernel::ParticlesTemp const & psb, double point_distance) -> unsigned int"""
  return _IMP_example.get_number_of_incidences(*args)

def create_chain_restraint(*args):
  """create_chain_restraint(IMP::kernel::ParticlesTemp const & ps, double length_factor, double k, std::string name) -> Restraint"""
  return _IMP_example.create_chain_restraint(*args)

def create_excluded_volume(*args):
  """create_excluded_volume(IMP::kernel::ParticlesTemp const & ps, double k, std::string name) -> ClosePairContainer"""
  return _IMP_example.create_excluded_volume(*args)
class ExampleTemplateClass3D(_object):
    """Proxy of C++ IMP::example::ExampleTemplateClassD<(3)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExampleTemplateClass3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExampleTemplateClass3D, name)
    def __init__(self, *args): 
        """
        __init__(IMP::example::ExampleTemplateClassD<(3)> self) -> ExampleTemplateClass3D
        __init__(IMP::example::ExampleTemplateClassD<(3)> self, Vector3D a, Vector3D b) -> ExampleTemplateClass3D
        """
        this = _IMP_example.new_ExampleTemplateClass3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_point(self, *args):
        """get_point(ExampleTemplateClass3D self, unsigned int i) -> Vector3D"""
        return _IMP_example.ExampleTemplateClass3D_get_point(self, *args)

    def show(self, *args):
        """
        show(ExampleTemplateClass3D self, _ostream out=std::cout)
        show(ExampleTemplateClass3D self)
        """
        return _IMP_example.ExampleTemplateClass3D_show(self, *args)

    def __str__(self):
        """__str__(ExampleTemplateClass3D self) -> std::string"""
        return _IMP_example.ExampleTemplateClass3D___str__(self)

    def __repr__(self):
        """__repr__(ExampleTemplateClass3D self) -> std::string"""
        return _IMP_example.ExampleTemplateClass3D___repr__(self)

    __swig_destroy__ = _IMP_example.delete_ExampleTemplateClass3D
    __del__ = lambda self : None;
ExampleTemplateClass3D_swigregister = _IMP_example.ExampleTemplateClass3D_swigregister
ExampleTemplateClass3D_swigregister(ExampleTemplateClass3D)

from _randomize import *


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

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

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_example.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.