11 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
as _swig_python_version_info
19 import builtins
as __builtin__
25 strthis =
"proxy of " + self.this.__repr__()
26 except __builtin__.Exception:
28 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
31 def _swig_setattr_nondynamic_instance_variable(set):
32 def set_instance_attr(self, name, value):
34 set(self, name, value)
35 elif name ==
"thisown":
37 elif hasattr(self, name)
and isinstance(getattr(type(self), name), property):
38 set(self, name, value)
40 raise AttributeError(
"You cannot add instance attributes to %s" % self)
41 return set_instance_attr
44 def _swig_setattr_nondynamic_class_variable(set):
45 def set_class_attr(cls, name, value):
46 if hasattr(cls, name)
and not isinstance(getattr(cls, name), property):
49 raise AttributeError(
"You cannot add class attributes to %s" % cls)
53 def _swig_add_metaclass(metaclass):
54 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
56 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
60 class _SwigNonDynamicMeta(type):
61 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
62 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
67 class IMP_ALGEBRA_SwigPyIterator(object):
68 r"""Proxy of C++ swig::IMP_ALGEBRA_SwigPyIterator class."""
70 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
72 def __init__(self, *args, **kwargs):
73 raise AttributeError(
"No constructor defined - class is abstract")
75 __swig_destroy__ = _IMP_algebra.delete_IMP_ALGEBRA_SwigPyIterator
78 r"""value(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
79 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_value(self)
82 r"""incr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator"""
83 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_incr(self, n)
86 r"""decr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator"""
87 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_decr(self, n)
89 def distance(self, x):
90 r"""distance(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t"""
91 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_distance(self, x)
94 r"""equal(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
95 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_equal(self, x)
98 r"""copy(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator"""
99 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_copy(self)
102 r"""next(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
103 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_next(self)
106 r"""__next__(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
107 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___next__(self)
110 r"""previous(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
111 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_previous(self)
113 def advance(self, n):
114 r"""advance(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
115 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_advance(self, n)
118 r"""__eq__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
119 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___eq__(self, x)
122 r"""__ne__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
123 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___ne__(self, x)
125 def __iadd__(self, n):
126 r"""__iadd__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
127 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___iadd__(self, n)
129 def __isub__(self, n):
130 r"""__isub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
131 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___isub__(self, n)
133 def __add__(self, n):
134 r"""__add__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
135 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___add__(self, n)
137 def __sub__(self, *args):
139 __sub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator
140 __sub__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t
142 return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___sub__(self, *args)
147 _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_swigregister(IMP_ALGEBRA_SwigPyIterator)
154 IMP_DEBUG = _IMP_algebra.IMP_DEBUG
156 IMP_RELEASE = _IMP_algebra.IMP_RELEASE
158 IMP_SILENT = _IMP_algebra.IMP_SILENT
160 IMP_PROGRESS = _IMP_algebra.IMP_PROGRESS
162 IMP_TERSE = _IMP_algebra.IMP_TERSE
164 IMP_VERBOSE = _IMP_algebra.IMP_VERBOSE
166 IMP_MEMORY = _IMP_algebra.IMP_MEMORY
168 IMP_NONE = _IMP_algebra.IMP_NONE
170 IMP_USAGE = _IMP_algebra.IMP_USAGE
172 IMP_INTERNAL = _IMP_algebra.IMP_INTERNAL
174 IMP_KERNEL_HAS_LOG4CXX = _IMP_algebra.IMP_KERNEL_HAS_LOG4CXX
176 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_algebra.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
178 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_algebra.IMP_COMPILER_HAS_DEBUG_VECTOR
180 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_algebra.IMP_COMPILER_HAS_RANDOM_SHUFFLE
182 IMP_COMPILER_HAS_THREE_WAY = _IMP_algebra.IMP_COMPILER_HAS_THREE_WAY
184 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_KERNEL_HAS_BOOST_RANDOM
186 IMP_KERNEL_HAS_NUMPY = _IMP_algebra.IMP_KERNEL_HAS_NUMPY
188 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_algebra.IMP_KERNEL_HAS_GPERFTOOLS
190 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
192 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
194 IMPKERNEL_SHOW_WARNINGS = _IMP_algebra.IMPKERNEL_SHOW_WARNINGS
198 class _DirectorObjects(object):
199 """@internal Simple class to keep references to director objects
200 to prevent premature deletion."""
203 def register(self, obj):
204 """Take a reference to a director object; will only work for
205 refcounted C++ classes"""
206 if hasattr(obj,
'get_ref_count'):
207 self._objects.append(obj)
209 """Only drop our reference and allow cleanup by Python if no other
210 Python references exist (we hold 3 references: one in self._objects,
211 one in x, and one in the argument list for getrefcount) *and* no
212 other C++ references exist (the Python object always holds one)"""
213 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
214 or x.get_ref_count() > 1]
218 def get_object_count(self):
219 """Get number of director objects (useful for testing only)"""
220 return len(self._objects)
221 _director_objects = _DirectorObjects()
223 class _ostream(object):
224 r"""Proxy of C++ std::ostream class."""
226 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
228 def __init__(self, *args, **kwargs):
229 raise AttributeError(
"No constructor defined")
230 __repr__ = _swig_repr
232 def write(self, osa_buf):
233 r"""write(_ostream self, char const * osa_buf)"""
234 return _IMP_algebra._ostream_write(self, osa_buf)
237 _IMP_algebra._ostream_swigregister(_ostream)
238 IMP_C_OPEN_BINARY = _IMP_algebra.IMP_C_OPEN_BINARY
241 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_FILESYSTEM
243 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_CGAL_HAS_BOOST_RANDOM
247 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_SYSTEM
249 IMP_CGAL_HAS_NUMPY = _IMP_algebra.IMP_CGAL_HAS_NUMPY
251 IMPCGAL_SHOW_WARNINGS = _IMP_algebra.IMPCGAL_SHOW_WARNINGS
254 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_IMP_CGAL
256 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
258 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
260 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_RANDOM
262 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SYSTEM
264 IMP_ALGEBRA_HAS_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_CGAL
266 IMP_ALGEBRA_HAS_NUMPY = _IMP_algebra.IMP_ALGEBRA_HAS_NUMPY
268 IMP_ALGEBRA_HAS_ANN = _IMP_algebra.IMP_ALGEBRA_HAS_ANN
270 IMPALGEBRA_SHOW_WARNINGS = _IMP_algebra.IMPALGEBRA_SHOW_WARNINGS
275 return v.get_coordinates()
280 return v.get_sphere()
285 _object_types.append(
"VectorKDMetric")
288 def _object_cast_to_VectorKDMetric(o):
289 r"""_object_cast_to_VectorKDMetric(Object o) -> VectorKDMetric"""
290 return _IMP_algebra._object_cast_to_VectorKDMetric(o)
292 _object_types.append(
"EuclideanVectorKDMetric")
295 def _object_cast_to_EuclideanVectorKDMetric(o):
296 r"""_object_cast_to_EuclideanVectorKDMetric(Object o) -> EuclideanVectorKDMetric"""
297 return _IMP_algebra._object_cast_to_EuclideanVectorKDMetric(o)
299 _object_types.append(
"MaxVectorKDMetric")
302 def _object_cast_to_MaxVectorKDMetric(o):
303 r"""_object_cast_to_MaxVectorKDMetric(Object o) -> MaxVectorKDMetric"""
304 return _IMP_algebra._object_cast_to_MaxVectorKDMetric(o)
306 _object_types.append(
"DynamicNearestNeighbor3D")
309 def _object_cast_to_DynamicNearestNeighbor3D(o):
310 r"""_object_cast_to_DynamicNearestNeighbor3D(Object o) -> DynamicNearestNeighbor3D"""
311 return _IMP_algebra._object_cast_to_DynamicNearestNeighbor3D(o)
314 _plural_types.append(
"Rotation2Ds")
315 _value_types.append(
"Rotation2D")
319 _plural_types.append(
"Rotation3Ds")
320 _value_types.append(
"Rotation3D")
324 _plural_types.append(
"Reflection3Ds")
325 _value_types.append(
"Reflection3D")
328 Transformation2Ds=list
329 _plural_types.append(
"Transformation2Ds")
330 _value_types.append(
"Transformation2D")
333 Transformation3Ds=list
334 _plural_types.append(
"Transformation3Ds")
335 _value_types.append(
"Transformation3D")
338 SphericalVector3Ds=list
339 _plural_types.append(
"SphericalVector3Ds")
340 _value_types.append(
"SphericalVector3D")
344 _plural_types.append(
"Triangle3Ds")
345 _value_types.append(
"Triangle3D")
349 _plural_types.append(
"Cone3Ds")
350 _value_types.append(
"Cone3D")
354 _plural_types.append(
"Cylinder3Ds")
355 _value_types.append(
"Cylinder3D")
359 _plural_types.append(
"Ellipsoid3Ds")
360 _value_types.append(
"Ellipsoid3D")
364 _plural_types.append(
"Line3Ds")
365 _value_types.append(
"Line3D")
369 _plural_types.append(
"Plane3Ds")
370 _value_types.append(
"Plane3D")
374 _plural_types.append(
"Segment3Ds")
375 _value_types.append(
"Segment3D")
379 _plural_types.append(
"SpherePatch3Ds")
380 _value_types.append(
"SpherePatch3D")
383 ConnollySurfacePoints=list
384 _plural_types.append(
"ConnollySurfacePoints")
385 _value_types.append(
"ConnollySurfacePoint")
389 _plural_types.append(
"Sphere1Ds")
390 _value_types.append(
"Sphere1D")
394 _plural_types.append(
"Sphere2Ds")
395 _value_types.append(
"Sphere2D")
399 _plural_types.append(
"Sphere3Ds")
400 _value_types.append(
"Sphere3D")
404 _plural_types.append(
"Sphere4Ds")
405 _value_types.append(
"Sphere4D")
409 _plural_types.append(
"Sphere5Ds")
410 _value_types.append(
"Sphere5D")
414 _plural_types.append(
"Sphere6Ds")
415 _value_types.append(
"Sphere6D")
419 _plural_types.append(
"Sphere1Ds")
420 _value_types.append(
"SphereD<1>")
424 _plural_types.append(
"Sphere2Ds")
425 _value_types.append(
"SphereD<2>")
429 _plural_types.append(
"Sphere3Ds")
430 _value_types.append(
"SphereD<3>")
434 _plural_types.append(
"Sphere4Ds")
435 _value_types.append(
"SphereD<4>")
439 _plural_types.append(
"Sphere5Ds")
440 _value_types.append(
"SphereD<5>")
444 _plural_types.append(
"Sphere6Ds")
445 _value_types.append(
"SphereD<6>")
449 _plural_types.append(
"SphereKDs")
450 _value_types.append(
"SphereKD")
454 _plural_types.append(
"SphereKDs")
455 _value_types.append(
"SphereD<-1>")
459 _plural_types.append(
"UnitSimplex1Ds")
460 _value_types.append(
"UnitSimplex1D")
464 _plural_types.append(
"UnitSimplex2Ds")
465 _value_types.append(
"UnitSimplex2D")
469 _plural_types.append(
"UnitSimplex3Ds")
470 _value_types.append(
"UnitSimplex3D")
474 _plural_types.append(
"UnitSimplex4Ds")
475 _value_types.append(
"UnitSimplex4D")
479 _plural_types.append(
"UnitSimplex5Ds")
480 _value_types.append(
"UnitSimplex5D")
484 _plural_types.append(
"UnitSimplex6Ds")
485 _value_types.append(
"UnitSimplex6D")
489 _plural_types.append(
"UnitSimplex1Ds")
490 _value_types.append(
"UnitSimplexD<1>")
494 _plural_types.append(
"UnitSimplex2Ds")
495 _value_types.append(
"UnitSimplexD<2>")
499 _plural_types.append(
"UnitSimplex3Ds")
500 _value_types.append(
"UnitSimplexD<3>")
504 _plural_types.append(
"UnitSimplex4Ds")
505 _value_types.append(
"UnitSimplexD<4>")
509 _plural_types.append(
"UnitSimplex5Ds")
510 _value_types.append(
"UnitSimplexD<5>")
514 _plural_types.append(
"UnitSimplex6Ds")
515 _value_types.append(
"UnitSimplexD<6>")
519 _plural_types.append(
"UnitSimplexKDs")
520 _value_types.append(
"UnitSimplexKD")
524 _plural_types.append(
"UnitSimplexKDs")
525 _value_types.append(
"UnitSimplexD<-1>")
529 _plural_types.append(
"BoundingBox1Ds")
530 _value_types.append(
"BoundingBox1D")
534 _plural_types.append(
"BoundingBox2Ds")
535 _value_types.append(
"BoundingBox2D")
539 _plural_types.append(
"BoundingBox3Ds")
540 _value_types.append(
"BoundingBox3D")
544 _plural_types.append(
"BoundingBox4Ds")
545 _value_types.append(
"BoundingBox4D")
549 _plural_types.append(
"BoundingBox5Ds")
550 _value_types.append(
"BoundingBox5D")
554 _plural_types.append(
"BoundingBox6Ds")
555 _value_types.append(
"BoundingBox6D")
559 _plural_types.append(
"BoundingBox1Ds")
560 _value_types.append(
"BoundingBoxD<1>")
564 _plural_types.append(
"BoundingBox2Ds")
565 _value_types.append(
"BoundingBoxD<2>")
569 _plural_types.append(
"BoundingBox3Ds")
570 _value_types.append(
"BoundingBoxD<3>")
574 _plural_types.append(
"BoundingBox4Ds")
575 _value_types.append(
"BoundingBoxD<4>")
579 _plural_types.append(
"BoundingBox5Ds")
580 _value_types.append(
"BoundingBoxD<5>")
584 _plural_types.append(
"BoundingBox6Ds")
585 _value_types.append(
"BoundingBoxD<6>")
589 _plural_types.append(
"BoundingBoxKDs")
590 _value_types.append(
"BoundingBoxKD")
594 _plural_types.append(
"BoundingBoxKDs")
595 _value_types.append(
"BoundingBoxD<-1>")
598 PrincipalComponentAnalysis1Ds=list
599 _plural_types.append(
"PrincipalComponentAnalysis1Ds")
600 _value_types.append(
"PrincipalComponentAnalysis1D")
603 PrincipalComponentAnalysis2Ds=list
604 _plural_types.append(
"PrincipalComponentAnalysis2Ds")
605 _value_types.append(
"PrincipalComponentAnalysis2D")
608 PrincipalComponentAnalysis3Ds=list
609 _plural_types.append(
"PrincipalComponentAnalysis3Ds")
610 _value_types.append(
"PrincipalComponentAnalysis3D")
613 PrincipalComponentAnalysis4Ds=list
614 _plural_types.append(
"PrincipalComponentAnalysis4Ds")
615 _value_types.append(
"PrincipalComponentAnalysis4D")
618 PrincipalComponentAnalysis5Ds=list
619 _plural_types.append(
"PrincipalComponentAnalysis5Ds")
620 _value_types.append(
"PrincipalComponentAnalysis5D")
623 PrincipalComponentAnalysis6Ds=list
624 _plural_types.append(
"PrincipalComponentAnalysis6Ds")
625 _value_types.append(
"PrincipalComponentAnalysis6D")
628 PrincipalComponentAnalysis1Ds=list
629 _plural_types.append(
"PrincipalComponentAnalysis1Ds")
630 _value_types.append(
"PrincipalComponentAnalysisD<1>")
633 PrincipalComponentAnalysis2Ds=list
634 _plural_types.append(
"PrincipalComponentAnalysis2Ds")
635 _value_types.append(
"PrincipalComponentAnalysisD<2>")
638 PrincipalComponentAnalysis3Ds=list
639 _plural_types.append(
"PrincipalComponentAnalysis3Ds")
640 _value_types.append(
"PrincipalComponentAnalysisD<3>")
643 PrincipalComponentAnalysis4Ds=list
644 _plural_types.append(
"PrincipalComponentAnalysis4Ds")
645 _value_types.append(
"PrincipalComponentAnalysisD<4>")
648 PrincipalComponentAnalysis5Ds=list
649 _plural_types.append(
"PrincipalComponentAnalysis5Ds")
650 _value_types.append(
"PrincipalComponentAnalysisD<5>")
653 PrincipalComponentAnalysis6Ds=list
654 _plural_types.append(
"PrincipalComponentAnalysis6Ds")
655 _value_types.append(
"PrincipalComponentAnalysisD<6>")
658 PrincipalComponentAnalysisKDs=list
659 _plural_types.append(
"PrincipalComponentAnalysisKDs")
660 _value_types.append(
"PrincipalComponentAnalysisKD")
663 PrincipalComponentAnalysisKDs=list
664 _plural_types.append(
"PrincipalComponentAnalysisKDs")
665 _value_types.append(
"PrincipalComponentAnalysisD<-1>")
668 _object_types.append(
"NearestNeighbor1D")
671 def _object_cast_to_NearestNeighbor1D(o):
672 r"""_object_cast_to_NearestNeighbor1D(Object o) -> NearestNeighbor1D"""
673 return _IMP_algebra._object_cast_to_NearestNeighbor1D(o)
675 _object_types.append(
"NearestNeighbor2D")
678 def _object_cast_to_NearestNeighbor2D(o):
679 r"""_object_cast_to_NearestNeighbor2D(Object o) -> NearestNeighbor2D"""
680 return _IMP_algebra._object_cast_to_NearestNeighbor2D(o)
682 _object_types.append(
"NearestNeighbor3D")
685 def _object_cast_to_NearestNeighbor3D(o):
686 r"""_object_cast_to_NearestNeighbor3D(Object o) -> NearestNeighbor3D"""
687 return _IMP_algebra._object_cast_to_NearestNeighbor3D(o)
689 _object_types.append(
"NearestNeighbor4D")
692 def _object_cast_to_NearestNeighbor4D(o):
693 r"""_object_cast_to_NearestNeighbor4D(Object o) -> NearestNeighbor4D"""
694 return _IMP_algebra._object_cast_to_NearestNeighbor4D(o)
696 _object_types.append(
"NearestNeighbor5D")
699 def _object_cast_to_NearestNeighbor5D(o):
700 r"""_object_cast_to_NearestNeighbor5D(Object o) -> NearestNeighbor5D"""
701 return _IMP_algebra._object_cast_to_NearestNeighbor5D(o)
703 _object_types.append(
"NearestNeighbor6D")
706 def _object_cast_to_NearestNeighbor6D(o):
707 r"""_object_cast_to_NearestNeighbor6D(Object o) -> NearestNeighbor6D"""
708 return _IMP_algebra._object_cast_to_NearestNeighbor6D(o)
710 _object_types.append(
"NearestNeighborKD")
713 def _object_cast_to_NearestNeighborKD(o):
714 r"""_object_cast_to_NearestNeighborKD(Object o) -> NearestNeighborKD"""
715 return _IMP_algebra._object_cast_to_NearestNeighborKD(o)
717 ReferenceFrame3Ds=list
718 _plural_types.append(
"ReferenceFrame3Ds")
719 _value_types.append(
"ReferenceFrame3D")
723 _plural_types.append(
"Gaussian3Ds")
724 _value_types.append(
"Gaussian3D")
727 DefaultEmbedding1Ds=list
728 _plural_types.append(
"DefaultEmbedding1Ds")
729 _value_types.append(
"DefaultEmbedding1D")
732 DefaultEmbedding2Ds=list
733 _plural_types.append(
"DefaultEmbedding2Ds")
734 _value_types.append(
"DefaultEmbedding2D")
737 DefaultEmbedding3Ds=list
738 _plural_types.append(
"DefaultEmbedding3Ds")
739 _value_types.append(
"DefaultEmbedding3D")
742 DefaultEmbedding4Ds=list
743 _plural_types.append(
"DefaultEmbedding4Ds")
744 _value_types.append(
"DefaultEmbedding4D")
747 DefaultEmbedding5Ds=list
748 _plural_types.append(
"DefaultEmbedding5Ds")
749 _value_types.append(
"DefaultEmbedding5D")
752 DefaultEmbedding6Ds=list
753 _plural_types.append(
"DefaultEmbedding6Ds")
754 _value_types.append(
"DefaultEmbedding6D")
757 DefaultEmbedding1Ds=list
758 _plural_types.append(
"DefaultEmbedding1Ds")
759 _value_types.append(
"DefaultEmbeddingD<1>")
762 DefaultEmbedding2Ds=list
763 _plural_types.append(
"DefaultEmbedding2Ds")
764 _value_types.append(
"DefaultEmbeddingD<2>")
767 DefaultEmbedding3Ds=list
768 _plural_types.append(
"DefaultEmbedding3Ds")
769 _value_types.append(
"DefaultEmbeddingD<3>")
772 DefaultEmbedding4Ds=list
773 _plural_types.append(
"DefaultEmbedding4Ds")
774 _value_types.append(
"DefaultEmbeddingD<4>")
777 DefaultEmbedding5Ds=list
778 _plural_types.append(
"DefaultEmbedding5Ds")
779 _value_types.append(
"DefaultEmbeddingD<5>")
782 DefaultEmbedding6Ds=list
783 _plural_types.append(
"DefaultEmbedding6Ds")
784 _value_types.append(
"DefaultEmbeddingD<6>")
787 DefaultEmbeddingKDs=list
788 _plural_types.append(
"DefaultEmbeddingKDs")
789 _value_types.append(
"DefaultEmbeddingKD")
792 DefaultEmbeddingKDs=list
793 _plural_types.append(
"DefaultEmbeddingKDs")
794 _value_types.append(
"DefaultEmbeddingD<-1>")
798 _plural_types.append(
"LogEmbedding1Ds")
799 _value_types.append(
"LogEmbedding1D")
803 _plural_types.append(
"LogEmbedding2Ds")
804 _value_types.append(
"LogEmbedding2D")
808 _plural_types.append(
"LogEmbedding3Ds")
809 _value_types.append(
"LogEmbedding3D")
813 _plural_types.append(
"LogEmbedding4Ds")
814 _value_types.append(
"LogEmbedding4D")
818 _plural_types.append(
"LogEmbedding5Ds")
819 _value_types.append(
"LogEmbedding5D")
823 _plural_types.append(
"LogEmbedding6Ds")
824 _value_types.append(
"LogEmbedding6D")
828 _plural_types.append(
"LogEmbedding1Ds")
829 _value_types.append(
"LogEmbeddingD<1>")
833 _plural_types.append(
"LogEmbedding2Ds")
834 _value_types.append(
"LogEmbeddingD<2>")
838 _plural_types.append(
"LogEmbedding3Ds")
839 _value_types.append(
"LogEmbeddingD<3>")
843 _plural_types.append(
"LogEmbedding4Ds")
844 _value_types.append(
"LogEmbeddingD<4>")
848 _plural_types.append(
"LogEmbedding5Ds")
849 _value_types.append(
"LogEmbeddingD<5>")
853 _plural_types.append(
"LogEmbedding6Ds")
854 _value_types.append(
"LogEmbeddingD<6>")
858 _plural_types.append(
"LogEmbeddingKDs")
859 _value_types.append(
"LogEmbeddingKD")
863 _plural_types.append(
"LogEmbeddingKDs")
864 _value_types.append(
"LogEmbeddingD<-1>")
868 _plural_types.append(
"GridIndex1Ds")
869 _value_types.append(
"GridIndex1D")
873 _plural_types.append(
"GridIndex2Ds")
874 _value_types.append(
"GridIndex2D")
878 _plural_types.append(
"GridIndex3Ds")
879 _value_types.append(
"GridIndex3D")
883 _plural_types.append(
"GridIndex4Ds")
884 _value_types.append(
"GridIndex4D")
888 _plural_types.append(
"GridIndex5Ds")
889 _value_types.append(
"GridIndex5D")
893 _plural_types.append(
"GridIndex6Ds")
894 _value_types.append(
"GridIndex6D")
898 _plural_types.append(
"GridIndex1Ds")
899 _value_types.append(
"GridIndexD<1>")
903 _plural_types.append(
"GridIndex2Ds")
904 _value_types.append(
"GridIndexD<2>")
908 _plural_types.append(
"GridIndex3Ds")
909 _value_types.append(
"GridIndexD<3>")
913 _plural_types.append(
"GridIndex4Ds")
914 _value_types.append(
"GridIndexD<4>")
918 _plural_types.append(
"GridIndex5Ds")
919 _value_types.append(
"GridIndexD<5>")
923 _plural_types.append(
"GridIndex6Ds")
924 _value_types.append(
"GridIndexD<6>")
928 _plural_types.append(
"GridIndexKDs")
929 _value_types.append(
"GridIndexKD")
933 _plural_types.append(
"GridIndexKDs")
934 _value_types.append(
"GridIndexD<-1>")
937 ExtendedGridIndex1Ds=list
938 _plural_types.append(
"ExtendedGridIndex1Ds")
939 _value_types.append(
"ExtendedGridIndex1D")
942 ExtendedGridIndex2Ds=list
943 _plural_types.append(
"ExtendedGridIndex2Ds")
944 _value_types.append(
"ExtendedGridIndex2D")
947 ExtendedGridIndex3Ds=list
948 _plural_types.append(
"ExtendedGridIndex3Ds")
949 _value_types.append(
"ExtendedGridIndex3D")
952 ExtendedGridIndex4Ds=list
953 _plural_types.append(
"ExtendedGridIndex4Ds")
954 _value_types.append(
"ExtendedGridIndex4D")
957 ExtendedGridIndex5Ds=list
958 _plural_types.append(
"ExtendedGridIndex5Ds")
959 _value_types.append(
"ExtendedGridIndex5D")
962 ExtendedGridIndex6Ds=list
963 _plural_types.append(
"ExtendedGridIndex6Ds")
964 _value_types.append(
"ExtendedGridIndex6D")
967 ExtendedGridIndex1Ds=list
968 _plural_types.append(
"ExtendedGridIndex1Ds")
969 _value_types.append(
"ExtendedGridIndexD<1>")
972 ExtendedGridIndex2Ds=list
973 _plural_types.append(
"ExtendedGridIndex2Ds")
974 _value_types.append(
"ExtendedGridIndexD<2>")
977 ExtendedGridIndex3Ds=list
978 _plural_types.append(
"ExtendedGridIndex3Ds")
979 _value_types.append(
"ExtendedGridIndexD<3>")
982 ExtendedGridIndex4Ds=list
983 _plural_types.append(
"ExtendedGridIndex4Ds")
984 _value_types.append(
"ExtendedGridIndexD<4>")
987 ExtendedGridIndex5Ds=list
988 _plural_types.append(
"ExtendedGridIndex5Ds")
989 _value_types.append(
"ExtendedGridIndexD<5>")
992 ExtendedGridIndex6Ds=list
993 _plural_types.append(
"ExtendedGridIndex6Ds")
994 _value_types.append(
"ExtendedGridIndexD<6>")
997 ExtendedGridIndexKDs=list
998 _plural_types.append(
"ExtendedGridIndexKDs")
999 _value_types.append(
"ExtendedGridIndexKD")
1002 ExtendedGridIndexKDs=list
1003 _plural_types.append(
"ExtendedGridIndexKDs")
1004 _value_types.append(
"ExtendedGridIndexD<-1>")
1007 BoundedGridRange1Ds=list
1008 _plural_types.append(
"BoundedGridRange1Ds")
1009 _value_types.append(
"BoundedGridRange1D")
1012 BoundedGridRange2Ds=list
1013 _plural_types.append(
"BoundedGridRange2Ds")
1014 _value_types.append(
"BoundedGridRange2D")
1017 BoundedGridRange3Ds=list
1018 _plural_types.append(
"BoundedGridRange3Ds")
1019 _value_types.append(
"BoundedGridRange3D")
1022 BoundedGridRange4Ds=list
1023 _plural_types.append(
"BoundedGridRange4Ds")
1024 _value_types.append(
"BoundedGridRange4D")
1027 BoundedGridRange5Ds=list
1028 _plural_types.append(
"BoundedGridRange5Ds")
1029 _value_types.append(
"BoundedGridRange5D")
1032 BoundedGridRange6Ds=list
1033 _plural_types.append(
"BoundedGridRange6Ds")
1034 _value_types.append(
"BoundedGridRange6D")
1037 BoundedGridRange1Ds=list
1038 _plural_types.append(
"BoundedGridRange1Ds")
1039 _value_types.append(
"BoundedGridRangeD<1>")
1042 BoundedGridRange2Ds=list
1043 _plural_types.append(
"BoundedGridRange2Ds")
1044 _value_types.append(
"BoundedGridRangeD<2>")
1047 BoundedGridRange3Ds=list
1048 _plural_types.append(
"BoundedGridRange3Ds")
1049 _value_types.append(
"BoundedGridRangeD<3>")
1052 BoundedGridRange4Ds=list
1053 _plural_types.append(
"BoundedGridRange4Ds")
1054 _value_types.append(
"BoundedGridRangeD<4>")
1057 BoundedGridRange5Ds=list
1058 _plural_types.append(
"BoundedGridRange5Ds")
1059 _value_types.append(
"BoundedGridRangeD<5>")
1062 BoundedGridRange6Ds=list
1063 _plural_types.append(
"BoundedGridRange6Ds")
1064 _value_types.append(
"BoundedGridRangeD<6>")
1067 BoundedGridRangeKDs=list
1068 _plural_types.append(
"BoundedGridRangeKDs")
1069 _value_types.append(
"BoundedGridRangeKD")
1072 BoundedGridRangeKDs=list
1073 _plural_types.append(
"BoundedGridRangeKDs")
1074 _value_types.append(
"BoundedGridRangeD<-1>")
1077 UnboundedGridRange1Ds=list
1078 _plural_types.append(
"UnboundedGridRange1Ds")
1079 _value_types.append(
"UnboundedGridRange1D")
1082 UnboundedGridRange2Ds=list
1083 _plural_types.append(
"UnboundedGridRange2Ds")
1084 _value_types.append(
"UnboundedGridRange2D")
1087 UnboundedGridRange3Ds=list
1088 _plural_types.append(
"UnboundedGridRange3Ds")
1089 _value_types.append(
"UnboundedGridRange3D")
1092 UnboundedGridRange4Ds=list
1093 _plural_types.append(
"UnboundedGridRange4Ds")
1094 _value_types.append(
"UnboundedGridRange4D")
1097 UnboundedGridRange5Ds=list
1098 _plural_types.append(
"UnboundedGridRange5Ds")
1099 _value_types.append(
"UnboundedGridRange5D")
1102 UnboundedGridRange6Ds=list
1103 _plural_types.append(
"UnboundedGridRange6Ds")
1104 _value_types.append(
"UnboundedGridRange6D")
1107 UnboundedGridRange1Ds=list
1108 _plural_types.append(
"UnboundedGridRange1Ds")
1109 _value_types.append(
"UnboundedGridRangeD<1>")
1112 UnboundedGridRange2Ds=list
1113 _plural_types.append(
"UnboundedGridRange2Ds")
1114 _value_types.append(
"UnboundedGridRangeD<2>")
1117 UnboundedGridRange3Ds=list
1118 _plural_types.append(
"UnboundedGridRange3Ds")
1119 _value_types.append(
"UnboundedGridRangeD<3>")
1122 UnboundedGridRange4Ds=list
1123 _plural_types.append(
"UnboundedGridRange4Ds")
1124 _value_types.append(
"UnboundedGridRangeD<4>")
1127 UnboundedGridRange5Ds=list
1128 _plural_types.append(
"UnboundedGridRange5Ds")
1129 _value_types.append(
"UnboundedGridRangeD<5>")
1132 UnboundedGridRange6Ds=list
1133 _plural_types.append(
"UnboundedGridRange6Ds")
1134 _value_types.append(
"UnboundedGridRangeD<6>")
1137 UnboundedGridRangeKDs=list
1138 _plural_types.append(
"UnboundedGridRangeKDs")
1139 _value_types.append(
"UnboundedGridRangeKD")
1142 UnboundedGridRangeKDs=list
1143 _plural_types.append(
"UnboundedGridRangeKDs")
1144 _value_types.append(
"UnboundedGridRangeD<-1>")
1148 _plural_types.append(
"LinearFit2Ds")
1149 _value_types.append(
"LinearFit2D")
1152 ParabolicFit2Ds=list
1153 _plural_types.append(
"ParabolicFit2Ds")
1154 _value_types.append(
"ParabolicFit2D")
1158 _plural_types.append(
"FixedXYZs")
1159 _value_types.append(
"FixedXYZ")
1161 class _GeometricPrimitive1D(object):
1162 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 1 > class."""
1164 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1166 def __init__(self, *args, **kwargs):
1167 raise AttributeError(
"No constructor defined")
1168 __repr__ = _swig_repr
1169 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive1D
1172 _IMP_algebra._GeometricPrimitive1D_swigregister(_GeometricPrimitive1D)
1173 class _GeometricPrimitive2D(object):
1174 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 2 > class."""
1176 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1178 def __init__(self, *args, **kwargs):
1179 raise AttributeError(
"No constructor defined")
1180 __repr__ = _swig_repr
1181 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive2D
1184 _IMP_algebra._GeometricPrimitive2D_swigregister(_GeometricPrimitive2D)
1185 class _GeometricPrimitive3D(object):
1186 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 3 > class."""
1188 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1190 def __init__(self, *args, **kwargs):
1191 raise AttributeError(
"No constructor defined")
1192 __repr__ = _swig_repr
1193 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive3D
1196 _IMP_algebra._GeometricPrimitive3D_swigregister(_GeometricPrimitive3D)
1197 class _GeometricPrimitive4D(object):
1198 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 4 > class."""
1200 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1202 def __init__(self, *args, **kwargs):
1203 raise AttributeError(
"No constructor defined")
1204 __repr__ = _swig_repr
1205 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive4D
1208 _IMP_algebra._GeometricPrimitive4D_swigregister(_GeometricPrimitive4D)
1209 class _GeometricPrimitive5D(object):
1210 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 5 > class."""
1212 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1214 def __init__(self, *args, **kwargs):
1215 raise AttributeError(
"No constructor defined")
1216 __repr__ = _swig_repr
1217 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive5D
1220 _IMP_algebra._GeometricPrimitive5D_swigregister(_GeometricPrimitive5D)
1221 class _GeometricPrimitive6D(object):
1222 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 6 > class."""
1224 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1226 def __init__(self, *args, **kwargs):
1227 raise AttributeError(
"No constructor defined")
1228 __repr__ = _swig_repr
1229 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive6D
1232 _IMP_algebra._GeometricPrimitive6D_swigregister(_GeometricPrimitive6D)
1233 class _GeometricPrimitiveKD(object):
1234 r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< -1 > class."""
1236 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1238 def __init__(self, *args, **kwargs):
1239 raise AttributeError(
"No constructor defined")
1240 __repr__ = _swig_repr
1241 __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitiveKD
1244 _IMP_algebra._GeometricPrimitiveKD_swigregister(_GeometricPrimitiveKD)
1247 _plural_types.append(
"Vector1Ds")
1248 _value_types.append(
"Vector1D")
1252 _plural_types.append(
"Vector2Ds")
1253 _value_types.append(
"Vector2D")
1257 _plural_types.append(
"Vector3Ds")
1258 _value_types.append(
"Vector3D")
1262 _plural_types.append(
"Vector4Ds")
1263 _value_types.append(
"Vector4D")
1267 _plural_types.append(
"Vector5Ds")
1268 _value_types.append(
"Vector5D")
1272 _plural_types.append(
"Vector6Ds")
1273 _value_types.append(
"Vector6D")
1277 _plural_types.append(
"Vector1Ds")
1278 _value_types.append(
"VectorD<1>")
1282 _plural_types.append(
"Vector2Ds")
1283 _value_types.append(
"VectorD<2>")
1287 _plural_types.append(
"Vector3Ds")
1288 _value_types.append(
"VectorD<3>")
1292 _plural_types.append(
"Vector4Ds")
1293 _value_types.append(
"VectorD<4>")
1297 _plural_types.append(
"Vector5Ds")
1298 _value_types.append(
"VectorD<5>")
1302 _plural_types.append(
"Vector6Ds")
1303 _value_types.append(
"VectorD<6>")
1307 _plural_types.append(
"VectorKDs")
1308 _value_types.append(
"VectorKD")
1312 _plural_types.append(
"VectorKDs")
1313 _value_types.append(
"VectorD<-1>")
1315 class _VectorBaseKD(_GeometricPrimitiveKD):
1316 r"""Proxy of C++ IMP::algebra::VectorBaseD< -1 > class."""
1318 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1319 __repr__ = _swig_repr
1322 r"""__init__(_VectorBaseKD self) -> _VectorBaseKD"""
1323 _IMP_algebra._VectorBaseKD_swiginit(self, _IMP_algebra.new__VectorBaseKD())
1325 def get_scalar_product(self, o):
1326 r"""get_scalar_product(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1327 return _IMP_algebra._VectorBaseKD_get_scalar_product(self, o)
1329 def get_squared_magnitude(self):
1330 r"""get_squared_magnitude(_VectorBaseKD self) -> double"""
1331 return _IMP_algebra._VectorBaseKD_get_squared_magnitude(self)
1333 def get_magnitude(self):
1334 r"""get_magnitude(_VectorBaseKD self) -> double"""
1335 return _IMP_algebra._VectorBaseKD_get_magnitude(self)
1338 r"""get_distance(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1339 return _IMP_algebra._VectorBaseKD_get_distance(self, o)
1341 def __mul__(self, o):
1342 r"""__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1343 return _IMP_algebra._VectorBaseKD___mul__(self, o)
1345 def __iadd__(self, o):
1346 r"""__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1347 return _IMP_algebra._VectorBaseKD___iadd__(self, o)
1349 def __isub__(self, o):
1350 r"""__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1351 return _IMP_algebra._VectorBaseKD___isub__(self, o)
1353 def __itruediv__(self, *args):
1354 return _IMP_algebra._VectorBaseKD___itruediv__(self, *args)
1355 __idiv__ = __itruediv__
1359 def __imul__(self, f):
1360 r"""__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1361 return _IMP_algebra._VectorBaseKD___imul__(self, f)
1363 def show(self, *args):
1365 show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
1366 show(_VectorBaseKD self, _ostream out=std::cout)
1368 return _IMP_algebra._VectorBaseKD_show(self, *args)
1370 def get_dimension(self):
1371 r"""get_dimension(_VectorBaseKD self) -> unsigned int"""
1372 return _IMP_algebra._VectorBaseKD_get_dimension(self)
1373 __swig_destroy__ = _IMP_algebra.delete__VectorBaseKD
1376 _IMP_algebra._VectorBaseKD_swigregister(_VectorBaseKD)
1377 class _VectorBase1D(_GeometricPrimitive1D):
1378 r"""Proxy of C++ IMP::algebra::VectorBaseD< 1 > class."""
1380 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1381 __repr__ = _swig_repr
1384 r"""__init__(_VectorBase1D self) -> _VectorBase1D"""
1385 _IMP_algebra._VectorBase1D_swiginit(self, _IMP_algebra.new__VectorBase1D())
1387 def get_scalar_product(self, o):
1388 r"""get_scalar_product(_VectorBase1D self, _VectorBase1D o) -> double"""
1389 return _IMP_algebra._VectorBase1D_get_scalar_product(self, o)
1391 def get_squared_magnitude(self):
1392 r"""get_squared_magnitude(_VectorBase1D self) -> double"""
1393 return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)
1395 def get_magnitude(self):
1396 r"""get_magnitude(_VectorBase1D self) -> double"""
1397 return _IMP_algebra._VectorBase1D_get_magnitude(self)
1400 r"""get_distance(_VectorBase1D self, _VectorBase1D o) -> double"""
1401 return _IMP_algebra._VectorBase1D_get_distance(self, o)
1403 def __mul__(self, o):
1404 r"""__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
1405 return _IMP_algebra._VectorBase1D___mul__(self, o)
1407 def __iadd__(self, o):
1408 r"""__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1409 return _IMP_algebra._VectorBase1D___iadd__(self, o)
1411 def __isub__(self, o):
1412 r"""__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1413 return _IMP_algebra._VectorBase1D___isub__(self, o)
1415 def __itruediv__(self, *args):
1416 return _IMP_algebra._VectorBase1D___itruediv__(self, *args)
1417 __idiv__ = __itruediv__
1421 def __imul__(self, f):
1422 r"""__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
1423 return _IMP_algebra._VectorBase1D___imul__(self, f)
1425 def show(self, *args):
1427 show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
1428 show(_VectorBase1D self, _ostream out=std::cout)
1430 return _IMP_algebra._VectorBase1D_show(self, *args)
1432 def get_dimension(self):
1433 r"""get_dimension(_VectorBase1D self) -> unsigned int"""
1434 return _IMP_algebra._VectorBase1D_get_dimension(self)
1435 __swig_destroy__ = _IMP_algebra.delete__VectorBase1D
1438 _IMP_algebra._VectorBase1D_swigregister(_VectorBase1D)
1439 class _VectorBase2D(_GeometricPrimitive2D):
1440 r"""Proxy of C++ IMP::algebra::VectorBaseD< 2 > class."""
1442 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1443 __repr__ = _swig_repr
1446 r"""__init__(_VectorBase2D self) -> _VectorBase2D"""
1447 _IMP_algebra._VectorBase2D_swiginit(self, _IMP_algebra.new__VectorBase2D())
1449 def get_scalar_product(self, o):
1450 r"""get_scalar_product(_VectorBase2D self, _VectorBase2D o) -> double"""
1451 return _IMP_algebra._VectorBase2D_get_scalar_product(self, o)
1453 def get_squared_magnitude(self):
1454 r"""get_squared_magnitude(_VectorBase2D self) -> double"""
1455 return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)
1457 def get_magnitude(self):
1458 r"""get_magnitude(_VectorBase2D self) -> double"""
1459 return _IMP_algebra._VectorBase2D_get_magnitude(self)
1462 r"""get_distance(_VectorBase2D self, _VectorBase2D o) -> double"""
1463 return _IMP_algebra._VectorBase2D_get_distance(self, o)
1465 def __mul__(self, o):
1466 r"""__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
1467 return _IMP_algebra._VectorBase2D___mul__(self, o)
1469 def __iadd__(self, o):
1470 r"""__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1471 return _IMP_algebra._VectorBase2D___iadd__(self, o)
1473 def __isub__(self, o):
1474 r"""__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1475 return _IMP_algebra._VectorBase2D___isub__(self, o)
1477 def __itruediv__(self, *args):
1478 return _IMP_algebra._VectorBase2D___itruediv__(self, *args)
1479 __idiv__ = __itruediv__
1483 def __imul__(self, f):
1484 r"""__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
1485 return _IMP_algebra._VectorBase2D___imul__(self, f)
1487 def show(self, *args):
1489 show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
1490 show(_VectorBase2D self, _ostream out=std::cout)
1492 return _IMP_algebra._VectorBase2D_show(self, *args)
1494 def get_dimension(self):
1495 r"""get_dimension(_VectorBase2D self) -> unsigned int"""
1496 return _IMP_algebra._VectorBase2D_get_dimension(self)
1497 __swig_destroy__ = _IMP_algebra.delete__VectorBase2D
1500 _IMP_algebra._VectorBase2D_swigregister(_VectorBase2D)
1501 class _VectorBase3D(_GeometricPrimitive3D):
1502 r"""Proxy of C++ IMP::algebra::VectorBaseD< 3 > class."""
1504 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1505 __repr__ = _swig_repr
1508 r"""__init__(_VectorBase3D self) -> _VectorBase3D"""
1509 _IMP_algebra._VectorBase3D_swiginit(self, _IMP_algebra.new__VectorBase3D())
1511 def get_scalar_product(self, o):
1512 r"""get_scalar_product(_VectorBase3D self, _VectorBase3D o) -> double"""
1513 return _IMP_algebra._VectorBase3D_get_scalar_product(self, o)
1515 def get_squared_magnitude(self):
1516 r"""get_squared_magnitude(_VectorBase3D self) -> double"""
1517 return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)
1519 def get_magnitude(self):
1520 r"""get_magnitude(_VectorBase3D self) -> double"""
1521 return _IMP_algebra._VectorBase3D_get_magnitude(self)
1524 r"""get_distance(_VectorBase3D self, _VectorBase3D o) -> double"""
1525 return _IMP_algebra._VectorBase3D_get_distance(self, o)
1527 def __mul__(self, o):
1528 r"""__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
1529 return _IMP_algebra._VectorBase3D___mul__(self, o)
1531 def __iadd__(self, o):
1532 r"""__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1533 return _IMP_algebra._VectorBase3D___iadd__(self, o)
1535 def __isub__(self, o):
1536 r"""__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1537 return _IMP_algebra._VectorBase3D___isub__(self, o)
1539 def __itruediv__(self, *args):
1540 return _IMP_algebra._VectorBase3D___itruediv__(self, *args)
1541 __idiv__ = __itruediv__
1545 def __imul__(self, f):
1546 r"""__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
1547 return _IMP_algebra._VectorBase3D___imul__(self, f)
1549 def show(self, *args):
1551 show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
1552 show(_VectorBase3D self, _ostream out=std::cout)
1554 return _IMP_algebra._VectorBase3D_show(self, *args)
1556 def get_dimension(self):
1557 r"""get_dimension(_VectorBase3D self) -> unsigned int"""
1558 return _IMP_algebra._VectorBase3D_get_dimension(self)
1559 __swig_destroy__ = _IMP_algebra.delete__VectorBase3D
1562 _IMP_algebra._VectorBase3D_swigregister(_VectorBase3D)
1563 class _VectorBase4D(_GeometricPrimitive4D):
1564 r"""Proxy of C++ IMP::algebra::VectorBaseD< 4 > class."""
1566 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1567 __repr__ = _swig_repr
1570 r"""__init__(_VectorBase4D self) -> _VectorBase4D"""
1571 _IMP_algebra._VectorBase4D_swiginit(self, _IMP_algebra.new__VectorBase4D())
1573 def get_scalar_product(self, o):
1574 r"""get_scalar_product(_VectorBase4D self, _VectorBase4D o) -> double"""
1575 return _IMP_algebra._VectorBase4D_get_scalar_product(self, o)
1577 def get_squared_magnitude(self):
1578 r"""get_squared_magnitude(_VectorBase4D self) -> double"""
1579 return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)
1581 def get_magnitude(self):
1582 r"""get_magnitude(_VectorBase4D self) -> double"""
1583 return _IMP_algebra._VectorBase4D_get_magnitude(self)
1586 r"""get_distance(_VectorBase4D self, _VectorBase4D o) -> double"""
1587 return _IMP_algebra._VectorBase4D_get_distance(self, o)
1589 def __mul__(self, o):
1590 r"""__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
1591 return _IMP_algebra._VectorBase4D___mul__(self, o)
1593 def __iadd__(self, o):
1594 r"""__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1595 return _IMP_algebra._VectorBase4D___iadd__(self, o)
1597 def __isub__(self, o):
1598 r"""__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1599 return _IMP_algebra._VectorBase4D___isub__(self, o)
1601 def __itruediv__(self, *args):
1602 return _IMP_algebra._VectorBase4D___itruediv__(self, *args)
1603 __idiv__ = __itruediv__
1607 def __imul__(self, f):
1608 r"""__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
1609 return _IMP_algebra._VectorBase4D___imul__(self, f)
1611 def show(self, *args):
1613 show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
1614 show(_VectorBase4D self, _ostream out=std::cout)
1616 return _IMP_algebra._VectorBase4D_show(self, *args)
1618 def get_dimension(self):
1619 r"""get_dimension(_VectorBase4D self) -> unsigned int"""
1620 return _IMP_algebra._VectorBase4D_get_dimension(self)
1621 __swig_destroy__ = _IMP_algebra.delete__VectorBase4D
1624 _IMP_algebra._VectorBase4D_swigregister(_VectorBase4D)
1625 class _VectorBase5D(_GeometricPrimitive5D):
1626 r"""Proxy of C++ IMP::algebra::VectorBaseD< 5 > class."""
1628 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1629 __repr__ = _swig_repr
1632 r"""__init__(_VectorBase5D self) -> _VectorBase5D"""
1633 _IMP_algebra._VectorBase5D_swiginit(self, _IMP_algebra.new__VectorBase5D())
1635 def get_scalar_product(self, o):
1636 r"""get_scalar_product(_VectorBase5D self, _VectorBase5D o) -> double"""
1637 return _IMP_algebra._VectorBase5D_get_scalar_product(self, o)
1639 def get_squared_magnitude(self):
1640 r"""get_squared_magnitude(_VectorBase5D self) -> double"""
1641 return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)
1643 def get_magnitude(self):
1644 r"""get_magnitude(_VectorBase5D self) -> double"""
1645 return _IMP_algebra._VectorBase5D_get_magnitude(self)
1648 r"""get_distance(_VectorBase5D self, _VectorBase5D o) -> double"""
1649 return _IMP_algebra._VectorBase5D_get_distance(self, o)
1651 def __mul__(self, o):
1652 r"""__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
1653 return _IMP_algebra._VectorBase5D___mul__(self, o)
1655 def __iadd__(self, o):
1656 r"""__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1657 return _IMP_algebra._VectorBase5D___iadd__(self, o)
1659 def __isub__(self, o):
1660 r"""__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1661 return _IMP_algebra._VectorBase5D___isub__(self, o)
1663 def __itruediv__(self, *args):
1664 return _IMP_algebra._VectorBase5D___itruediv__(self, *args)
1665 __idiv__ = __itruediv__
1669 def __imul__(self, f):
1670 r"""__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
1671 return _IMP_algebra._VectorBase5D___imul__(self, f)
1673 def show(self, *args):
1675 show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
1676 show(_VectorBase5D self, _ostream out=std::cout)
1678 return _IMP_algebra._VectorBase5D_show(self, *args)
1680 def get_dimension(self):
1681 r"""get_dimension(_VectorBase5D self) -> unsigned int"""
1682 return _IMP_algebra._VectorBase5D_get_dimension(self)
1683 __swig_destroy__ = _IMP_algebra.delete__VectorBase5D
1686 _IMP_algebra._VectorBase5D_swigregister(_VectorBase5D)
1687 class _VectorBase6D(_GeometricPrimitive6D):
1688 r"""Proxy of C++ IMP::algebra::VectorBaseD< 6 > class."""
1690 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1691 __repr__ = _swig_repr
1694 r"""__init__(_VectorBase6D self) -> _VectorBase6D"""
1695 _IMP_algebra._VectorBase6D_swiginit(self, _IMP_algebra.new__VectorBase6D())
1697 def get_scalar_product(self, o):
1698 r"""get_scalar_product(_VectorBase6D self, _VectorBase6D o) -> double"""
1699 return _IMP_algebra._VectorBase6D_get_scalar_product(self, o)
1701 def get_squared_magnitude(self):
1702 r"""get_squared_magnitude(_VectorBase6D self) -> double"""
1703 return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)
1705 def get_magnitude(self):
1706 r"""get_magnitude(_VectorBase6D self) -> double"""
1707 return _IMP_algebra._VectorBase6D_get_magnitude(self)
1710 r"""get_distance(_VectorBase6D self, _VectorBase6D o) -> double"""
1711 return _IMP_algebra._VectorBase6D_get_distance(self, o)
1713 def __mul__(self, o):
1714 r"""__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
1715 return _IMP_algebra._VectorBase6D___mul__(self, o)
1717 def __iadd__(self, o):
1718 r"""__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1719 return _IMP_algebra._VectorBase6D___iadd__(self, o)
1721 def __isub__(self, o):
1722 r"""__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1723 return _IMP_algebra._VectorBase6D___isub__(self, o)
1725 def __itruediv__(self, *args):
1726 return _IMP_algebra._VectorBase6D___itruediv__(self, *args)
1727 __idiv__ = __itruediv__
1731 def __imul__(self, f):
1732 r"""__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
1733 return _IMP_algebra._VectorBase6D___imul__(self, f)
1735 def show(self, *args):
1737 show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
1738 show(_VectorBase6D self, _ostream out=std::cout)
1740 return _IMP_algebra._VectorBase6D_show(self, *args)
1742 def get_dimension(self):
1743 r"""get_dimension(_VectorBase6D self) -> unsigned int"""
1744 return _IMP_algebra._VectorBase6D_get_dimension(self)
1745 __swig_destroy__ = _IMP_algebra.delete__VectorBase6D
1748 _IMP_algebra._VectorBase6D_swigregister(_VectorBase6D)
1751 r"""get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
1752 return _IMP_algebra.get_basis_vector_kd(D, coordinate)
1755 r"""get_zero_vector_kd(int D) -> VectorKD"""
1756 return _IMP_algebra.get_zero_vector_kd(D)
1759 r"""get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD"""
1760 return _IMP_algebra.get_ones_vector_kd(D, v)
1763 r"""get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
1764 return _IMP_algebra.get_vector_product(p1, p2)
1767 r"""get_orthogonal_vector(Vector3D v) -> Vector3D"""
1768 return _IMP_algebra.get_orthogonal_vector(v)
1771 r"""get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
1772 return _IMP_algebra.get_centroid(ps)
1775 r"""get_radius_of_gyration(IMP::algebra::Vector3Ds const & ps) -> double"""
1776 return _IMP_algebra.get_radius_of_gyration(ps)
1777 class Rotation3D(_GeometricPrimitive3D):
1778 r"""Proxy of C++ IMP::algebra::Rotation3D class."""
1780 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1782 def __init__(self, *args):
1784 __init__(Rotation3D self, Rotation3D rot) -> Rotation3D
1785 __init__(Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
1786 __init__(Rotation3D self) -> Rotation3D
1787 __init__(Rotation3D self, double a, double b, double c, double d) -> Rotation3D
1789 _IMP_algebra.Rotation3D_swiginit(self, _IMP_algebra.new_Rotation3D(*args))
1790 __swig_destroy__ = _IMP_algebra.delete_Rotation3D
1792 def get_rotated_no_cache(self, o):
1793 r"""get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
1794 return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, o)
1796 def get_rotated_one_coordinate_no_cache(self, o, coord):
1797 r"""get_rotated_one_coordinate_no_cache(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1798 return _IMP_algebra.Rotation3D_get_rotated_one_coordinate_no_cache(self, o, coord)
1800 def get_rotated(self, o):
1801 r"""get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
1802 return _IMP_algebra.Rotation3D_get_rotated(self, o)
1804 def get_rotated_adjoint(self, v, Dw):
1805 r"""get_rotated_adjoint(Rotation3D self, Vector3D v, Vector3D Dw) -> _RotatedVector3DAdjoint"""
1806 return _IMP_algebra.Rotation3D_get_rotated_adjoint(self, v, Dw)
1808 def get_rotated_one_coordinate(self, o, coord):
1809 r"""get_rotated_one_coordinate(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1810 return _IMP_algebra.Rotation3D_get_rotated_one_coordinate(self, o, coord)
1812 def get_rotation_matrix_row(self, i):
1813 r"""get_rotation_matrix_row(Rotation3D self, int i) -> Vector3D"""
1814 return _IMP_algebra.Rotation3D_get_rotation_matrix_row(self, i)
1816 def show(self, *args):
1817 r"""show(Rotation3D self, _ostream out=std::cout)"""
1818 return _IMP_algebra.Rotation3D_show(self, *args)
1820 def get_inverse(self):
1821 r"""get_inverse(Rotation3D self) -> Rotation3D"""
1822 return _IMP_algebra.Rotation3D_get_inverse(self)
1824 def get_quaternion(self):
1825 r"""get_quaternion(Rotation3D self) -> Vector4D"""
1826 return _IMP_algebra.Rotation3D_get_quaternion(self)
1828 def __mul__(self, *args):
1830 __mul__(Rotation3D self, Vector3D v) -> Vector3D
1831 __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
1833 return _IMP_algebra.Rotation3D___mul__(self, *args)
1835 def __truediv__(self, *args):
1836 return _IMP_algebra.Rotation3D___truediv__(self, *args)
1837 __div__ = __truediv__
1841 def get_gradient_of_rotated(self, v, i, wrt_unnorm=False):
1842 r"""get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=False) -> Vector3D"""
1843 return _IMP_algebra.Rotation3D_get_gradient_of_rotated(self, v, i, wrt_unnorm)
1845 def get_jacobian_of_rotated(self, v, wrt_unnorm=False):
1846 r"""get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1847 return _IMP_algebra.Rotation3D_get_jacobian_of_rotated(self, v, wrt_unnorm)
1849 def get_is_valid(self):
1850 r"""get_is_valid(Rotation3D self) -> bool"""
1851 return _IMP_algebra.Rotation3D_get_is_valid(self)
1854 r"""__str__(Rotation3D self) -> std::string"""
1855 return _IMP_algebra.Rotation3D___str__(self)
1858 r"""__repr__(Rotation3D self) -> std::string"""
1859 return _IMP_algebra.Rotation3D___repr__(self)
1861 def _get_as_binary(self):
1862 r"""_get_as_binary(Rotation3D self) -> PyObject *"""
1863 return _IMP_algebra.Rotation3D__get_as_binary(self)
1865 def _set_from_binary(self, p):
1866 r"""_set_from_binary(Rotation3D self, PyObject * p)"""
1867 return _IMP_algebra.Rotation3D__set_from_binary(self, p)
1869 def __getstate__(self):
1870 p = self._get_as_binary()
1871 if len(self.__dict__) > 1:
1872 d = self.__dict__.copy()
1877 def __setstate__(self, p):
1878 if not hasattr(self,
'this'):
1880 if isinstance(p, tuple):
1882 self.__dict__.update(d)
1883 return self._set_from_binary(p)
1886 __truediv__ = __div__
1890 _IMP_algebra.Rotation3D_swigregister(Rotation3D)
1893 r"""get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1894 return _IMP_algebra.get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm)
1897 r"""get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1898 return _IMP_algebra.get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm)
1901 r"""get_identity_rotation_3d() -> Rotation3D"""
1902 return _IMP_algebra.get_identity_rotation_3d()
1905 r"""get_rotation_about_normalized_axis(Vector3D axis_norm, double angle) -> Rotation3D"""
1906 return _IMP_algebra.get_rotation_about_normalized_axis(axis_norm, angle)
1909 r"""get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
1910 return _IMP_algebra.get_rotation_about_axis(axis, angle)
1913 r"""get_rotation_taking_first_to_second(Vector3D v1, Vector3D v2) -> Rotation3D"""
1914 return _IMP_algebra.get_rotation_taking_first_to_second(v1, v2)
1918 get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22) -> Rotation3D
1919 get_rotation_from_matrix(Eigen::Matrix3d m) -> Rotation3D
1921 return _IMP_algebra.get_rotation_from_matrix(*args)
1925 get_random_rotation_3d() -> Rotation3D
1926 get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
1928 return _IMP_algebra.get_random_rotation_3d(*args)
1931 r"""get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
1932 return _IMP_algebra.get_uniform_cover_rotations_3d(num_points)
1935 r"""get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
1936 return _IMP_algebra.get_uniformly_sampled_rotations(delta)
1939 r"""get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
1940 return _IMP_algebra.get_rotation_from_vector4d(v)
1943 r"""get_rotation_from_fixed_xyz(double xr, double yr, double zr) -> Rotation3D"""
1944 return _IMP_algebra.get_rotation_from_fixed_xyz(xr, yr, zr)
1947 r"""get_rotation_from_fixed_zxz(double phi, double theta, double psi) -> Rotation3D"""
1948 return _IMP_algebra.get_rotation_from_fixed_zxz(phi, theta, psi)
1951 r"""get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
1952 return _IMP_algebra.get_rotation_from_fixed_zyz(Rot, Tilt, Psi)
1953 class FixedXYZ(_GeometricPrimitive3D):
1954 r"""Proxy of C++ IMP::algebra::FixedXYZ class."""
1956 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1958 def __init__(self, *args):
1960 __init__(FixedXYZ self) -> FixedXYZ
1961 __init__(FixedXYZ self, double x, double y, double z) -> FixedXYZ
1963 _IMP_algebra.FixedXYZ_swiginit(self, _IMP_algebra.new_FixedXYZ(*args))
1966 r"""get_x(FixedXYZ self) -> double"""
1967 return _IMP_algebra.FixedXYZ_get_x(self)
1970 r"""get_y(FixedXYZ self) -> double"""
1971 return _IMP_algebra.FixedXYZ_get_y(self)
1974 r"""get_z(FixedXYZ self) -> double"""
1975 return _IMP_algebra.FixedXYZ_get_z(self)
1977 def show(self, *args):
1978 r"""show(FixedXYZ self, _ostream out=std::cout)"""
1979 return _IMP_algebra.FixedXYZ_show(self, *args)
1982 r"""__str__(FixedXYZ self) -> std::string"""
1983 return _IMP_algebra.FixedXYZ___str__(self)
1986 r"""__repr__(FixedXYZ self) -> std::string"""
1987 return _IMP_algebra.FixedXYZ___repr__(self)
1989 def _get_as_binary(self):
1990 r"""_get_as_binary(FixedXYZ self) -> PyObject *"""
1991 return _IMP_algebra.FixedXYZ__get_as_binary(self)
1993 def _set_from_binary(self, p):
1994 r"""_set_from_binary(FixedXYZ self, PyObject * p)"""
1995 return _IMP_algebra.FixedXYZ__set_from_binary(self, p)
1997 def __getstate__(self):
1998 p = self._get_as_binary()
1999 if len(self.__dict__) > 1:
2000 d = self.__dict__.copy()
2005 def __setstate__(self, p):
2006 if not hasattr(self,
'this'):
2008 if isinstance(p, tuple):
2010 self.__dict__.update(d)
2011 return self._set_from_binary(p)
2013 __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
2016 _IMP_algebra.FixedXYZ_swigregister(FixedXYZ)
2019 r"""get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
2020 return _IMP_algebra.get_fixed_xyz_from_rotation(r)
2023 r"""get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
2024 return _IMP_algebra.get_interpolated(a, b, f)
2027 r"""get_rotation_from_x_y_axes(Vector3D x, Vector3D y) -> Rotation3D"""
2028 return _IMP_algebra.get_rotation_from_x_y_axes(x, y)
2031 r"""get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
2032 return _IMP_algebra.get_axis_and_angle(rot)
2035 r"""get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
2036 return _IMP_algebra.get_unit_bounding_box_kd(d)
2039 r"""get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
2040 return _IMP_algebra.get_cube_kd(d, radius)
2043 r"""get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
2044 return _IMP_algebra.get_edges(arg1)
2045 class Transformation3D(_GeometricPrimitive3D):
2046 r"""Proxy of C++ IMP::algebra::Transformation3D class."""
2048 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2050 def __init__(self, *args):
2052 __init__(Transformation3D self, Transformation3D arg2) -> Transformation3D
2053 __init__(Transformation3D self) -> Transformation3D
2054 __init__(Transformation3D self, Rotation3D r, Vector3D t=IMP::algebra::Vector3D(0, 0, 0)) -> Transformation3D
2055 __init__(Transformation3D self, Vector3D t) -> Transformation3D
2057 _IMP_algebra.Transformation3D_swiginit(self, _IMP_algebra.new_Transformation3D(*args))
2058 __swig_destroy__ = _IMP_algebra.delete_Transformation3D
2060 def get_transformed(self, o):
2061 r"""get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
2062 return _IMP_algebra.Transformation3D_get_transformed(self, o)
2064 def get_transformed_adjoint(self, v, Dw):
2065 r"""get_transformed_adjoint(Transformation3D self, Vector3D v, Vector3D Dw) -> _TransformedVector3DAdjoint"""
2066 return _IMP_algebra.Transformation3D_get_transformed_adjoint(self, v, Dw)
2068 def __mul__(self, *args):
2070 __mul__(Transformation3D self, Vector3D v) -> Vector3D
2071 __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
2073 return _IMP_algebra.Transformation3D___mul__(self, *args)
2075 def __truediv__(self, *args):
2076 return _IMP_algebra.Transformation3D___truediv__(self, *args)
2077 __div__ = __truediv__
2081 def get_rotation(self):
2082 r"""get_rotation(Transformation3D self) -> Rotation3D"""
2083 return _IMP_algebra.Transformation3D_get_rotation(self)
2085 def get_translation(self):
2086 r"""get_translation(Transformation3D self) -> Vector3D"""
2087 return _IMP_algebra.Transformation3D_get_translation(self)
2089 def show(self, *args):
2090 r"""show(Transformation3D self, _ostream out=std::cout)"""
2091 return _IMP_algebra.Transformation3D_show(self, *args)
2093 def get_inverse(self):
2094 r"""get_inverse(Transformation3D self) -> Transformation3D"""
2095 return _IMP_algebra.Transformation3D_get_inverse(self)
2097 def get_is_valid(self):
2098 r"""get_is_valid(Transformation3D self) -> bool"""
2099 return _IMP_algebra.Transformation3D_get_is_valid(self)
2102 r"""__str__(Transformation3D self) -> std::string"""
2103 return _IMP_algebra.Transformation3D___str__(self)
2106 r"""__repr__(Transformation3D self) -> std::string"""
2107 return _IMP_algebra.Transformation3D___repr__(self)
2109 def _get_as_binary(self):
2110 r"""_get_as_binary(Transformation3D self) -> PyObject *"""
2111 return _IMP_algebra.Transformation3D__get_as_binary(self)
2113 def _set_from_binary(self, p):
2114 r"""_set_from_binary(Transformation3D self, PyObject * p)"""
2115 return _IMP_algebra.Transformation3D__set_from_binary(self, p)
2117 def __getstate__(self):
2118 p = self._get_as_binary()
2119 if len(self.__dict__) > 1:
2120 d = self.__dict__.copy()
2125 def __setstate__(self, p):
2126 if not hasattr(self,
'this'):
2128 if isinstance(p, tuple):
2130 self.__dict__.update(d)
2131 return self._set_from_binary(p)
2134 __truediv__ = __div__
2138 _IMP_algebra.Transformation3D_swigregister(Transformation3D)
2141 r"""get_identity_transformation_3d() -> Transformation3D"""
2142 return _IMP_algebra.get_identity_transformation_3d()
2146 compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
2147 compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
2149 return _IMP_algebra.compose_adjoint(*args)
2152 r"""get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
2153 return _IMP_algebra.get_transformation_3d(t2d)
2156 r"""get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D"""
2157 return _IMP_algebra.get_random_local_transformation(origin, max_translation, max_angle_in_rad)
2158 class Rotation2D(_GeometricPrimitive2D):
2159 r"""Proxy of C++ IMP::algebra::Rotation2D class."""
2161 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2163 def __init__(self, *args):
2165 __init__(Rotation2D self) -> Rotation2D
2166 __init__(Rotation2D self, double angle) -> Rotation2D
2168 _IMP_algebra.Rotation2D_swiginit(self, _IMP_algebra.new_Rotation2D(*args))
2170 def get_rotated(self, *args):
2172 get_rotated(Rotation2D self, Vector2D o) -> Vector2D
2173 get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
2175 return _IMP_algebra.Rotation2D_get_rotated(self, *args)
2177 def get_inverse(self):
2178 r"""get_inverse(Rotation2D self) -> Rotation2D"""
2179 return _IMP_algebra.Rotation2D_get_inverse(self)
2181 def set_angle(self, angle):
2182 r"""set_angle(Rotation2D self, double angle)"""
2183 return _IMP_algebra.Rotation2D_set_angle(self, angle)
2186 r"""get_angle(Rotation2D self) -> double"""
2187 return _IMP_algebra.Rotation2D_get_angle(self)
2189 def show(self, *args):
2190 r"""show(Rotation2D self, _ostream out=std::cout)"""
2191 return _IMP_algebra.Rotation2D_show(self, *args)
2194 r"""__str__(Rotation2D self) -> std::string"""
2195 return _IMP_algebra.Rotation2D___str__(self)
2198 r"""__repr__(Rotation2D self) -> std::string"""
2199 return _IMP_algebra.Rotation2D___repr__(self)
2201 def _get_as_binary(self):
2202 r"""_get_as_binary(Rotation2D self) -> PyObject *"""
2203 return _IMP_algebra.Rotation2D__get_as_binary(self)
2205 def _set_from_binary(self, p):
2206 r"""_set_from_binary(Rotation2D self, PyObject * p)"""
2207 return _IMP_algebra.Rotation2D__set_from_binary(self, p)
2209 def __getstate__(self):
2210 p = self._get_as_binary()
2211 if len(self.__dict__) > 1:
2212 d = self.__dict__.copy()
2217 def __setstate__(self, p):
2218 if not hasattr(self,
'this'):
2220 if isinstance(p, tuple):
2222 self.__dict__.update(d)
2223 return self._set_from_binary(p)
2225 __swig_destroy__ = _IMP_algebra.delete_Rotation2D
2228 _IMP_algebra.Rotation2D_swigregister(Rotation2D)
2231 r"""get_identity_rotation_2d() -> Rotation2D"""
2232 return _IMP_algebra.get_identity_rotation_2d()
2235 r"""get_random_rotation_2d() -> Rotation2D"""
2236 return _IMP_algebra.get_random_rotation_2d()
2239 r"""get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
2240 return _IMP_algebra.get_rotation_to_x_axis(v)
2241 class Transformation2D(_GeometricPrimitive2D):
2242 r"""Proxy of C++ IMP::algebra::Transformation2D class."""
2244 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2246 def __init__(self, *args):
2248 __init__(Transformation2D self, Transformation2D arg2) -> Transformation2D
2249 __init__(Transformation2D self) -> Transformation2D
2250 __init__(Transformation2D self, Rotation2D r, Vector2D t=IMP::algebra::Vector2D(0.0, 0.0)) -> Transformation2D
2251 __init__(Transformation2D self, Vector2D t) -> Transformation2D
2253 _IMP_algebra.Transformation2D_swiginit(self, _IMP_algebra.new_Transformation2D(*args))
2254 __swig_destroy__ = _IMP_algebra.delete_Transformation2D
2256 def get_transformed(self, o):
2257 r"""get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
2258 return _IMP_algebra.Transformation2D_get_transformed(self, o)
2260 def __mul__(self, *args):
2262 __mul__(Transformation2D self, Vector2D v) -> Vector2D
2263 __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
2265 return _IMP_algebra.Transformation2D___mul__(self, *args)
2267 def __truediv__(self, *args):
2268 return _IMP_algebra.Transformation2D___truediv__(self, *args)
2269 __div__ = __truediv__
2273 def get_rotation(self):
2274 r"""get_rotation(Transformation2D self) -> Rotation2D"""
2275 return _IMP_algebra.Transformation2D_get_rotation(self)
2277 def set_rotation(self, angle):
2278 r"""set_rotation(Transformation2D self, double angle)"""
2279 return _IMP_algebra.Transformation2D_set_rotation(self, angle)
2281 def get_translation(self):
2282 r"""get_translation(Transformation2D self) -> Vector2D"""
2283 return _IMP_algebra.Transformation2D_get_translation(self)
2285 def set_translation(self, v):
2286 r"""set_translation(Transformation2D self, Vector2D v)"""
2287 return _IMP_algebra.Transformation2D_set_translation(self, v)
2289 def show(self, *args):
2290 r"""show(Transformation2D self, _ostream out=std::cout)"""
2291 return _IMP_algebra.Transformation2D_show(self, *args)
2293 def get_inverse(self):
2294 r"""get_inverse(Transformation2D self) -> Transformation2D"""
2295 return _IMP_algebra.Transformation2D_get_inverse(self)
2298 r"""__str__(Transformation2D self) -> std::string"""
2299 return _IMP_algebra.Transformation2D___str__(self)
2302 r"""__repr__(Transformation2D self) -> std::string"""
2303 return _IMP_algebra.Transformation2D___repr__(self)
2305 def _get_as_binary(self):
2306 r"""_get_as_binary(Transformation2D self) -> PyObject *"""
2307 return _IMP_algebra.Transformation2D__get_as_binary(self)
2309 def _set_from_binary(self, p):
2310 r"""_set_from_binary(Transformation2D self, PyObject * p)"""
2311 return _IMP_algebra.Transformation2D__set_from_binary(self, p)
2313 def __getstate__(self):
2314 p = self._get_as_binary()
2315 if len(self.__dict__) > 1:
2316 d = self.__dict__.copy()
2321 def __setstate__(self, p):
2322 if not hasattr(self,
'this'):
2324 if isinstance(p, tuple):
2326 self.__dict__.update(d)
2327 return self._set_from_binary(p)
2330 __truediv__ = __div__
2334 _IMP_algebra.Transformation2D_swigregister(Transformation2D)
2337 r"""get_identity_transformation_2d() -> Transformation2D"""
2338 return _IMP_algebra.get_identity_transformation_2d()
2342 get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
2343 get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
2345 return _IMP_algebra.get_rotation_about_point(*args)
2349 compose(Rotation3D a, Rotation3D b) -> Rotation3D
2350 compose(Transformation3D a, Transformation3D b) -> Transformation3D
2351 compose(Rotation2D a, Rotation2D b) -> Rotation2D
2352 compose(Transformation2D a, Transformation2D b) -> Transformation2D
2354 return _IMP_algebra.compose(*args)
2356 def get_unit_sphere_kd(d):
2357 r"""get_unit_sphere_kd(unsigned int d) -> SphereKD"""
2358 return _IMP_algebra.get_unit_sphere_kd(d)
2362 get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
2363 get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
2365 return _IMP_algebra.get_enclosing_sphere(*args)
2368 r"""get_ball_radius_from_volume_3d(double volume) -> double"""
2369 return _IMP_algebra.get_ball_radius_from_volume_3d(volume)
2372 r"""get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
2373 return _IMP_algebra.get_surface_area_and_volume(ss)
2376 r"""get_simplified_from_volume(IMP::algebra::Sphere3Ds _in, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
2377 return _IMP_algebra.get_simplified_from_volume(_in, maximum_allowed_error_angstroms)
2379 def get_triangle_3d(s):
2380 r"""get_triangle_3d(UnitSimplex3D s) -> Triangle3D"""
2381 return _IMP_algebra.get_triangle_3d(s)
2382 class _UnitSimplexBaseKD(_GeometricPrimitiveKD):
2383 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< -1 > class."""
2385 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2387 def __init__(self, *args, **kwargs):
2388 raise AttributeError(
"No constructor defined - class is abstract")
2389 __repr__ = _swig_repr
2391 def get_dimension(self):
2392 r"""get_dimension(_UnitSimplexBaseKD self) -> int"""
2393 return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)
2395 def get_barycenter(self):
2396 r"""get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
2397 return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)
2399 def get_contains(self, *args):
2400 r"""get_contains(_UnitSimplexBaseKD self, VectorKD p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2401 return _IMP_algebra._UnitSimplexBaseKD_get_contains(self, *args)
2402 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBaseKD
2405 _IMP_algebra._UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
2406 class _UnitSimplexBase1D(_GeometricPrimitive1D):
2407 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 1 > class."""
2409 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2411 def __init__(self, *args, **kwargs):
2412 raise AttributeError(
"No constructor defined - class is abstract")
2413 __repr__ = _swig_repr
2415 def get_dimension(self):
2416 r"""get_dimension(_UnitSimplexBase1D self) -> int"""
2417 return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)
2419 def get_barycenter(self):
2420 r"""get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
2421 return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)
2423 def get_contains(self, *args):
2424 r"""get_contains(_UnitSimplexBase1D self, Vector1D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2425 return _IMP_algebra._UnitSimplexBase1D_get_contains(self, *args)
2426 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase1D
2429 _IMP_algebra._UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
2430 class _UnitSimplexBase2D(_GeometricPrimitive2D):
2431 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 2 > class."""
2433 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2435 def __init__(self, *args, **kwargs):
2436 raise AttributeError(
"No constructor defined - class is abstract")
2437 __repr__ = _swig_repr
2439 def get_dimension(self):
2440 r"""get_dimension(_UnitSimplexBase2D self) -> int"""
2441 return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)
2443 def get_barycenter(self):
2444 r"""get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
2445 return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)
2447 def get_contains(self, *args):
2448 r"""get_contains(_UnitSimplexBase2D self, Vector2D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2449 return _IMP_algebra._UnitSimplexBase2D_get_contains(self, *args)
2450 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase2D
2453 _IMP_algebra._UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
2454 class _UnitSimplexBase3D(_GeometricPrimitive3D):
2455 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 3 > class."""
2457 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2459 def __init__(self, *args, **kwargs):
2460 raise AttributeError(
"No constructor defined - class is abstract")
2461 __repr__ = _swig_repr
2463 def get_dimension(self):
2464 r"""get_dimension(_UnitSimplexBase3D self) -> int"""
2465 return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)
2467 def get_barycenter(self):
2468 r"""get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
2469 return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)
2471 def get_contains(self, *args):
2472 r"""get_contains(_UnitSimplexBase3D self, Vector3D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2473 return _IMP_algebra._UnitSimplexBase3D_get_contains(self, *args)
2474 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase3D
2477 _IMP_algebra._UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
2478 class _UnitSimplexBase4D(_GeometricPrimitive4D):
2479 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 4 > class."""
2481 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2483 def __init__(self, *args, **kwargs):
2484 raise AttributeError(
"No constructor defined - class is abstract")
2485 __repr__ = _swig_repr
2487 def get_dimension(self):
2488 r"""get_dimension(_UnitSimplexBase4D self) -> int"""
2489 return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)
2491 def get_barycenter(self):
2492 r"""get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
2493 return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)
2495 def get_contains(self, *args):
2496 r"""get_contains(_UnitSimplexBase4D self, Vector4D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2497 return _IMP_algebra._UnitSimplexBase4D_get_contains(self, *args)
2498 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase4D
2501 _IMP_algebra._UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
2502 class _UnitSimplexBase5D(_GeometricPrimitive5D):
2503 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 5 > class."""
2505 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2507 def __init__(self, *args, **kwargs):
2508 raise AttributeError(
"No constructor defined - class is abstract")
2509 __repr__ = _swig_repr
2511 def get_dimension(self):
2512 r"""get_dimension(_UnitSimplexBase5D self) -> int"""
2513 return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)
2515 def get_barycenter(self):
2516 r"""get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
2517 return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)
2519 def get_contains(self, *args):
2520 r"""get_contains(_UnitSimplexBase5D self, Vector5D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2521 return _IMP_algebra._UnitSimplexBase5D_get_contains(self, *args)
2522 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase5D
2525 _IMP_algebra._UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
2526 class _UnitSimplexBase6D(_GeometricPrimitive6D):
2527 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 6 > class."""
2529 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2531 def __init__(self, *args, **kwargs):
2532 raise AttributeError(
"No constructor defined - class is abstract")
2533 __repr__ = _swig_repr
2535 def get_dimension(self):
2536 r"""get_dimension(_UnitSimplexBase6D self) -> int"""
2537 return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)
2539 def get_barycenter(self):
2540 r"""get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
2541 return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)
2543 def get_contains(self, *args):
2544 r"""get_contains(_UnitSimplexBase6D self, Vector6D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2545 return _IMP_algebra._UnitSimplexBase6D_get_contains(self, *args)
2546 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase6D
2549 _IMP_algebra._UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
2551 r"""Proxy of C++ IMP::algebra::VectorD< 1 > class."""
2553 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2556 r"""get_unit_vector(Vector1D self) -> Vector1D"""
2557 return _IMP_algebra.Vector1D_get_unit_vector(self)
2559 def __truediv__(self, *args):
2560 return _IMP_algebra.Vector1D___truediv__(self, *args)
2561 __div__ = __truediv__
2566 r"""__neg__(Vector1D self) -> Vector1D"""
2567 return _IMP_algebra.Vector1D___neg__(self)
2569 def __sub__(self, o):
2570 r"""__sub__(Vector1D self, Vector1D o) -> Vector1D"""
2571 return _IMP_algebra.Vector1D___sub__(self, o)
2573 def __add__(self, ret):
2574 r"""__add__(Vector1D self, Vector1D ret) -> Vector1D"""
2575 return _IMP_algebra.Vector1D___add__(self, ret)
2577 def __mul__(self, *args):
2579 __mul__(Vector1D self, double s) -> Vector1D
2580 __mul__(Vector1D self, Vector1D o) -> double
2582 return _IMP_algebra.Vector1D___mul__(self, *args)
2584 def __init__(self, *args):
2586 __init__(Vector1D self, IMP::Floats const & f) -> Vector1D
2587 __init__(Vector1D self) -> Vector1D
2588 __init__(Vector1D self, double x) -> Vector1D
2590 _IMP_algebra.Vector1D_swiginit(self, _IMP_algebra.new_Vector1D(*args))
2592 def __iadd__(self, *args):
2593 _IMP_algebra.Vector1D___iadd__(self, *args)
2598 def __imul__(self, *args):
2599 _IMP_algebra.Vector1D___imul__(self, *args)
2604 def __idiv__(self, *args):
2605 _IMP_algebra.Vector1D___idiv__(self, *args)
2610 def __isub__(self, *args):
2611 _IMP_algebra.Vector1D___isub__(self, *args)
2617 r"""__len__(Vector1D self) -> unsigned int"""
2618 return _IMP_algebra.Vector1D___len__(self)
2620 def __rmul__(self, f):
2621 r"""__rmul__(Vector1D self, double f) -> Vector1D"""
2622 return _IMP_algebra.Vector1D___rmul__(self, f)
2625 r"""__str__(Vector1D self) -> std::string"""
2626 return _IMP_algebra.Vector1D___str__(self)
2629 r"""__repr__(Vector1D self) -> std::string"""
2630 return _IMP_algebra.Vector1D___repr__(self)
2632 def __cmp__(self, arg2):
2633 r"""__cmp__(Vector1D self, Vector1D arg2) -> int"""
2634 return _IMP_algebra.Vector1D___cmp__(self, arg2)
2636 def __eq__(self, arg2):
2637 r"""__eq__(Vector1D self, Vector1D arg2) -> bool"""
2638 return _IMP_algebra.Vector1D___eq__(self, arg2)
2640 __truediv__ = __div__
2641 __itruediv__ = __idiv__
2644 def _get_as_binary(self):
2645 r"""_get_as_binary(Vector1D self) -> PyObject *"""
2646 return _IMP_algebra.Vector1D__get_as_binary(self)
2648 def _set_from_binary(self, p):
2649 r"""_set_from_binary(Vector1D self, PyObject * p)"""
2650 return _IMP_algebra.Vector1D__set_from_binary(self, p)
2652 def __getstate__(self):
2653 p = self._get_as_binary()
2654 if len(self.__dict__) > 1:
2655 d = self.__dict__.copy()
2660 def __setstate__(self, p):
2661 if not hasattr(self,
'this'):
2663 if isinstance(p, tuple):
2665 self.__dict__.update(d)
2666 return self._set_from_binary(p)
2669 def __getitem__(self, index):
2670 r"""__getitem__(Vector1D self, int index) -> double"""
2671 return _IMP_algebra.Vector1D___getitem__(self, index)
2673 def __setitem__(self, index, val):
2674 r"""__setitem__(Vector1D self, int index, double val)"""
2675 return _IMP_algebra.Vector1D___setitem__(self, index, val)
2676 __swig_destroy__ = _IMP_algebra.delete_Vector1D
2679 _IMP_algebra.Vector1D_swigregister(Vector1D)
2681 r"""Proxy of C++ IMP::algebra::VectorD< 2 > class."""
2683 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2686 r"""get_unit_vector(Vector2D self) -> Vector2D"""
2687 return _IMP_algebra.Vector2D_get_unit_vector(self)
2689 def __truediv__(self, *args):
2690 return _IMP_algebra.Vector2D___truediv__(self, *args)
2691 __div__ = __truediv__
2696 r"""__neg__(Vector2D self) -> Vector2D"""
2697 return _IMP_algebra.Vector2D___neg__(self)
2699 def __sub__(self, o):
2700 r"""__sub__(Vector2D self, Vector2D o) -> Vector2D"""
2701 return _IMP_algebra.Vector2D___sub__(self, o)
2703 def __add__(self, ret):
2704 r"""__add__(Vector2D self, Vector2D ret) -> Vector2D"""
2705 return _IMP_algebra.Vector2D___add__(self, ret)
2707 def __mul__(self, *args):
2709 __mul__(Vector2D self, double s) -> Vector2D
2710 __mul__(Vector2D self, Vector2D o) -> double
2712 return _IMP_algebra.Vector2D___mul__(self, *args)
2714 def __init__(self, *args):
2716 __init__(Vector2D self, IMP::Floats const & f) -> Vector2D
2717 __init__(Vector2D self) -> Vector2D
2718 __init__(Vector2D self, double x, double y) -> Vector2D
2720 _IMP_algebra.Vector2D_swiginit(self, _IMP_algebra.new_Vector2D(*args))
2722 def __iadd__(self, *args):
2723 _IMP_algebra.Vector2D___iadd__(self, *args)
2728 def __imul__(self, *args):
2729 _IMP_algebra.Vector2D___imul__(self, *args)
2734 def __idiv__(self, *args):
2735 _IMP_algebra.Vector2D___idiv__(self, *args)
2740 def __isub__(self, *args):
2741 _IMP_algebra.Vector2D___isub__(self, *args)
2747 r"""__len__(Vector2D self) -> unsigned int"""
2748 return _IMP_algebra.Vector2D___len__(self)
2750 def __rmul__(self, f):
2751 r"""__rmul__(Vector2D self, double f) -> Vector2D"""
2752 return _IMP_algebra.Vector2D___rmul__(self, f)
2755 r"""__str__(Vector2D self) -> std::string"""
2756 return _IMP_algebra.Vector2D___str__(self)
2759 r"""__repr__(Vector2D self) -> std::string"""
2760 return _IMP_algebra.Vector2D___repr__(self)
2762 def __cmp__(self, arg2):
2763 r"""__cmp__(Vector2D self, Vector2D arg2) -> int"""
2764 return _IMP_algebra.Vector2D___cmp__(self, arg2)
2766 def __eq__(self, arg2):
2767 r"""__eq__(Vector2D self, Vector2D arg2) -> bool"""
2768 return _IMP_algebra.Vector2D___eq__(self, arg2)
2770 __truediv__ = __div__
2771 __itruediv__ = __idiv__
2774 def _get_as_binary(self):
2775 r"""_get_as_binary(Vector2D self) -> PyObject *"""
2776 return _IMP_algebra.Vector2D__get_as_binary(self)
2778 def _set_from_binary(self, p):
2779 r"""_set_from_binary(Vector2D self, PyObject * p)"""
2780 return _IMP_algebra.Vector2D__set_from_binary(self, p)
2782 def __getstate__(self):
2783 p = self._get_as_binary()
2784 if len(self.__dict__) > 1:
2785 d = self.__dict__.copy()
2790 def __setstate__(self, p):
2791 if not hasattr(self,
'this'):
2793 if isinstance(p, tuple):
2795 self.__dict__.update(d)
2796 return self._set_from_binary(p)
2799 def __getitem__(self, index):
2800 r"""__getitem__(Vector2D self, int index) -> double"""
2801 return _IMP_algebra.Vector2D___getitem__(self, index)
2803 def __setitem__(self, index, val):
2804 r"""__setitem__(Vector2D self, int index, double val)"""
2805 return _IMP_algebra.Vector2D___setitem__(self, index, val)
2806 __swig_destroy__ = _IMP_algebra.delete_Vector2D
2809 _IMP_algebra.Vector2D_swigregister(Vector2D)
2811 r"""Proxy of C++ IMP::algebra::VectorD< 3 > class."""
2813 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2816 r"""get_unit_vector(Vector3D self) -> Vector3D"""
2817 return _IMP_algebra.Vector3D_get_unit_vector(self)
2819 def __truediv__(self, *args):
2820 return _IMP_algebra.Vector3D___truediv__(self, *args)
2821 __div__ = __truediv__
2826 r"""__neg__(Vector3D self) -> Vector3D"""
2827 return _IMP_algebra.Vector3D___neg__(self)
2829 def __sub__(self, o):
2830 r"""__sub__(Vector3D self, Vector3D o) -> Vector3D"""
2831 return _IMP_algebra.Vector3D___sub__(self, o)
2833 def __add__(self, ret):
2834 r"""__add__(Vector3D self, Vector3D ret) -> Vector3D"""
2835 return _IMP_algebra.Vector3D___add__(self, ret)
2837 def __mul__(self, *args):
2839 __mul__(Vector3D self, double s) -> Vector3D
2840 __mul__(Vector3D self, Vector3D o) -> double
2842 return _IMP_algebra.Vector3D___mul__(self, *args)
2844 def __init__(self, *args):
2846 __init__(Vector3D self, IMP::Floats const & f) -> Vector3D
2847 __init__(Vector3D self) -> Vector3D
2848 __init__(Vector3D self, double x, double y, double z) -> Vector3D
2850 _IMP_algebra.Vector3D_swiginit(self, _IMP_algebra.new_Vector3D(*args))
2852 def __iadd__(self, *args):
2853 _IMP_algebra.Vector3D___iadd__(self, *args)
2858 def __imul__(self, *args):
2859 _IMP_algebra.Vector3D___imul__(self, *args)
2864 def __idiv__(self, *args):
2865 _IMP_algebra.Vector3D___idiv__(self, *args)
2870 def __isub__(self, *args):
2871 _IMP_algebra.Vector3D___isub__(self, *args)
2877 r"""__len__(Vector3D self) -> unsigned int"""
2878 return _IMP_algebra.Vector3D___len__(self)
2880 def __rmul__(self, f):
2881 r"""__rmul__(Vector3D self, double f) -> Vector3D"""
2882 return _IMP_algebra.Vector3D___rmul__(self, f)
2885 r"""__str__(Vector3D self) -> std::string"""
2886 return _IMP_algebra.Vector3D___str__(self)
2889 r"""__repr__(Vector3D self) -> std::string"""
2890 return _IMP_algebra.Vector3D___repr__(self)
2892 def __cmp__(self, arg2):
2893 r"""__cmp__(Vector3D self, Vector3D arg2) -> int"""
2894 return _IMP_algebra.Vector3D___cmp__(self, arg2)
2896 def __eq__(self, arg2):
2897 r"""__eq__(Vector3D self, Vector3D arg2) -> bool"""
2898 return _IMP_algebra.Vector3D___eq__(self, arg2)
2900 __truediv__ = __div__
2901 __itruediv__ = __idiv__
2904 def _get_as_binary(self):
2905 r"""_get_as_binary(Vector3D self) -> PyObject *"""
2906 return _IMP_algebra.Vector3D__get_as_binary(self)
2908 def _set_from_binary(self, p):
2909 r"""_set_from_binary(Vector3D self, PyObject * p)"""
2910 return _IMP_algebra.Vector3D__set_from_binary(self, p)
2912 def __getstate__(self):
2913 p = self._get_as_binary()
2914 if len(self.__dict__) > 1:
2915 d = self.__dict__.copy()
2920 def __setstate__(self, p):
2921 if not hasattr(self,
'this'):
2923 if isinstance(p, tuple):
2925 self.__dict__.update(d)
2926 return self._set_from_binary(p)
2929 def __getitem__(self, index):
2930 r"""__getitem__(Vector3D self, int index) -> double"""
2931 return _IMP_algebra.Vector3D___getitem__(self, index)
2933 def __setitem__(self, index, val):
2934 r"""__setitem__(Vector3D self, int index, double val)"""
2935 return _IMP_algebra.Vector3D___setitem__(self, index, val)
2936 __swig_destroy__ = _IMP_algebra.delete_Vector3D
2939 _IMP_algebra.Vector3D_swigregister(Vector3D)
2941 r"""Proxy of C++ IMP::algebra::VectorD< 4 > class."""
2943 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2946 r"""get_unit_vector(Vector4D self) -> Vector4D"""
2947 return _IMP_algebra.Vector4D_get_unit_vector(self)
2949 def __truediv__(self, *args):
2950 return _IMP_algebra.Vector4D___truediv__(self, *args)
2951 __div__ = __truediv__
2956 r"""__neg__(Vector4D self) -> Vector4D"""
2957 return _IMP_algebra.Vector4D___neg__(self)
2959 def __sub__(self, o):
2960 r"""__sub__(Vector4D self, Vector4D o) -> Vector4D"""
2961 return _IMP_algebra.Vector4D___sub__(self, o)
2963 def __add__(self, ret):
2964 r"""__add__(Vector4D self, Vector4D ret) -> Vector4D"""
2965 return _IMP_algebra.Vector4D___add__(self, ret)
2967 def __mul__(self, *args):
2969 __mul__(Vector4D self, double s) -> Vector4D
2970 __mul__(Vector4D self, Vector4D o) -> double
2972 return _IMP_algebra.Vector4D___mul__(self, *args)
2974 def __init__(self, *args):
2976 __init__(Vector4D self, IMP::Floats const & f) -> Vector4D
2977 __init__(Vector4D self) -> Vector4D
2978 __init__(Vector4D self, double x0, double x1, double x2, double x3) -> Vector4D
2980 _IMP_algebra.Vector4D_swiginit(self, _IMP_algebra.new_Vector4D(*args))
2982 def __iadd__(self, *args):
2983 _IMP_algebra.Vector4D___iadd__(self, *args)
2988 def __imul__(self, *args):
2989 _IMP_algebra.Vector4D___imul__(self, *args)
2994 def __idiv__(self, *args):
2995 _IMP_algebra.Vector4D___idiv__(self, *args)
3000 def __isub__(self, *args):
3001 _IMP_algebra.Vector4D___isub__(self, *args)
3007 r"""__len__(Vector4D self) -> unsigned int"""
3008 return _IMP_algebra.Vector4D___len__(self)
3010 def __rmul__(self, f):
3011 r"""__rmul__(Vector4D self, double f) -> Vector4D"""
3012 return _IMP_algebra.Vector4D___rmul__(self, f)
3015 r"""__str__(Vector4D self) -> std::string"""
3016 return _IMP_algebra.Vector4D___str__(self)
3019 r"""__repr__(Vector4D self) -> std::string"""
3020 return _IMP_algebra.Vector4D___repr__(self)
3022 def __cmp__(self, arg2):
3023 r"""__cmp__(Vector4D self, Vector4D arg2) -> int"""
3024 return _IMP_algebra.Vector4D___cmp__(self, arg2)
3026 def __eq__(self, arg2):
3027 r"""__eq__(Vector4D self, Vector4D arg2) -> bool"""
3028 return _IMP_algebra.Vector4D___eq__(self, arg2)
3030 __truediv__ = __div__
3031 __itruediv__ = __idiv__
3034 def _get_as_binary(self):
3035 r"""_get_as_binary(Vector4D self) -> PyObject *"""
3036 return _IMP_algebra.Vector4D__get_as_binary(self)
3038 def _set_from_binary(self, p):
3039 r"""_set_from_binary(Vector4D self, PyObject * p)"""
3040 return _IMP_algebra.Vector4D__set_from_binary(self, p)
3042 def __getstate__(self):
3043 p = self._get_as_binary()
3044 if len(self.__dict__) > 1:
3045 d = self.__dict__.copy()
3050 def __setstate__(self, p):
3051 if not hasattr(self,
'this'):
3053 if isinstance(p, tuple):
3055 self.__dict__.update(d)
3056 return self._set_from_binary(p)
3059 def __getitem__(self, index):
3060 r"""__getitem__(Vector4D self, int index) -> double"""
3061 return _IMP_algebra.Vector4D___getitem__(self, index)
3063 def __setitem__(self, index, val):
3064 r"""__setitem__(Vector4D self, int index, double val)"""
3065 return _IMP_algebra.Vector4D___setitem__(self, index, val)
3066 __swig_destroy__ = _IMP_algebra.delete_Vector4D
3069 _IMP_algebra.Vector4D_swigregister(Vector4D)
3071 r"""Proxy of C++ IMP::algebra::VectorD< 5 > class."""
3073 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3076 r"""get_unit_vector(Vector5D self) -> Vector5D"""
3077 return _IMP_algebra.Vector5D_get_unit_vector(self)
3079 def __truediv__(self, *args):
3080 return _IMP_algebra.Vector5D___truediv__(self, *args)
3081 __div__ = __truediv__
3086 r"""__neg__(Vector5D self) -> Vector5D"""
3087 return _IMP_algebra.Vector5D___neg__(self)
3089 def __sub__(self, o):
3090 r"""__sub__(Vector5D self, Vector5D o) -> Vector5D"""
3091 return _IMP_algebra.Vector5D___sub__(self, o)
3093 def __add__(self, ret):
3094 r"""__add__(Vector5D self, Vector5D ret) -> Vector5D"""
3095 return _IMP_algebra.Vector5D___add__(self, ret)
3097 def __mul__(self, *args):
3099 __mul__(Vector5D self, double s) -> Vector5D
3100 __mul__(Vector5D self, Vector5D o) -> double
3102 return _IMP_algebra.Vector5D___mul__(self, *args)
3104 def __init__(self, *args):
3106 __init__(Vector5D self, IMP::Floats const & f) -> Vector5D
3107 __init__(Vector5D self) -> Vector5D
3108 __init__(Vector5D self, double x0, double x1, double x2, double x3, double x4) -> Vector5D
3110 _IMP_algebra.Vector5D_swiginit(self, _IMP_algebra.new_Vector5D(*args))
3112 def __iadd__(self, *args):
3113 _IMP_algebra.Vector5D___iadd__(self, *args)
3118 def __imul__(self, *args):
3119 _IMP_algebra.Vector5D___imul__(self, *args)
3124 def __idiv__(self, *args):
3125 _IMP_algebra.Vector5D___idiv__(self, *args)
3130 def __isub__(self, *args):
3131 _IMP_algebra.Vector5D___isub__(self, *args)
3137 r"""__len__(Vector5D self) -> unsigned int"""
3138 return _IMP_algebra.Vector5D___len__(self)
3140 def __rmul__(self, f):
3141 r"""__rmul__(Vector5D self, double f) -> Vector5D"""
3142 return _IMP_algebra.Vector5D___rmul__(self, f)
3145 r"""__str__(Vector5D self) -> std::string"""
3146 return _IMP_algebra.Vector5D___str__(self)
3149 r"""__repr__(Vector5D self) -> std::string"""
3150 return _IMP_algebra.Vector5D___repr__(self)
3152 def __cmp__(self, arg2):
3153 r"""__cmp__(Vector5D self, Vector5D arg2) -> int"""
3154 return _IMP_algebra.Vector5D___cmp__(self, arg2)
3156 def __eq__(self, arg2):
3157 r"""__eq__(Vector5D self, Vector5D arg2) -> bool"""
3158 return _IMP_algebra.Vector5D___eq__(self, arg2)
3160 __truediv__ = __div__
3161 __itruediv__ = __idiv__
3164 def _get_as_binary(self):
3165 r"""_get_as_binary(Vector5D self) -> PyObject *"""
3166 return _IMP_algebra.Vector5D__get_as_binary(self)
3168 def _set_from_binary(self, p):
3169 r"""_set_from_binary(Vector5D self, PyObject * p)"""
3170 return _IMP_algebra.Vector5D__set_from_binary(self, p)
3172 def __getstate__(self):
3173 p = self._get_as_binary()
3174 if len(self.__dict__) > 1:
3175 d = self.__dict__.copy()
3180 def __setstate__(self, p):
3181 if not hasattr(self,
'this'):
3183 if isinstance(p, tuple):
3185 self.__dict__.update(d)
3186 return self._set_from_binary(p)
3189 def __getitem__(self, index):
3190 r"""__getitem__(Vector5D self, int index) -> double"""
3191 return _IMP_algebra.Vector5D___getitem__(self, index)
3193 def __setitem__(self, index, val):
3194 r"""__setitem__(Vector5D self, int index, double val)"""
3195 return _IMP_algebra.Vector5D___setitem__(self, index, val)
3196 __swig_destroy__ = _IMP_algebra.delete_Vector5D
3199 _IMP_algebra.Vector5D_swigregister(Vector5D)
3201 r"""Proxy of C++ IMP::algebra::VectorD< 6 > class."""
3203 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3206 r"""get_unit_vector(Vector6D self) -> Vector6D"""
3207 return _IMP_algebra.Vector6D_get_unit_vector(self)
3209 def __truediv__(self, *args):
3210 return _IMP_algebra.Vector6D___truediv__(self, *args)
3211 __div__ = __truediv__
3216 r"""__neg__(Vector6D self) -> Vector6D"""
3217 return _IMP_algebra.Vector6D___neg__(self)
3219 def __sub__(self, o):
3220 r"""__sub__(Vector6D self, Vector6D o) -> Vector6D"""
3221 return _IMP_algebra.Vector6D___sub__(self, o)
3223 def __add__(self, ret):
3224 r"""__add__(Vector6D self, Vector6D ret) -> Vector6D"""
3225 return _IMP_algebra.Vector6D___add__(self, ret)
3227 def __mul__(self, *args):
3229 __mul__(Vector6D self, double s) -> Vector6D
3230 __mul__(Vector6D self, Vector6D o) -> double
3232 return _IMP_algebra.Vector6D___mul__(self, *args)
3234 def __init__(self, *args):
3236 __init__(Vector6D self, IMP::Floats const & f) -> Vector6D
3237 __init__(Vector6D self) -> Vector6D
3238 __init__(Vector6D self, double x0, double x1, double x2, double x3, double x4, double x5) -> Vector6D
3240 _IMP_algebra.Vector6D_swiginit(self, _IMP_algebra.new_Vector6D(*args))
3242 def __iadd__(self, *args):
3243 _IMP_algebra.Vector6D___iadd__(self, *args)
3248 def __imul__(self, *args):
3249 _IMP_algebra.Vector6D___imul__(self, *args)
3254 def __idiv__(self, *args):
3255 _IMP_algebra.Vector6D___idiv__(self, *args)
3260 def __isub__(self, *args):
3261 _IMP_algebra.Vector6D___isub__(self, *args)
3267 r"""__len__(Vector6D self) -> unsigned int"""
3268 return _IMP_algebra.Vector6D___len__(self)
3270 def __rmul__(self, f):
3271 r"""__rmul__(Vector6D self, double f) -> Vector6D"""
3272 return _IMP_algebra.Vector6D___rmul__(self, f)
3275 r"""__str__(Vector6D self) -> std::string"""
3276 return _IMP_algebra.Vector6D___str__(self)
3279 r"""__repr__(Vector6D self) -> std::string"""
3280 return _IMP_algebra.Vector6D___repr__(self)
3282 def __cmp__(self, arg2):
3283 r"""__cmp__(Vector6D self, Vector6D arg2) -> int"""
3284 return _IMP_algebra.Vector6D___cmp__(self, arg2)
3286 def __eq__(self, arg2):
3287 r"""__eq__(Vector6D self, Vector6D arg2) -> bool"""
3288 return _IMP_algebra.Vector6D___eq__(self, arg2)
3290 __truediv__ = __div__
3291 __itruediv__ = __idiv__
3294 def _get_as_binary(self):
3295 r"""_get_as_binary(Vector6D self) -> PyObject *"""
3296 return _IMP_algebra.Vector6D__get_as_binary(self)
3298 def _set_from_binary(self, p):
3299 r"""_set_from_binary(Vector6D self, PyObject * p)"""
3300 return _IMP_algebra.Vector6D__set_from_binary(self, p)
3302 def __getstate__(self):
3303 p = self._get_as_binary()
3304 if len(self.__dict__) > 1:
3305 d = self.__dict__.copy()
3310 def __setstate__(self, p):
3311 if not hasattr(self,
'this'):
3313 if isinstance(p, tuple):
3315 self.__dict__.update(d)
3316 return self._set_from_binary(p)
3319 def __getitem__(self, index):
3320 r"""__getitem__(Vector6D self, int index) -> double"""
3321 return _IMP_algebra.Vector6D___getitem__(self, index)
3323 def __setitem__(self, index, val):
3324 r"""__setitem__(Vector6D self, int index, double val)"""
3325 return _IMP_algebra.Vector6D___setitem__(self, index, val)
3326 __swig_destroy__ = _IMP_algebra.delete_Vector6D
3329 _IMP_algebra.Vector6D_swigregister(Vector6D)
3331 r"""Proxy of C++ IMP::algebra::VectorD< -1 > class."""
3333 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3336 r"""get_unit_vector(VectorKD self) -> VectorKD"""
3337 return _IMP_algebra.VectorKD_get_unit_vector(self)
3339 def __truediv__(self, *args):
3340 return _IMP_algebra.VectorKD___truediv__(self, *args)
3341 __div__ = __truediv__
3346 r"""__neg__(VectorKD self) -> VectorKD"""
3347 return _IMP_algebra.VectorKD___neg__(self)
3349 def __sub__(self, o):
3350 r"""__sub__(VectorKD self, VectorKD o) -> VectorKD"""
3351 return _IMP_algebra.VectorKD___sub__(self, o)
3353 def __add__(self, ret):
3354 r"""__add__(VectorKD self, VectorKD ret) -> VectorKD"""
3355 return _IMP_algebra.VectorKD___add__(self, ret)
3357 def __mul__(self, *args):
3359 __mul__(VectorKD self, double s) -> VectorKD
3360 __mul__(VectorKD self, VectorKD o) -> double
3362 return _IMP_algebra.VectorKD___mul__(self, *args)
3364 def __init__(self, *args):
3366 __init__(VectorKD self, IMP::Floats const & f) -> VectorKD
3367 __init__(VectorKD self) -> VectorKD
3368 __init__(VectorKD self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max(), double x3=std::numeric_limits< double >::max(), double x4=std::numeric_limits< double >::max(), double x5=std::numeric_limits< double >::max()) -> VectorKD
3370 _IMP_algebra.VectorKD_swiginit(self, _IMP_algebra.new_VectorKD(*args))
3372 def __iadd__(self, *args):
3373 _IMP_algebra.VectorKD___iadd__(self, *args)
3378 def __imul__(self, *args):
3379 _IMP_algebra.VectorKD___imul__(self, *args)
3384 def __idiv__(self, *args):
3385 _IMP_algebra.VectorKD___idiv__(self, *args)
3390 def __isub__(self, *args):
3391 _IMP_algebra.VectorKD___isub__(self, *args)
3397 r"""__len__(VectorKD self) -> unsigned int"""
3398 return _IMP_algebra.VectorKD___len__(self)
3400 def __rmul__(self, f):
3401 r"""__rmul__(VectorKD self, double f) -> VectorKD"""
3402 return _IMP_algebra.VectorKD___rmul__(self, f)
3405 r"""__str__(VectorKD self) -> std::string"""
3406 return _IMP_algebra.VectorKD___str__(self)
3409 r"""__repr__(VectorKD self) -> std::string"""
3410 return _IMP_algebra.VectorKD___repr__(self)
3412 def __cmp__(self, arg2):
3413 r"""__cmp__(VectorKD self, VectorKD arg2) -> int"""
3414 return _IMP_algebra.VectorKD___cmp__(self, arg2)
3416 def __eq__(self, arg2):
3417 r"""__eq__(VectorKD self, VectorKD arg2) -> bool"""
3418 return _IMP_algebra.VectorKD___eq__(self, arg2)
3420 __truediv__ = __div__
3421 __itruediv__ = __idiv__
3424 def _get_as_binary(self):
3425 r"""_get_as_binary(VectorKD self) -> PyObject *"""
3426 return _IMP_algebra.VectorKD__get_as_binary(self)
3428 def _set_from_binary(self, p):
3429 r"""_set_from_binary(VectorKD self, PyObject * p)"""
3430 return _IMP_algebra.VectorKD__set_from_binary(self, p)
3432 def __getstate__(self):
3433 p = self._get_as_binary()
3434 if len(self.__dict__) > 1:
3435 d = self.__dict__.copy()
3440 def __setstate__(self, p):
3441 if not hasattr(self,
'this'):
3443 if isinstance(p, tuple):
3445 self.__dict__.update(d)
3446 return self._set_from_binary(p)
3449 def __getitem__(self, index):
3450 r"""__getitem__(VectorKD self, int index) -> double"""
3451 return _IMP_algebra.VectorKD___getitem__(self, index)
3453 def __setitem__(self, index, val):
3454 r"""__setitem__(VectorKD self, int index, double val)"""
3455 return _IMP_algebra.VectorKD___setitem__(self, index, val)
3456 __swig_destroy__ = _IMP_algebra.delete_VectorKD
3459 _IMP_algebra.VectorKD_swigregister(VectorKD)
3461 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 1 > class."""
3463 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3465 def get_dimension(self):
3466 r"""get_dimension(BoundingBox1D self) -> unsigned int"""
3467 return _IMP_algebra.BoundingBox1D_get_dimension(self)
3469 def get_corner(self, i):
3470 r"""get_corner(BoundingBox1D self, unsigned int i) -> Vector1D"""
3471 return _IMP_algebra.BoundingBox1D_get_corner(self, i)
3473 def get_contains(self, *args):
3475 get_contains(BoundingBox1D self, Vector1D o) -> bool
3476 get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
3478 return _IMP_algebra.BoundingBox1D_get_contains(self, *args)
3480 def show(self, *args):
3481 r"""show(BoundingBox1D self, _ostream out=std::cout)"""
3482 return _IMP_algebra.BoundingBox1D_show(self, *args)
3485 r"""__str__(BoundingBox1D self) -> std::string"""
3486 return _IMP_algebra.BoundingBox1D___str__(self)
3489 r"""__repr__(BoundingBox1D self) -> std::string"""
3490 return _IMP_algebra.BoundingBox1D___repr__(self)
3492 def __cmp__(self, arg2):
3493 r"""__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
3494 return _IMP_algebra.BoundingBox1D___cmp__(self, arg2)
3496 def __eq__(self, arg2):
3497 r"""__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
3498 return _IMP_algebra.BoundingBox1D___eq__(self, arg2)
3500 def __init__(self, *args):
3502 __init__(BoundingBox1D self, unsigned int d) -> BoundingBox1D
3503 __init__(BoundingBox1D self, Vector1D lb, Vector1D ub) -> BoundingBox1D
3504 __init__(BoundingBox1D self, Vector1D v) -> BoundingBox1D
3505 __init__(BoundingBox1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
3506 __init__(BoundingBox1D self) -> BoundingBox1D
3508 _IMP_algebra.BoundingBox1D_swiginit(self, _IMP_algebra.new_BoundingBox1D(*args))
3510 def __getitem__(self, index):
3511 r"""__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
3512 return _IMP_algebra.BoundingBox1D___getitem__(self, index)
3514 def __iadd__(self, *args):
3515 _IMP_algebra.BoundingBox1D___iadd__(self, *args)
3521 r"""__len__(BoundingBox1D self) -> unsigned int"""
3522 return _IMP_algebra.BoundingBox1D___len__(self)
3524 def __add__(self, *args):
3526 __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
3527 __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
3528 __add__(BoundingBox1D self, double o) -> BoundingBox1D
3530 return _IMP_algebra.BoundingBox1D___add__(self, *args)
3532 def _get_as_binary(self):
3533 r"""_get_as_binary(BoundingBox1D self) -> PyObject *"""
3534 return _IMP_algebra.BoundingBox1D__get_as_binary(self)
3536 def _set_from_binary(self, p):
3537 r"""_set_from_binary(BoundingBox1D self, PyObject * p)"""
3538 return _IMP_algebra.BoundingBox1D__set_from_binary(self, p)
3540 def __getstate__(self):
3541 p = self._get_as_binary()
3542 if len(self.__dict__) > 1:
3543 d = self.__dict__.copy()
3548 def __setstate__(self, p):
3549 if not hasattr(self,
'this'):
3551 if isinstance(p, tuple):
3553 self.__dict__.update(d)
3554 return self._set_from_binary(p)
3556 __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
3559 _IMP_algebra.BoundingBox1D_swigregister(BoundingBox1D)
3561 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 2 > class."""
3563 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3565 def get_dimension(self):
3566 r"""get_dimension(BoundingBox2D self) -> unsigned int"""
3567 return _IMP_algebra.BoundingBox2D_get_dimension(self)
3569 def get_corner(self, i):
3570 r"""get_corner(BoundingBox2D self, unsigned int i) -> Vector2D"""
3571 return _IMP_algebra.BoundingBox2D_get_corner(self, i)
3573 def get_contains(self, *args):
3575 get_contains(BoundingBox2D self, Vector2D o) -> bool
3576 get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
3578 return _IMP_algebra.BoundingBox2D_get_contains(self, *args)
3580 def show(self, *args):
3581 r"""show(BoundingBox2D self, _ostream out=std::cout)"""
3582 return _IMP_algebra.BoundingBox2D_show(self, *args)
3585 r"""__str__(BoundingBox2D self) -> std::string"""
3586 return _IMP_algebra.BoundingBox2D___str__(self)
3589 r"""__repr__(BoundingBox2D self) -> std::string"""
3590 return _IMP_algebra.BoundingBox2D___repr__(self)
3592 def __cmp__(self, arg2):
3593 r"""__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
3594 return _IMP_algebra.BoundingBox2D___cmp__(self, arg2)
3596 def __eq__(self, arg2):
3597 r"""__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
3598 return _IMP_algebra.BoundingBox2D___eq__(self, arg2)
3600 def __init__(self, *args):
3602 __init__(BoundingBox2D self, unsigned int d) -> BoundingBox2D
3603 __init__(BoundingBox2D self, Vector2D lb, Vector2D ub) -> BoundingBox2D
3604 __init__(BoundingBox2D self, Vector2D v) -> BoundingBox2D
3605 __init__(BoundingBox2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
3606 __init__(BoundingBox2D self) -> BoundingBox2D
3608 _IMP_algebra.BoundingBox2D_swiginit(self, _IMP_algebra.new_BoundingBox2D(*args))
3610 def __getitem__(self, index):
3611 r"""__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
3612 return _IMP_algebra.BoundingBox2D___getitem__(self, index)
3614 def __iadd__(self, *args):
3615 _IMP_algebra.BoundingBox2D___iadd__(self, *args)
3621 r"""__len__(BoundingBox2D self) -> unsigned int"""
3622 return _IMP_algebra.BoundingBox2D___len__(self)
3624 def __add__(self, *args):
3626 __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
3627 __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
3628 __add__(BoundingBox2D self, double o) -> BoundingBox2D
3630 return _IMP_algebra.BoundingBox2D___add__(self, *args)
3632 def _get_as_binary(self):
3633 r"""_get_as_binary(BoundingBox2D self) -> PyObject *"""
3634 return _IMP_algebra.BoundingBox2D__get_as_binary(self)
3636 def _set_from_binary(self, p):
3637 r"""_set_from_binary(BoundingBox2D self, PyObject * p)"""
3638 return _IMP_algebra.BoundingBox2D__set_from_binary(self, p)
3640 def __getstate__(self):
3641 p = self._get_as_binary()
3642 if len(self.__dict__) > 1:
3643 d = self.__dict__.copy()
3648 def __setstate__(self, p):
3649 if not hasattr(self,
'this'):
3651 if isinstance(p, tuple):
3653 self.__dict__.update(d)
3654 return self._set_from_binary(p)
3656 __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
3659 _IMP_algebra.BoundingBox2D_swigregister(BoundingBox2D)
3661 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 3 > class."""
3663 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3665 def get_dimension(self):
3666 r"""get_dimension(BoundingBox3D self) -> unsigned int"""
3667 return _IMP_algebra.BoundingBox3D_get_dimension(self)
3669 def get_corner(self, i):
3670 r"""get_corner(BoundingBox3D self, unsigned int i) -> Vector3D"""
3671 return _IMP_algebra.BoundingBox3D_get_corner(self, i)
3673 def get_contains(self, *args):
3675 get_contains(BoundingBox3D self, Vector3D o) -> bool
3676 get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
3678 return _IMP_algebra.BoundingBox3D_get_contains(self, *args)
3680 def show(self, *args):
3681 r"""show(BoundingBox3D self, _ostream out=std::cout)"""
3682 return _IMP_algebra.BoundingBox3D_show(self, *args)
3685 r"""__str__(BoundingBox3D self) -> std::string"""
3686 return _IMP_algebra.BoundingBox3D___str__(self)
3689 r"""__repr__(BoundingBox3D self) -> std::string"""
3690 return _IMP_algebra.BoundingBox3D___repr__(self)
3692 def __cmp__(self, arg2):
3693 r"""__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
3694 return _IMP_algebra.BoundingBox3D___cmp__(self, arg2)
3696 def __eq__(self, arg2):
3697 r"""__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
3698 return _IMP_algebra.BoundingBox3D___eq__(self, arg2)
3700 def __init__(self, *args):
3702 __init__(BoundingBox3D self, unsigned int d) -> BoundingBox3D
3703 __init__(BoundingBox3D self, Vector3D lb, Vector3D ub) -> BoundingBox3D
3704 __init__(BoundingBox3D self, Vector3D v) -> BoundingBox3D
3705 __init__(BoundingBox3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
3706 __init__(BoundingBox3D self) -> BoundingBox3D
3708 _IMP_algebra.BoundingBox3D_swiginit(self, _IMP_algebra.new_BoundingBox3D(*args))
3710 def __getitem__(self, index):
3711 r"""__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
3712 return _IMP_algebra.BoundingBox3D___getitem__(self, index)
3714 def __iadd__(self, *args):
3715 _IMP_algebra.BoundingBox3D___iadd__(self, *args)
3721 r"""__len__(BoundingBox3D self) -> unsigned int"""
3722 return _IMP_algebra.BoundingBox3D___len__(self)
3724 def __add__(self, *args):
3726 __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
3727 __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
3728 __add__(BoundingBox3D self, double o) -> BoundingBox3D
3730 return _IMP_algebra.BoundingBox3D___add__(self, *args)
3732 def _get_as_binary(self):
3733 r"""_get_as_binary(BoundingBox3D self) -> PyObject *"""
3734 return _IMP_algebra.BoundingBox3D__get_as_binary(self)
3736 def _set_from_binary(self, p):
3737 r"""_set_from_binary(BoundingBox3D self, PyObject * p)"""
3738 return _IMP_algebra.BoundingBox3D__set_from_binary(self, p)
3740 def __getstate__(self):
3741 p = self._get_as_binary()
3742 if len(self.__dict__) > 1:
3743 d = self.__dict__.copy()
3748 def __setstate__(self, p):
3749 if not hasattr(self,
'this'):
3751 if isinstance(p, tuple):
3753 self.__dict__.update(d)
3754 return self._set_from_binary(p)
3756 __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
3759 _IMP_algebra.BoundingBox3D_swigregister(BoundingBox3D)
3761 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 4 > class."""
3763 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3765 def get_dimension(self):
3766 r"""get_dimension(BoundingBox4D self) -> unsigned int"""
3767 return _IMP_algebra.BoundingBox4D_get_dimension(self)
3769 def get_corner(self, i):
3770 r"""get_corner(BoundingBox4D self, unsigned int i) -> Vector4D"""
3771 return _IMP_algebra.BoundingBox4D_get_corner(self, i)
3773 def get_contains(self, *args):
3775 get_contains(BoundingBox4D self, Vector4D o) -> bool
3776 get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
3778 return _IMP_algebra.BoundingBox4D_get_contains(self, *args)
3780 def show(self, *args):
3781 r"""show(BoundingBox4D self, _ostream out=std::cout)"""
3782 return _IMP_algebra.BoundingBox4D_show(self, *args)
3785 r"""__str__(BoundingBox4D self) -> std::string"""
3786 return _IMP_algebra.BoundingBox4D___str__(self)
3789 r"""__repr__(BoundingBox4D self) -> std::string"""
3790 return _IMP_algebra.BoundingBox4D___repr__(self)
3792 def __cmp__(self, arg2):
3793 r"""__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
3794 return _IMP_algebra.BoundingBox4D___cmp__(self, arg2)
3796 def __eq__(self, arg2):
3797 r"""__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
3798 return _IMP_algebra.BoundingBox4D___eq__(self, arg2)
3800 def __init__(self, *args):
3802 __init__(BoundingBox4D self, unsigned int d) -> BoundingBox4D
3803 __init__(BoundingBox4D self, Vector4D lb, Vector4D ub) -> BoundingBox4D
3804 __init__(BoundingBox4D self, Vector4D v) -> BoundingBox4D
3805 __init__(BoundingBox4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
3806 __init__(BoundingBox4D self) -> BoundingBox4D
3808 _IMP_algebra.BoundingBox4D_swiginit(self, _IMP_algebra.new_BoundingBox4D(*args))
3810 def __getitem__(self, index):
3811 r"""__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
3812 return _IMP_algebra.BoundingBox4D___getitem__(self, index)
3814 def __iadd__(self, *args):
3815 _IMP_algebra.BoundingBox4D___iadd__(self, *args)
3821 r"""__len__(BoundingBox4D self) -> unsigned int"""
3822 return _IMP_algebra.BoundingBox4D___len__(self)
3824 def __add__(self, *args):
3826 __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
3827 __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
3828 __add__(BoundingBox4D self, double o) -> BoundingBox4D
3830 return _IMP_algebra.BoundingBox4D___add__(self, *args)
3832 def _get_as_binary(self):
3833 r"""_get_as_binary(BoundingBox4D self) -> PyObject *"""
3834 return _IMP_algebra.BoundingBox4D__get_as_binary(self)
3836 def _set_from_binary(self, p):
3837 r"""_set_from_binary(BoundingBox4D self, PyObject * p)"""
3838 return _IMP_algebra.BoundingBox4D__set_from_binary(self, p)
3840 def __getstate__(self):
3841 p = self._get_as_binary()
3842 if len(self.__dict__) > 1:
3843 d = self.__dict__.copy()
3848 def __setstate__(self, p):
3849 if not hasattr(self,
'this'):
3851 if isinstance(p, tuple):
3853 self.__dict__.update(d)
3854 return self._set_from_binary(p)
3856 __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
3859 _IMP_algebra.BoundingBox4D_swigregister(BoundingBox4D)
3861 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 5 > class."""
3863 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3865 def get_dimension(self):
3866 r"""get_dimension(BoundingBox5D self) -> unsigned int"""
3867 return _IMP_algebra.BoundingBox5D_get_dimension(self)
3869 def get_corner(self, i):
3870 r"""get_corner(BoundingBox5D self, unsigned int i) -> Vector5D"""
3871 return _IMP_algebra.BoundingBox5D_get_corner(self, i)
3873 def get_contains(self, *args):
3875 get_contains(BoundingBox5D self, Vector5D o) -> bool
3876 get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
3878 return _IMP_algebra.BoundingBox5D_get_contains(self, *args)
3880 def show(self, *args):
3881 r"""show(BoundingBox5D self, _ostream out=std::cout)"""
3882 return _IMP_algebra.BoundingBox5D_show(self, *args)
3885 r"""__str__(BoundingBox5D self) -> std::string"""
3886 return _IMP_algebra.BoundingBox5D___str__(self)
3889 r"""__repr__(BoundingBox5D self) -> std::string"""
3890 return _IMP_algebra.BoundingBox5D___repr__(self)
3892 def __cmp__(self, arg2):
3893 r"""__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
3894 return _IMP_algebra.BoundingBox5D___cmp__(self, arg2)
3896 def __eq__(self, arg2):
3897 r"""__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
3898 return _IMP_algebra.BoundingBox5D___eq__(self, arg2)
3900 def __init__(self, *args):
3902 __init__(BoundingBox5D self, unsigned int d) -> BoundingBox5D
3903 __init__(BoundingBox5D self, Vector5D lb, Vector5D ub) -> BoundingBox5D
3904 __init__(BoundingBox5D self, Vector5D v) -> BoundingBox5D
3905 __init__(BoundingBox5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
3906 __init__(BoundingBox5D self) -> BoundingBox5D
3908 _IMP_algebra.BoundingBox5D_swiginit(self, _IMP_algebra.new_BoundingBox5D(*args))
3910 def __getitem__(self, index):
3911 r"""__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
3912 return _IMP_algebra.BoundingBox5D___getitem__(self, index)
3914 def __iadd__(self, *args):
3915 _IMP_algebra.BoundingBox5D___iadd__(self, *args)
3921 r"""__len__(BoundingBox5D self) -> unsigned int"""
3922 return _IMP_algebra.BoundingBox5D___len__(self)
3924 def __add__(self, *args):
3926 __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
3927 __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
3928 __add__(BoundingBox5D self, double o) -> BoundingBox5D
3930 return _IMP_algebra.BoundingBox5D___add__(self, *args)
3932 def _get_as_binary(self):
3933 r"""_get_as_binary(BoundingBox5D self) -> PyObject *"""
3934 return _IMP_algebra.BoundingBox5D__get_as_binary(self)
3936 def _set_from_binary(self, p):
3937 r"""_set_from_binary(BoundingBox5D self, PyObject * p)"""
3938 return _IMP_algebra.BoundingBox5D__set_from_binary(self, p)
3940 def __getstate__(self):
3941 p = self._get_as_binary()
3942 if len(self.__dict__) > 1:
3943 d = self.__dict__.copy()
3948 def __setstate__(self, p):
3949 if not hasattr(self,
'this'):
3951 if isinstance(p, tuple):
3953 self.__dict__.update(d)
3954 return self._set_from_binary(p)
3956 __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D
3959 _IMP_algebra.BoundingBox5D_swigregister(BoundingBox5D)
3961 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 6 > class."""
3963 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3965 def get_dimension(self):
3966 r"""get_dimension(BoundingBox6D self) -> unsigned int"""
3967 return _IMP_algebra.BoundingBox6D_get_dimension(self)
3969 def get_corner(self, i):
3970 r"""get_corner(BoundingBox6D self, unsigned int i) -> Vector6D"""
3971 return _IMP_algebra.BoundingBox6D_get_corner(self, i)
3973 def get_contains(self, *args):
3975 get_contains(BoundingBox6D self, Vector6D o) -> bool
3976 get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
3978 return _IMP_algebra.BoundingBox6D_get_contains(self, *args)
3980 def show(self, *args):
3981 r"""show(BoundingBox6D self, _ostream out=std::cout)"""
3982 return _IMP_algebra.BoundingBox6D_show(self, *args)
3985 r"""__str__(BoundingBox6D self) -> std::string"""
3986 return _IMP_algebra.BoundingBox6D___str__(self)
3989 r"""__repr__(BoundingBox6D self) -> std::string"""
3990 return _IMP_algebra.BoundingBox6D___repr__(self)
3992 def __cmp__(self, arg2):
3993 r"""__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
3994 return _IMP_algebra.BoundingBox6D___cmp__(self, arg2)
3996 def __eq__(self, arg2):
3997 r"""__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
3998 return _IMP_algebra.BoundingBox6D___eq__(self, arg2)
4000 def __init__(self, *args):
4002 __init__(BoundingBox6D self, unsigned int d) -> BoundingBox6D
4003 __init__(BoundingBox6D self, Vector6D lb, Vector6D ub) -> BoundingBox6D
4004 __init__(BoundingBox6D self, Vector6D v) -> BoundingBox6D
4005 __init__(BoundingBox6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
4006 __init__(BoundingBox6D self) -> BoundingBox6D
4008 _IMP_algebra.BoundingBox6D_swiginit(self, _IMP_algebra.new_BoundingBox6D(*args))
4010 def __getitem__(self, index):
4011 r"""__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
4012 return _IMP_algebra.BoundingBox6D___getitem__(self, index)
4014 def __iadd__(self, *args):
4015 _IMP_algebra.BoundingBox6D___iadd__(self, *args)
4021 r"""__len__(BoundingBox6D self) -> unsigned int"""
4022 return _IMP_algebra.BoundingBox6D___len__(self)
4024 def __add__(self, *args):
4026 __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
4027 __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
4028 __add__(BoundingBox6D self, double o) -> BoundingBox6D
4030 return _IMP_algebra.BoundingBox6D___add__(self, *args)
4032 def _get_as_binary(self):
4033 r"""_get_as_binary(BoundingBox6D self) -> PyObject *"""
4034 return _IMP_algebra.BoundingBox6D__get_as_binary(self)
4036 def _set_from_binary(self, p):
4037 r"""_set_from_binary(BoundingBox6D self, PyObject * p)"""
4038 return _IMP_algebra.BoundingBox6D__set_from_binary(self, p)
4040 def __getstate__(self):
4041 p = self._get_as_binary()
4042 if len(self.__dict__) > 1:
4043 d = self.__dict__.copy()
4048 def __setstate__(self, p):
4049 if not hasattr(self,
'this'):
4051 if isinstance(p, tuple):
4053 self.__dict__.update(d)
4054 return self._set_from_binary(p)
4056 __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
4059 _IMP_algebra.BoundingBox6D_swigregister(BoundingBox6D)
4061 r"""Proxy of C++ IMP::algebra::BoundingBoxD< -1 > class."""
4063 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4065 def get_dimension(self):
4066 r"""get_dimension(BoundingBoxKD self) -> unsigned int"""
4067 return _IMP_algebra.BoundingBoxKD_get_dimension(self)
4069 def get_corner(self, i):
4070 r"""get_corner(BoundingBoxKD self, unsigned int i) -> VectorKD"""
4071 return _IMP_algebra.BoundingBoxKD_get_corner(self, i)
4073 def get_contains(self, *args):
4075 get_contains(BoundingBoxKD self, VectorKD o) -> bool
4076 get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
4078 return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)
4080 def show(self, *args):
4081 r"""show(BoundingBoxKD self, _ostream out=std::cout)"""
4082 return _IMP_algebra.BoundingBoxKD_show(self, *args)
4085 r"""__str__(BoundingBoxKD self) -> std::string"""
4086 return _IMP_algebra.BoundingBoxKD___str__(self)
4089 r"""__repr__(BoundingBoxKD self) -> std::string"""
4090 return _IMP_algebra.BoundingBoxKD___repr__(self)
4092 def __cmp__(self, arg2):
4093 r"""__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
4094 return _IMP_algebra.BoundingBoxKD___cmp__(self, arg2)
4096 def __eq__(self, arg2):
4097 r"""__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
4098 return _IMP_algebra.BoundingBoxKD___eq__(self, arg2)
4100 def __init__(self, *args):
4102 __init__(BoundingBoxKD self, unsigned int d) -> BoundingBoxKD
4103 __init__(BoundingBoxKD self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
4104 __init__(BoundingBoxKD self, VectorKD v) -> BoundingBoxKD
4105 __init__(BoundingBoxKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
4106 __init__(BoundingBoxKD self) -> BoundingBoxKD
4108 _IMP_algebra.BoundingBoxKD_swiginit(self, _IMP_algebra.new_BoundingBoxKD(*args))
4110 def __getitem__(self, index):
4111 r"""__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
4112 return _IMP_algebra.BoundingBoxKD___getitem__(self, index)
4114 def __iadd__(self, *args):
4115 _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
4121 r"""__len__(BoundingBoxKD self) -> unsigned int"""
4122 return _IMP_algebra.BoundingBoxKD___len__(self)
4124 def __add__(self, *args):
4126 __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
4127 __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
4128 __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
4130 return _IMP_algebra.BoundingBoxKD___add__(self, *args)
4132 def _get_as_binary(self):
4133 r"""_get_as_binary(BoundingBoxKD self) -> PyObject *"""
4134 return _IMP_algebra.BoundingBoxKD__get_as_binary(self)
4136 def _set_from_binary(self, p):
4137 r"""_set_from_binary(BoundingBoxKD self, PyObject * p)"""
4138 return _IMP_algebra.BoundingBoxKD__set_from_binary(self, p)
4140 def __getstate__(self):
4141 p = self._get_as_binary()
4142 if len(self.__dict__) > 1:
4143 d = self.__dict__.copy()
4148 def __setstate__(self, p):
4149 if not hasattr(self,
'this'):
4151 if isinstance(p, tuple):
4153 self.__dict__.update(d)
4154 return self._set_from_binary(p)
4156 __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
4159 _IMP_algebra.BoundingBoxKD_swigregister(BoundingBoxKD)
4160 class Sphere1D(_GeometricPrimitive1D):
4161 r"""Proxy of C++ IMP::algebra::SphereD< 1 > class."""
4163 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4165 def __init__(self, *args):
4167 __init__(Sphere1D self) -> Sphere1D
4168 __init__(Sphere1D self, Vector1D center, double radius) -> Sphere1D
4170 _IMP_algebra.Sphere1D_swiginit(self, _IMP_algebra.new_Sphere1D(*args))
4172 def get_radius(self):
4173 r"""get_radius(Sphere1D self) -> double"""
4174 return _IMP_algebra.Sphere1D_get_radius(self)
4176 def get_center(self):
4177 r"""get_center(Sphere1D self) -> Vector1D"""
4178 return _IMP_algebra.Sphere1D_get_center(self)
4180 def get_contains(self, *args):
4182 get_contains(Sphere1D self, Sphere1D o) -> bool
4183 get_contains(Sphere1D self, Vector1D p) -> bool
4185 return _IMP_algebra.Sphere1D_get_contains(self, *args)
4187 def show(self, *args):
4188 r"""show(Sphere1D self, _ostream out=std::cout)"""
4189 return _IMP_algebra.Sphere1D_show(self, *args)
4191 def get_dimension(self):
4192 r"""get_dimension(Sphere1D self) -> unsigned int"""
4193 return _IMP_algebra.Sphere1D_get_dimension(self)
4196 r"""__str__(Sphere1D self) -> std::string"""
4197 return _IMP_algebra.Sphere1D___str__(self)
4200 r"""__repr__(Sphere1D self) -> std::string"""
4201 return _IMP_algebra.Sphere1D___repr__(self)
4203 def __cmp__(self, arg2):
4204 r"""__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
4205 return _IMP_algebra.Sphere1D___cmp__(self, arg2)
4207 def __eq__(self, arg2):
4208 r"""__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
4209 return _IMP_algebra.Sphere1D___eq__(self, arg2)
4211 def _get_as_binary(self):
4212 r"""_get_as_binary(Sphere1D self) -> PyObject *"""
4213 return _IMP_algebra.Sphere1D__get_as_binary(self)
4215 def _set_from_binary(self, p):
4216 r"""_set_from_binary(Sphere1D self, PyObject * p)"""
4217 return _IMP_algebra.Sphere1D__set_from_binary(self, p)
4219 def __getstate__(self):
4220 p = self._get_as_binary()
4221 if len(self.__dict__) > 1:
4222 d = self.__dict__.copy()
4227 def __setstate__(self, p):
4228 if not hasattr(self,
'this'):
4230 if isinstance(p, tuple):
4232 self.__dict__.update(d)
4233 return self._set_from_binary(p)
4235 __swig_destroy__ = _IMP_algebra.delete_Sphere1D
4238 _IMP_algebra.Sphere1D_swigregister(Sphere1D)
4239 class Sphere2D(_GeometricPrimitive2D):
4240 r"""Proxy of C++ IMP::algebra::SphereD< 2 > class."""
4242 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4244 def __init__(self, *args):
4246 __init__(Sphere2D self) -> Sphere2D
4247 __init__(Sphere2D self, Vector2D center, double radius) -> Sphere2D
4249 _IMP_algebra.Sphere2D_swiginit(self, _IMP_algebra.new_Sphere2D(*args))
4251 def get_radius(self):
4252 r"""get_radius(Sphere2D self) -> double"""
4253 return _IMP_algebra.Sphere2D_get_radius(self)
4255 def get_center(self):
4256 r"""get_center(Sphere2D self) -> Vector2D"""
4257 return _IMP_algebra.Sphere2D_get_center(self)
4259 def get_contains(self, *args):
4261 get_contains(Sphere2D self, Sphere2D o) -> bool
4262 get_contains(Sphere2D self, Vector2D p) -> bool
4264 return _IMP_algebra.Sphere2D_get_contains(self, *args)
4266 def show(self, *args):
4267 r"""show(Sphere2D self, _ostream out=std::cout)"""
4268 return _IMP_algebra.Sphere2D_show(self, *args)
4270 def get_dimension(self):
4271 r"""get_dimension(Sphere2D self) -> unsigned int"""
4272 return _IMP_algebra.Sphere2D_get_dimension(self)
4275 r"""__str__(Sphere2D self) -> std::string"""
4276 return _IMP_algebra.Sphere2D___str__(self)
4279 r"""__repr__(Sphere2D self) -> std::string"""
4280 return _IMP_algebra.Sphere2D___repr__(self)
4282 def __cmp__(self, arg2):
4283 r"""__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
4284 return _IMP_algebra.Sphere2D___cmp__(self, arg2)
4286 def __eq__(self, arg2):
4287 r"""__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
4288 return _IMP_algebra.Sphere2D___eq__(self, arg2)
4290 def _get_as_binary(self):
4291 r"""_get_as_binary(Sphere2D self) -> PyObject *"""
4292 return _IMP_algebra.Sphere2D__get_as_binary(self)
4294 def _set_from_binary(self, p):
4295 r"""_set_from_binary(Sphere2D self, PyObject * p)"""
4296 return _IMP_algebra.Sphere2D__set_from_binary(self, p)
4298 def __getstate__(self):
4299 p = self._get_as_binary()
4300 if len(self.__dict__) > 1:
4301 d = self.__dict__.copy()
4306 def __setstate__(self, p):
4307 if not hasattr(self,
'this'):
4309 if isinstance(p, tuple):
4311 self.__dict__.update(d)
4312 return self._set_from_binary(p)
4314 __swig_destroy__ = _IMP_algebra.delete_Sphere2D
4317 _IMP_algebra.Sphere2D_swigregister(Sphere2D)
4318 class Sphere3D(_GeometricPrimitive3D):
4319 r"""Proxy of C++ IMP::algebra::SphereD< 3 > class."""
4321 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4323 def __init__(self, *args):
4325 __init__(Sphere3D self) -> Sphere3D
4326 __init__(Sphere3D self, Vector3D center, double radius) -> Sphere3D
4328 _IMP_algebra.Sphere3D_swiginit(self, _IMP_algebra.new_Sphere3D(*args))
4330 def get_radius(self):
4331 r"""get_radius(Sphere3D self) -> double"""
4332 return _IMP_algebra.Sphere3D_get_radius(self)
4334 def get_center(self):
4335 r"""get_center(Sphere3D self) -> Vector3D"""
4336 return _IMP_algebra.Sphere3D_get_center(self)
4338 def get_contains(self, *args):
4340 get_contains(Sphere3D self, Sphere3D o) -> bool
4341 get_contains(Sphere3D self, Vector3D p) -> bool
4343 return _IMP_algebra.Sphere3D_get_contains(self, *args)
4345 def show(self, *args):
4346 r"""show(Sphere3D self, _ostream out=std::cout)"""
4347 return _IMP_algebra.Sphere3D_show(self, *args)
4349 def get_dimension(self):
4350 r"""get_dimension(Sphere3D self) -> unsigned int"""
4351 return _IMP_algebra.Sphere3D_get_dimension(self)
4354 r"""__str__(Sphere3D self) -> std::string"""
4355 return _IMP_algebra.Sphere3D___str__(self)
4358 r"""__repr__(Sphere3D self) -> std::string"""
4359 return _IMP_algebra.Sphere3D___repr__(self)
4361 def __cmp__(self, arg2):
4362 r"""__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
4363 return _IMP_algebra.Sphere3D___cmp__(self, arg2)
4365 def __eq__(self, arg2):
4366 r"""__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
4367 return _IMP_algebra.Sphere3D___eq__(self, arg2)
4369 def _get_as_binary(self):
4370 r"""_get_as_binary(Sphere3D self) -> PyObject *"""
4371 return _IMP_algebra.Sphere3D__get_as_binary(self)
4373 def _set_from_binary(self, p):
4374 r"""_set_from_binary(Sphere3D self, PyObject * p)"""
4375 return _IMP_algebra.Sphere3D__set_from_binary(self, p)
4377 def __getstate__(self):
4378 p = self._get_as_binary()
4379 if len(self.__dict__) > 1:
4380 d = self.__dict__.copy()
4385 def __setstate__(self, p):
4386 if not hasattr(self,
'this'):
4388 if isinstance(p, tuple):
4390 self.__dict__.update(d)
4391 return self._set_from_binary(p)
4393 __swig_destroy__ = _IMP_algebra.delete_Sphere3D
4396 _IMP_algebra.Sphere3D_swigregister(Sphere3D)
4397 class Sphere4D(_GeometricPrimitive4D):
4398 r"""Proxy of C++ IMP::algebra::SphereD< 4 > class."""
4400 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4402 def __init__(self, *args):
4404 __init__(Sphere4D self) -> Sphere4D
4405 __init__(Sphere4D self, Vector4D center, double radius) -> Sphere4D
4407 _IMP_algebra.Sphere4D_swiginit(self, _IMP_algebra.new_Sphere4D(*args))
4409 def get_radius(self):
4410 r"""get_radius(Sphere4D self) -> double"""
4411 return _IMP_algebra.Sphere4D_get_radius(self)
4413 def get_center(self):
4414 r"""get_center(Sphere4D self) -> Vector4D"""
4415 return _IMP_algebra.Sphere4D_get_center(self)
4417 def get_contains(self, *args):
4419 get_contains(Sphere4D self, Sphere4D o) -> bool
4420 get_contains(Sphere4D self, Vector4D p) -> bool
4422 return _IMP_algebra.Sphere4D_get_contains(self, *args)
4424 def show(self, *args):
4425 r"""show(Sphere4D self, _ostream out=std::cout)"""
4426 return _IMP_algebra.Sphere4D_show(self, *args)
4428 def get_dimension(self):
4429 r"""get_dimension(Sphere4D self) -> unsigned int"""
4430 return _IMP_algebra.Sphere4D_get_dimension(self)
4433 r"""__str__(Sphere4D self) -> std::string"""
4434 return _IMP_algebra.Sphere4D___str__(self)
4437 r"""__repr__(Sphere4D self) -> std::string"""
4438 return _IMP_algebra.Sphere4D___repr__(self)
4440 def __cmp__(self, arg2):
4441 r"""__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
4442 return _IMP_algebra.Sphere4D___cmp__(self, arg2)
4444 def __eq__(self, arg2):
4445 r"""__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
4446 return _IMP_algebra.Sphere4D___eq__(self, arg2)
4448 def _get_as_binary(self):
4449 r"""_get_as_binary(Sphere4D self) -> PyObject *"""
4450 return _IMP_algebra.Sphere4D__get_as_binary(self)
4452 def _set_from_binary(self, p):
4453 r"""_set_from_binary(Sphere4D self, PyObject * p)"""
4454 return _IMP_algebra.Sphere4D__set_from_binary(self, p)
4456 def __getstate__(self):
4457 p = self._get_as_binary()
4458 if len(self.__dict__) > 1:
4459 d = self.__dict__.copy()
4464 def __setstate__(self, p):
4465 if not hasattr(self,
'this'):
4467 if isinstance(p, tuple):
4469 self.__dict__.update(d)
4470 return self._set_from_binary(p)
4472 __swig_destroy__ = _IMP_algebra.delete_Sphere4D
4475 _IMP_algebra.Sphere4D_swigregister(Sphere4D)
4476 class Sphere5D(_GeometricPrimitive5D):
4477 r"""Proxy of C++ IMP::algebra::SphereD< 5 > class."""
4479 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4481 def __init__(self, *args):
4483 __init__(Sphere5D self) -> Sphere5D
4484 __init__(Sphere5D self, Vector5D center, double radius) -> Sphere5D
4486 _IMP_algebra.Sphere5D_swiginit(self, _IMP_algebra.new_Sphere5D(*args))
4488 def get_radius(self):
4489 r"""get_radius(Sphere5D self) -> double"""
4490 return _IMP_algebra.Sphere5D_get_radius(self)
4492 def get_center(self):
4493 r"""get_center(Sphere5D self) -> Vector5D"""
4494 return _IMP_algebra.Sphere5D_get_center(self)
4496 def get_contains(self, *args):
4498 get_contains(Sphere5D self, Sphere5D o) -> bool
4499 get_contains(Sphere5D self, Vector5D p) -> bool
4501 return _IMP_algebra.Sphere5D_get_contains(self, *args)
4503 def show(self, *args):
4504 r"""show(Sphere5D self, _ostream out=std::cout)"""
4505 return _IMP_algebra.Sphere5D_show(self, *args)
4507 def get_dimension(self):
4508 r"""get_dimension(Sphere5D self) -> unsigned int"""
4509 return _IMP_algebra.Sphere5D_get_dimension(self)
4512 r"""__str__(Sphere5D self) -> std::string"""
4513 return _IMP_algebra.Sphere5D___str__(self)
4516 r"""__repr__(Sphere5D self) -> std::string"""
4517 return _IMP_algebra.Sphere5D___repr__(self)
4519 def __cmp__(self, arg2):
4520 r"""__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
4521 return _IMP_algebra.Sphere5D___cmp__(self, arg2)
4523 def __eq__(self, arg2):
4524 r"""__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
4525 return _IMP_algebra.Sphere5D___eq__(self, arg2)
4527 def _get_as_binary(self):
4528 r"""_get_as_binary(Sphere5D self) -> PyObject *"""
4529 return _IMP_algebra.Sphere5D__get_as_binary(self)
4531 def _set_from_binary(self, p):
4532 r"""_set_from_binary(Sphere5D self, PyObject * p)"""
4533 return _IMP_algebra.Sphere5D__set_from_binary(self, p)
4535 def __getstate__(self):
4536 p = self._get_as_binary()
4537 if len(self.__dict__) > 1:
4538 d = self.__dict__.copy()
4543 def __setstate__(self, p):
4544 if not hasattr(self,
'this'):
4546 if isinstance(p, tuple):
4548 self.__dict__.update(d)
4549 return self._set_from_binary(p)
4551 __swig_destroy__ = _IMP_algebra.delete_Sphere5D
4554 _IMP_algebra.Sphere5D_swigregister(Sphere5D)
4555 class Sphere6D(_GeometricPrimitive6D):
4556 r"""Proxy of C++ IMP::algebra::SphereD< 6 > class."""
4558 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4560 def __init__(self, *args):
4562 __init__(Sphere6D self) -> Sphere6D
4563 __init__(Sphere6D self, Vector6D center, double radius) -> Sphere6D
4565 _IMP_algebra.Sphere6D_swiginit(self, _IMP_algebra.new_Sphere6D(*args))
4567 def get_radius(self):
4568 r"""get_radius(Sphere6D self) -> double"""
4569 return _IMP_algebra.Sphere6D_get_radius(self)
4571 def get_center(self):
4572 r"""get_center(Sphere6D self) -> Vector6D"""
4573 return _IMP_algebra.Sphere6D_get_center(self)
4575 def get_contains(self, *args):
4577 get_contains(Sphere6D self, Sphere6D o) -> bool
4578 get_contains(Sphere6D self, Vector6D p) -> bool
4580 return _IMP_algebra.Sphere6D_get_contains(self, *args)
4582 def show(self, *args):
4583 r"""show(Sphere6D self, _ostream out=std::cout)"""
4584 return _IMP_algebra.Sphere6D_show(self, *args)
4586 def get_dimension(self):
4587 r"""get_dimension(Sphere6D self) -> unsigned int"""
4588 return _IMP_algebra.Sphere6D_get_dimension(self)
4591 r"""__str__(Sphere6D self) -> std::string"""
4592 return _IMP_algebra.Sphere6D___str__(self)
4595 r"""__repr__(Sphere6D self) -> std::string"""
4596 return _IMP_algebra.Sphere6D___repr__(self)
4598 def __cmp__(self, arg2):
4599 r"""__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
4600 return _IMP_algebra.Sphere6D___cmp__(self, arg2)
4602 def __eq__(self, arg2):
4603 r"""__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
4604 return _IMP_algebra.Sphere6D___eq__(self, arg2)
4606 def _get_as_binary(self):
4607 r"""_get_as_binary(Sphere6D self) -> PyObject *"""
4608 return _IMP_algebra.Sphere6D__get_as_binary(self)
4610 def _set_from_binary(self, p):
4611 r"""_set_from_binary(Sphere6D self, PyObject * p)"""
4612 return _IMP_algebra.Sphere6D__set_from_binary(self, p)
4614 def __getstate__(self):
4615 p = self._get_as_binary()
4616 if len(self.__dict__) > 1:
4617 d = self.__dict__.copy()
4622 def __setstate__(self, p):
4623 if not hasattr(self,
'this'):
4625 if isinstance(p, tuple):
4627 self.__dict__.update(d)
4628 return self._set_from_binary(p)
4630 __swig_destroy__ = _IMP_algebra.delete_Sphere6D
4633 _IMP_algebra.Sphere6D_swigregister(Sphere6D)
4634 class SphereKD(_GeometricPrimitiveKD):
4635 r"""Proxy of C++ IMP::algebra::SphereD< -1 > class."""
4637 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4639 def __init__(self, *args):
4641 __init__(SphereKD self) -> SphereKD
4642 __init__(SphereKD self, VectorKD center, double radius) -> SphereKD
4644 _IMP_algebra.SphereKD_swiginit(self, _IMP_algebra.new_SphereKD(*args))
4646 def get_radius(self):
4647 r"""get_radius(SphereKD self) -> double"""
4648 return _IMP_algebra.SphereKD_get_radius(self)
4650 def get_center(self):
4651 r"""get_center(SphereKD self) -> VectorKD"""
4652 return _IMP_algebra.SphereKD_get_center(self)
4654 def get_contains(self, *args):
4656 get_contains(SphereKD self, SphereKD o) -> bool
4657 get_contains(SphereKD self, VectorKD p) -> bool
4659 return _IMP_algebra.SphereKD_get_contains(self, *args)
4661 def show(self, *args):
4662 r"""show(SphereKD self, _ostream out=std::cout)"""
4663 return _IMP_algebra.SphereKD_show(self, *args)
4665 def get_dimension(self):
4666 r"""get_dimension(SphereKD self) -> unsigned int"""
4667 return _IMP_algebra.SphereKD_get_dimension(self)
4670 r"""__str__(SphereKD self) -> std::string"""
4671 return _IMP_algebra.SphereKD___str__(self)
4674 r"""__repr__(SphereKD self) -> std::string"""
4675 return _IMP_algebra.SphereKD___repr__(self)
4677 def __cmp__(self, arg2):
4678 r"""__cmp__(SphereKD self, SphereKD arg2) -> int"""
4679 return _IMP_algebra.SphereKD___cmp__(self, arg2)
4681 def __eq__(self, arg2):
4682 r"""__eq__(SphereKD self, SphereKD arg2) -> bool"""
4683 return _IMP_algebra.SphereKD___eq__(self, arg2)
4685 def _get_as_binary(self):
4686 r"""_get_as_binary(SphereKD self) -> PyObject *"""
4687 return _IMP_algebra.SphereKD__get_as_binary(self)
4689 def _set_from_binary(self, p):
4690 r"""_set_from_binary(SphereKD self, PyObject * p)"""
4691 return _IMP_algebra.SphereKD__set_from_binary(self, p)
4693 def __getstate__(self):
4694 p = self._get_as_binary()
4695 if len(self.__dict__) > 1:
4696 d = self.__dict__.copy()
4701 def __setstate__(self, p):
4702 if not hasattr(self,
'this'):
4704 if isinstance(p, tuple):
4706 self.__dict__.update(d)
4707 return self._set_from_binary(p)
4709 __swig_destroy__ = _IMP_algebra.delete_SphereKD
4712 _IMP_algebra.SphereKD_swigregister(SphereKD)
4713 class UnitSimplex1D(_UnitSimplexBase1D):
4714 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 1 > class."""
4716 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4719 r"""__init__(UnitSimplex1D self) -> UnitSimplex1D"""
4720 _IMP_algebra.UnitSimplex1D_swiginit(self, _IMP_algebra.new_UnitSimplex1D())
4722 def show(self, *args):
4723 r"""show(UnitSimplex1D self, _ostream out=std::cout)"""
4724 return _IMP_algebra.UnitSimplex1D_show(self, *args)
4727 r"""__str__(UnitSimplex1D self) -> std::string"""
4728 return _IMP_algebra.UnitSimplex1D___str__(self)
4731 r"""__repr__(UnitSimplex1D self) -> std::string"""
4732 return _IMP_algebra.UnitSimplex1D___repr__(self)
4734 def __cmp__(self, arg2):
4735 r"""__cmp__(UnitSimplex1D self, UnitSimplex1D arg2) -> int"""
4736 return _IMP_algebra.UnitSimplex1D___cmp__(self, arg2)
4738 def __eq__(self, arg2):
4739 r"""__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
4740 return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)
4742 def _get_as_binary(self):
4743 r"""_get_as_binary(UnitSimplex1D self) -> PyObject *"""
4744 return _IMP_algebra.UnitSimplex1D__get_as_binary(self)
4746 def _set_from_binary(self, p):
4747 r"""_set_from_binary(UnitSimplex1D self, PyObject * p)"""
4748 return _IMP_algebra.UnitSimplex1D__set_from_binary(self, p)
4750 def __getstate__(self):
4751 p = self._get_as_binary()
4752 if len(self.__dict__) > 1:
4753 d = self.__dict__.copy()
4758 def __setstate__(self, p):
4759 if not hasattr(self,
'this'):
4761 if isinstance(p, tuple):
4763 self.__dict__.update(d)
4764 return self._set_from_binary(p)
4766 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D
4769 _IMP_algebra.UnitSimplex1D_swigregister(UnitSimplex1D)
4770 class UnitSimplex2D(_UnitSimplexBase2D):
4771 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 2 > class."""
4773 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4776 r"""__init__(UnitSimplex2D self) -> UnitSimplex2D"""
4777 _IMP_algebra.UnitSimplex2D_swiginit(self, _IMP_algebra.new_UnitSimplex2D())
4779 def show(self, *args):
4780 r"""show(UnitSimplex2D self, _ostream out=std::cout)"""
4781 return _IMP_algebra.UnitSimplex2D_show(self, *args)
4784 r"""__str__(UnitSimplex2D self) -> std::string"""
4785 return _IMP_algebra.UnitSimplex2D___str__(self)
4788 r"""__repr__(UnitSimplex2D self) -> std::string"""
4789 return _IMP_algebra.UnitSimplex2D___repr__(self)
4791 def __cmp__(self, arg2):
4792 r"""__cmp__(UnitSimplex2D self, UnitSimplex2D arg2) -> int"""
4793 return _IMP_algebra.UnitSimplex2D___cmp__(self, arg2)
4795 def __eq__(self, arg2):
4796 r"""__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
4797 return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)
4799 def _get_as_binary(self):
4800 r"""_get_as_binary(UnitSimplex2D self) -> PyObject *"""
4801 return _IMP_algebra.UnitSimplex2D__get_as_binary(self)
4803 def _set_from_binary(self, p):
4804 r"""_set_from_binary(UnitSimplex2D self, PyObject * p)"""
4805 return _IMP_algebra.UnitSimplex2D__set_from_binary(self, p)
4807 def __getstate__(self):
4808 p = self._get_as_binary()
4809 if len(self.__dict__) > 1:
4810 d = self.__dict__.copy()
4815 def __setstate__(self, p):
4816 if not hasattr(self,
'this'):
4818 if isinstance(p, tuple):
4820 self.__dict__.update(d)
4821 return self._set_from_binary(p)
4823 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D
4826 _IMP_algebra.UnitSimplex2D_swigregister(UnitSimplex2D)
4827 class UnitSimplex3D(_UnitSimplexBase3D):
4828 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 3 > class."""
4830 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4833 r"""__init__(UnitSimplex3D self) -> UnitSimplex3D"""
4834 _IMP_algebra.UnitSimplex3D_swiginit(self, _IMP_algebra.new_UnitSimplex3D())
4836 def show(self, *args):
4837 r"""show(UnitSimplex3D self, _ostream out=std::cout)"""
4838 return _IMP_algebra.UnitSimplex3D_show(self, *args)
4841 r"""__str__(UnitSimplex3D self) -> std::string"""
4842 return _IMP_algebra.UnitSimplex3D___str__(self)
4845 r"""__repr__(UnitSimplex3D self) -> std::string"""
4846 return _IMP_algebra.UnitSimplex3D___repr__(self)
4848 def __cmp__(self, arg2):
4849 r"""__cmp__(UnitSimplex3D self, UnitSimplex3D arg2) -> int"""
4850 return _IMP_algebra.UnitSimplex3D___cmp__(self, arg2)
4852 def __eq__(self, arg2):
4853 r"""__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
4854 return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)
4856 def _get_as_binary(self):
4857 r"""_get_as_binary(UnitSimplex3D self) -> PyObject *"""
4858 return _IMP_algebra.UnitSimplex3D__get_as_binary(self)
4860 def _set_from_binary(self, p):
4861 r"""_set_from_binary(UnitSimplex3D self, PyObject * p)"""
4862 return _IMP_algebra.UnitSimplex3D__set_from_binary(self, p)
4864 def __getstate__(self):
4865 p = self._get_as_binary()
4866 if len(self.__dict__) > 1:
4867 d = self.__dict__.copy()
4872 def __setstate__(self, p):
4873 if not hasattr(self,
'this'):
4875 if isinstance(p, tuple):
4877 self.__dict__.update(d)
4878 return self._set_from_binary(p)
4880 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D
4883 _IMP_algebra.UnitSimplex3D_swigregister(UnitSimplex3D)
4884 class UnitSimplex4D(_UnitSimplexBase4D):
4885 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 4 > class."""
4887 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4890 r"""__init__(UnitSimplex4D self) -> UnitSimplex4D"""
4891 _IMP_algebra.UnitSimplex4D_swiginit(self, _IMP_algebra.new_UnitSimplex4D())
4893 def show(self, *args):
4894 r"""show(UnitSimplex4D self, _ostream out=std::cout)"""
4895 return _IMP_algebra.UnitSimplex4D_show(self, *args)
4898 r"""__str__(UnitSimplex4D self) -> std::string"""
4899 return _IMP_algebra.UnitSimplex4D___str__(self)
4902 r"""__repr__(UnitSimplex4D self) -> std::string"""
4903 return _IMP_algebra.UnitSimplex4D___repr__(self)
4905 def __cmp__(self, arg2):
4906 r"""__cmp__(UnitSimplex4D self, UnitSimplex4D arg2) -> int"""
4907 return _IMP_algebra.UnitSimplex4D___cmp__(self, arg2)
4909 def __eq__(self, arg2):
4910 r"""__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
4911 return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)
4913 def _get_as_binary(self):
4914 r"""_get_as_binary(UnitSimplex4D self) -> PyObject *"""
4915 return _IMP_algebra.UnitSimplex4D__get_as_binary(self)
4917 def _set_from_binary(self, p):
4918 r"""_set_from_binary(UnitSimplex4D self, PyObject * p)"""
4919 return _IMP_algebra.UnitSimplex4D__set_from_binary(self, p)
4921 def __getstate__(self):
4922 p = self._get_as_binary()
4923 if len(self.__dict__) > 1:
4924 d = self.__dict__.copy()
4929 def __setstate__(self, p):
4930 if not hasattr(self,
'this'):
4932 if isinstance(p, tuple):
4934 self.__dict__.update(d)
4935 return self._set_from_binary(p)
4937 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D
4940 _IMP_algebra.UnitSimplex4D_swigregister(UnitSimplex4D)
4941 class UnitSimplex5D(_UnitSimplexBase5D):
4942 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 5 > class."""
4944 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4947 r"""__init__(UnitSimplex5D self) -> UnitSimplex5D"""
4948 _IMP_algebra.UnitSimplex5D_swiginit(self, _IMP_algebra.new_UnitSimplex5D())
4950 def show(self, *args):
4951 r"""show(UnitSimplex5D self, _ostream out=std::cout)"""
4952 return _IMP_algebra.UnitSimplex5D_show(self, *args)
4955 r"""__str__(UnitSimplex5D self) -> std::string"""
4956 return _IMP_algebra.UnitSimplex5D___str__(self)
4959 r"""__repr__(UnitSimplex5D self) -> std::string"""
4960 return _IMP_algebra.UnitSimplex5D___repr__(self)
4962 def __cmp__(self, arg2):
4963 r"""__cmp__(UnitSimplex5D self, UnitSimplex5D arg2) -> int"""
4964 return _IMP_algebra.UnitSimplex5D___cmp__(self, arg2)
4966 def __eq__(self, arg2):
4967 r"""__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
4968 return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)
4970 def _get_as_binary(self):
4971 r"""_get_as_binary(UnitSimplex5D self) -> PyObject *"""
4972 return _IMP_algebra.UnitSimplex5D__get_as_binary(self)
4974 def _set_from_binary(self, p):
4975 r"""_set_from_binary(UnitSimplex5D self, PyObject * p)"""
4976 return _IMP_algebra.UnitSimplex5D__set_from_binary(self, p)
4978 def __getstate__(self):
4979 p = self._get_as_binary()
4980 if len(self.__dict__) > 1:
4981 d = self.__dict__.copy()
4986 def __setstate__(self, p):
4987 if not hasattr(self,
'this'):
4989 if isinstance(p, tuple):
4991 self.__dict__.update(d)
4992 return self._set_from_binary(p)
4994 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D
4997 _IMP_algebra.UnitSimplex5D_swigregister(UnitSimplex5D)
4998 class UnitSimplex6D(_UnitSimplexBase6D):
4999 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 6 > class."""
5001 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5004 r"""__init__(UnitSimplex6D self) -> UnitSimplex6D"""
5005 _IMP_algebra.UnitSimplex6D_swiginit(self, _IMP_algebra.new_UnitSimplex6D())
5007 def show(self, *args):
5008 r"""show(UnitSimplex6D self, _ostream out=std::cout)"""
5009 return _IMP_algebra.UnitSimplex6D_show(self, *args)
5012 r"""__str__(UnitSimplex6D self) -> std::string"""
5013 return _IMP_algebra.UnitSimplex6D___str__(self)
5016 r"""__repr__(UnitSimplex6D self) -> std::string"""
5017 return _IMP_algebra.UnitSimplex6D___repr__(self)
5019 def __cmp__(self, arg2):
5020 r"""__cmp__(UnitSimplex6D self, UnitSimplex6D arg2) -> int"""
5021 return _IMP_algebra.UnitSimplex6D___cmp__(self, arg2)
5023 def __eq__(self, arg2):
5024 r"""__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
5025 return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)
5027 def _get_as_binary(self):
5028 r"""_get_as_binary(UnitSimplex6D self) -> PyObject *"""
5029 return _IMP_algebra.UnitSimplex6D__get_as_binary(self)
5031 def _set_from_binary(self, p):
5032 r"""_set_from_binary(UnitSimplex6D self, PyObject * p)"""
5033 return _IMP_algebra.UnitSimplex6D__set_from_binary(self, p)
5035 def __getstate__(self):
5036 p = self._get_as_binary()
5037 if len(self.__dict__) > 1:
5038 d = self.__dict__.copy()
5043 def __setstate__(self, p):
5044 if not hasattr(self,
'this'):
5046 if isinstance(p, tuple):
5048 self.__dict__.update(d)
5049 return self._set_from_binary(p)
5051 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D
5054 _IMP_algebra.UnitSimplex6D_swigregister(UnitSimplex6D)
5055 class UnitSimplexKD(_UnitSimplexBaseKD):
5056 r"""Proxy of C++ IMP::algebra::UnitSimplexD< -1 > class."""
5058 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5059 __repr__ = _swig_repr
5061 def __init__(self, d=1):
5062 r"""__init__(UnitSimplexKD self, int d=1) -> UnitSimplexKD"""
5063 _IMP_algebra.UnitSimplexKD_swiginit(self, _IMP_algebra.new_UnitSimplexKD(d))
5065 def show(self, *args):
5066 r"""show(UnitSimplexKD self, _ostream out=std::cout)"""
5067 return _IMP_algebra.UnitSimplexKD_show(self, *args)
5069 def _get_as_binary(self):
5070 r"""_get_as_binary(UnitSimplexKD self) -> PyObject *"""
5071 return _IMP_algebra.UnitSimplexKD__get_as_binary(self)
5073 def _set_from_binary(self, p):
5074 r"""_set_from_binary(UnitSimplexKD self, PyObject * p)"""
5075 return _IMP_algebra.UnitSimplexKD__set_from_binary(self, p)
5077 def __getstate__(self):
5078 p = self._get_as_binary()
5079 if len(self.__dict__) > 1:
5080 d = self.__dict__.copy()
5085 def __setstate__(self, p):
5086 if not hasattr(self,
'this'):
5088 if isinstance(p, tuple):
5090 self.__dict__.update(d)
5091 return self._set_from_binary(p)
5093 __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD
5096 _IMP_algebra.UnitSimplexKD_swigregister(UnitSimplexKD)
5097 class ReferenceFrame3D(object):
5098 r"""Proxy of C++ IMP::algebra::ReferenceFrame3D class."""
5100 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5102 def __init__(self, *args):
5104 __init__(ReferenceFrame3D self, ReferenceFrame3D arg2) -> ReferenceFrame3D
5105 __init__(ReferenceFrame3D self) -> ReferenceFrame3D
5106 __init__(ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
5108 _IMP_algebra.ReferenceFrame3D_swiginit(self, _IMP_algebra.new_ReferenceFrame3D(*args))
5109 __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
5111 def get_transformation_to(self):
5112 r"""get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
5113 return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)
5115 def get_transformation_from(self):
5116 r"""get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
5117 return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)
5119 def get_global_coordinates(self, v):
5120 r"""get_global_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5121 return _IMP_algebra.ReferenceFrame3D_get_global_coordinates(self, v)
5123 def get_local_coordinates(self, v):
5124 r"""get_local_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5125 return _IMP_algebra.ReferenceFrame3D_get_local_coordinates(self, v)
5127 def get_global_reference_frame(self, v):
5128 r"""get_global_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5129 return _IMP_algebra.ReferenceFrame3D_get_global_reference_frame(self, v)
5131 def get_local_reference_frame(self, v):
5132 r"""get_local_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5133 return _IMP_algebra.ReferenceFrame3D_get_local_reference_frame(self, v)
5135 def show(self, *args):
5136 r"""show(ReferenceFrame3D self, _ostream out=std::cout)"""
5137 return _IMP_algebra.ReferenceFrame3D_show(self, *args)
5140 r"""__str__(ReferenceFrame3D self) -> std::string"""
5141 return _IMP_algebra.ReferenceFrame3D___str__(self)
5144 r"""__repr__(ReferenceFrame3D self) -> std::string"""
5145 return _IMP_algebra.ReferenceFrame3D___repr__(self)
5147 def _get_as_binary(self):
5148 r"""_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
5149 return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)
5151 def _set_from_binary(self, p):
5152 r"""_set_from_binary(ReferenceFrame3D self, PyObject * p)"""
5153 return _IMP_algebra.ReferenceFrame3D__set_from_binary(self, p)
5155 def __getstate__(self):
5156 p = self._get_as_binary()
5157 if len(self.__dict__) > 1:
5158 d = self.__dict__.copy()
5163 def __setstate__(self, p):
5164 if not hasattr(self,
'this'):
5166 if isinstance(p, tuple):
5168 self.__dict__.update(d)
5169 return self._set_from_binary(p)
5173 _IMP_algebra.ReferenceFrame3D_swigregister(ReferenceFrame3D)
5175 def get_transformed(*args):
5177 get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
5178 get_transformed(Line3D l, Transformation3D tr) -> Line3D
5179 get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
5181 return _IMP_algebra.get_transformed(*args)
5183 def get_transformation_from_first_to_second(a, b):
5184 r"""get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
5185 return _IMP_algebra.get_transformation_from_first_to_second(a, b)
5186 class SphericalVector3D(_GeometricPrimitive3D):
5187 r"""Proxy of C++ IMP::algebra::SphericalVector3D class."""
5189 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5191 def __init__(self, *args):
5193 __init__(SphericalVector3D self) -> SphericalVector3D
5194 __init__(SphericalVector3D self, Vector3D v) -> SphericalVector3D
5195 __init__(SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
5197 _IMP_algebra.SphericalVector3D_swiginit(self, _IMP_algebra.new_SphericalVector3D(*args))
5199 def get_cartesian_coordinates(self):
5200 r"""get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
5201 return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)
5203 def show(self, *args):
5204 r"""show(SphericalVector3D self, _ostream out=std::cout)"""
5205 return _IMP_algebra.SphericalVector3D_show(self, *args)
5208 r"""__str__(SphericalVector3D self) -> std::string"""
5209 return _IMP_algebra.SphericalVector3D___str__(self)
5212 r"""__repr__(SphericalVector3D self) -> std::string"""
5213 return _IMP_algebra.SphericalVector3D___repr__(self)
5215 def _get_as_binary(self):
5216 r"""_get_as_binary(SphericalVector3D self) -> PyObject *"""
5217 return _IMP_algebra.SphericalVector3D__get_as_binary(self)
5219 def _set_from_binary(self, p):
5220 r"""_set_from_binary(SphericalVector3D self, PyObject * p)"""
5221 return _IMP_algebra.SphericalVector3D__set_from_binary(self, p)
5223 def __getstate__(self):
5224 p = self._get_as_binary()
5225 if len(self.__dict__) > 1:
5226 d = self.__dict__.copy()
5231 def __setstate__(self, p):
5232 if not hasattr(self,
'this'):
5234 if isinstance(p, tuple):
5236 self.__dict__.update(d)
5237 return self._set_from_binary(p)
5240 def __getitem__(self, index):
5241 r"""__getitem__(SphericalVector3D self, unsigned int index) -> double"""
5242 return _IMP_algebra.SphericalVector3D___getitem__(self, index)
5244 def __setitem__(self, index, val):
5245 r"""__setitem__(SphericalVector3D self, unsigned int index, double val)"""
5246 return _IMP_algebra.SphericalVector3D___setitem__(self, index, val)
5247 __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D
5250 _IMP_algebra.SphericalVector3D_swigregister(SphericalVector3D)
5253 r"""get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
5254 return _IMP_algebra.get_alignments_from_first_to_second(pca1, pca2)
5255 class Line3D(_GeometricPrimitive3D):
5256 r"""Proxy of C++ IMP::algebra::Line3D class."""
5258 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5260 def __init__(self, *args):
5262 __init__(Line3D self) -> Line3D
5263 __init__(Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
5264 __init__(Line3D self, Segment3D s) -> Line3D
5266 _IMP_algebra.Line3D_swiginit(self, _IMP_algebra.new_Line3D(*args))
5268 def get_direction(self):
5269 r"""get_direction(Line3D self) -> Vector3D"""
5270 return _IMP_algebra.Line3D_get_direction(self)
5272 def get_point_on_line(self):
5273 r"""get_point_on_line(Line3D self) -> Vector3D"""
5274 return _IMP_algebra.Line3D_get_point_on_line(self)
5276 def get_moment(self, *args):
5278 get_moment(Line3D self) -> Vector3D
5279 get_moment(Line3D self, Vector3D v) -> Vector3D
5281 return _IMP_algebra.Line3D_get_moment(self, *args)
5283 def get_reciprocal_product(self, l):
5284 r"""get_reciprocal_product(Line3D self, Line3D l) -> double"""
5285 return _IMP_algebra.Line3D_get_reciprocal_product(self, l)
5287 def get_opposite(self):
5288 r"""get_opposite(Line3D self) -> Line3D"""
5289 return _IMP_algebra.Line3D_get_opposite(self)
5291 def get_segment_starting_at(self, v, d):
5292 r"""get_segment_starting_at(Line3D self, Vector3D v, double d) -> Segment3D"""
5293 return _IMP_algebra.Line3D_get_segment_starting_at(self, v, d)
5295 def show(self, *args):
5296 r"""show(Line3D self, _ostream out=std::cout)"""
5297 return _IMP_algebra.Line3D_show(self, *args)
5300 r"""__str__(Line3D self) -> std::string"""
5301 return _IMP_algebra.Line3D___str__(self)
5304 r"""__repr__(Line3D self) -> std::string"""
5305 return _IMP_algebra.Line3D___repr__(self)
5307 def _get_as_binary(self):
5308 r"""_get_as_binary(Line3D self) -> PyObject *"""
5309 return _IMP_algebra.Line3D__get_as_binary(self)
5311 def _set_from_binary(self, p):
5312 r"""_set_from_binary(Line3D self, PyObject * p)"""
5313 return _IMP_algebra.Line3D__set_from_binary(self, p)
5315 def __getstate__(self):
5316 p = self._get_as_binary()
5317 if len(self.__dict__) > 1:
5318 d = self.__dict__.copy()
5323 def __setstate__(self, p):
5324 if not hasattr(self,
'this'):
5326 if isinstance(p, tuple):
5328 self.__dict__.update(d)
5329 return self._set_from_binary(p)
5331 __swig_destroy__ = _IMP_algebra.delete_Line3D
5334 _IMP_algebra.Line3D_swigregister(Line3D)
5336 def get_line_3d_geometry(g):
5337 r"""get_line_3d_geometry(Line3D g) -> Line3D"""
5338 return _IMP_algebra.get_line_3d_geometry(g)
5341 r"""get_angle(Line3D a, Line3D b) -> double"""
5342 return _IMP_algebra.get_angle(a, b)
5345 r"""get_segment_connecting_first_to_second(Line3D a, Line3D b) -> Segment3D"""
5346 return _IMP_algebra.get_segment_connecting_first_to_second(a, b)
5347 class Segment3D(_GeometricPrimitive3D):
5348 r"""Proxy of C++ IMP::algebra::Segment3D class."""
5350 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5352 def __init__(self, *args):
5354 __init__(Segment3D self) -> Segment3D
5355 __init__(Segment3D self, Vector3D start, Vector3D end) -> Segment3D
5357 _IMP_algebra.Segment3D_swiginit(self, _IMP_algebra.new_Segment3D(*args))
5359 def get_point(self, i):
5362 return _IMP_algebra.Segment3D_get_point(self, i)
5366 def get_middle_point(self):
5367 r"""get_middle_point(Segment3D self) -> Vector3D"""
5368 return _IMP_algebra.Segment3D_get_middle_point(self)
5370 def get_direction(self):
5371 r"""get_direction(Segment3D self) -> Vector3D"""
5372 return _IMP_algebra.Segment3D_get_direction(self)
5374 def get_length(self):
5375 r"""get_length(Segment3D self) -> double"""
5376 return _IMP_algebra.Segment3D_get_length(self)
5378 def show(self, *args):
5379 r"""show(Segment3D self, _ostream out=std::cout)"""
5380 return _IMP_algebra.Segment3D_show(self, *args)
5383 r"""__str__(Segment3D self) -> std::string"""
5384 return _IMP_algebra.Segment3D___str__(self)
5387 r"""__repr__(Segment3D self) -> std::string"""
5388 return _IMP_algebra.Segment3D___repr__(self)
5390 def _get_as_binary(self):
5391 r"""_get_as_binary(Segment3D self) -> PyObject *"""
5392 return _IMP_algebra.Segment3D__get_as_binary(self)
5394 def _set_from_binary(self, p):
5395 r"""_set_from_binary(Segment3D self, PyObject * p)"""
5396 return _IMP_algebra.Segment3D__set_from_binary(self, p)
5398 def __getstate__(self):
5399 p = self._get_as_binary()
5400 if len(self.__dict__) > 1:
5401 d = self.__dict__.copy()
5406 def __setstate__(self, p):
5407 if not hasattr(self,
'this'):
5409 if isinstance(p, tuple):
5411 self.__dict__.update(d)
5412 return self._set_from_binary(p)
5414 __swig_destroy__ = _IMP_algebra.delete_Segment3D
5417 _IMP_algebra.Segment3D_swigregister(Segment3D)
5419 def get_segment_3d_geometry(g):
5420 r"""get_segment_3d_geometry(Segment3D g) -> Segment3D"""
5421 return _IMP_algebra.get_segment_3d_geometry(g)
5424 r"""get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
5425 return _IMP_algebra.get_relative_projection_on_segment(s, p)
5426 class Triangle3D(_GeometricPrimitive3D):
5427 r"""Proxy of C++ IMP::algebra::Triangle3D class."""
5429 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5431 def __init__(self, *args):
5433 __init__(Triangle3D self) -> Triangle3D
5434 __init__(Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
5436 _IMP_algebra.Triangle3D_swiginit(self, _IMP_algebra.new_Triangle3D(*args))
5438 def get_point(self, i):
5439 r"""get_point(Triangle3D self, unsigned int i) -> Vector3D"""
5440 return _IMP_algebra.Triangle3D_get_point(self, i)
5442 def show(self, *args):
5443 r"""show(Triangle3D self, _ostream out=std::cout)"""
5444 return _IMP_algebra.Triangle3D_show(self, *args)
5446 def get_edge_lengths(self):
5447 r"""get_edge_lengths(Triangle3D self) -> IMP::Floats"""
5448 return _IMP_algebra.Triangle3D_get_edge_lengths(self)
5451 r"""__str__(Triangle3D self) -> std::string"""
5452 return _IMP_algebra.Triangle3D___str__(self)
5455 r"""__repr__(Triangle3D self) -> std::string"""
5456 return _IMP_algebra.Triangle3D___repr__(self)
5458 def _get_as_binary(self):
5459 r"""_get_as_binary(Triangle3D self) -> PyObject *"""
5460 return _IMP_algebra.Triangle3D__get_as_binary(self)
5462 def _set_from_binary(self, p):
5463 r"""_set_from_binary(Triangle3D self, PyObject * p)"""
5464 return _IMP_algebra.Triangle3D__set_from_binary(self, p)
5466 def __getstate__(self):
5467 p = self._get_as_binary()
5468 if len(self.__dict__) > 1:
5469 d = self.__dict__.copy()
5474 def __setstate__(self, p):
5475 if not hasattr(self,
'this'):
5477 if isinstance(p, tuple):
5479 self.__dict__.update(d)
5480 return self._set_from_binary(p)
5482 __swig_destroy__ = _IMP_algebra.delete_Triangle3D
5485 _IMP_algebra.Triangle3D_swigregister(Triangle3D)
5488 r"""get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
5489 return _IMP_algebra.get_largest_triangle(points)
5492 r"""get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri) -> Transformation3D"""
5493 return _IMP_algebra.get_transformation_from_first_triangle_to_second(first_tri, second_tri)
5496 r"""get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
5497 return _IMP_algebra.get_are_colinear(p1, p2, p3)
5498 class LinearFit2D(_GeometricPrimitive2D):
5499 r"""Proxy of C++ IMP::algebra::LinearFit2D class."""
5501 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5503 def __init__(self, *args):
5505 __init__(LinearFit2D self) -> LinearFit2D
5506 __init__(LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
5508 _IMP_algebra.LinearFit2D_swiginit(self, _IMP_algebra.new_LinearFit2D(*args))
5510 def get_fit_error(self):
5511 r"""get_fit_error(LinearFit2D self) -> double"""
5512 return _IMP_algebra.LinearFit2D_get_fit_error(self)
5515 r"""get_a(LinearFit2D self) -> double"""
5516 return _IMP_algebra.LinearFit2D_get_a(self)
5519 r"""get_b(LinearFit2D self) -> double"""
5520 return _IMP_algebra.LinearFit2D_get_b(self)
5522 def show(self, *args):
5523 r"""show(LinearFit2D self, _ostream out=std::cout)"""
5524 return _IMP_algebra.LinearFit2D_show(self, *args)
5527 r"""__str__(LinearFit2D self) -> std::string"""
5528 return _IMP_algebra.LinearFit2D___str__(self)
5531 r"""__repr__(LinearFit2D self) -> std::string"""
5532 return _IMP_algebra.LinearFit2D___repr__(self)
5534 def _get_as_binary(self):
5535 r"""_get_as_binary(LinearFit2D self) -> PyObject *"""
5536 return _IMP_algebra.LinearFit2D__get_as_binary(self)
5538 def _set_from_binary(self, p):
5539 r"""_set_from_binary(LinearFit2D self, PyObject * p)"""
5540 return _IMP_algebra.LinearFit2D__set_from_binary(self, p)
5542 def __getstate__(self):
5543 p = self._get_as_binary()
5544 if len(self.__dict__) > 1:
5545 d = self.__dict__.copy()
5550 def __setstate__(self, p):
5551 if not hasattr(self,
'this'):
5553 if isinstance(p, tuple):
5555 self.__dict__.update(d)
5556 return self._set_from_binary(p)
5558 __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
5561 _IMP_algebra.LinearFit2D_swigregister(LinearFit2D)
5562 class ParabolicFit2D(_GeometricPrimitive2D):
5563 r"""Proxy of C++ IMP::algebra::ParabolicFit2D class."""
5565 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5567 def __init__(self, *args):
5569 __init__(ParabolicFit2D self) -> ParabolicFit2D
5570 __init__(ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
5572 _IMP_algebra.ParabolicFit2D_swiginit(self, _IMP_algebra.new_ParabolicFit2D(*args))
5574 def get_fit_error(self):
5575 r"""get_fit_error(ParabolicFit2D self) -> double"""
5576 return _IMP_algebra.ParabolicFit2D_get_fit_error(self)
5579 r"""get_a(ParabolicFit2D self) -> double"""
5580 return _IMP_algebra.ParabolicFit2D_get_a(self)
5583 r"""get_b(ParabolicFit2D self) -> double"""
5584 return _IMP_algebra.ParabolicFit2D_get_b(self)
5587 r"""get_c(ParabolicFit2D self) -> double"""
5588 return _IMP_algebra.ParabolicFit2D_get_c(self)
5590 def show(self, *args):
5591 r"""show(ParabolicFit2D self, _ostream out=std::cout)"""
5592 return _IMP_algebra.ParabolicFit2D_show(self, *args)
5595 r"""__str__(ParabolicFit2D self) -> std::string"""
5596 return _IMP_algebra.ParabolicFit2D___str__(self)
5599 r"""__repr__(ParabolicFit2D self) -> std::string"""
5600 return _IMP_algebra.ParabolicFit2D___repr__(self)
5602 def _get_as_binary(self):
5603 r"""_get_as_binary(ParabolicFit2D self) -> PyObject *"""
5604 return _IMP_algebra.ParabolicFit2D__get_as_binary(self)
5606 def _set_from_binary(self, p):
5607 r"""_set_from_binary(ParabolicFit2D self, PyObject * p)"""
5608 return _IMP_algebra.ParabolicFit2D__set_from_binary(self, p)
5610 def __getstate__(self):
5611 p = self._get_as_binary()
5612 if len(self.__dict__) > 1:
5613 d = self.__dict__.copy()
5618 def __setstate__(self, p):
5619 if not hasattr(self,
'this'):
5621 if isinstance(p, tuple):
5623 self.__dict__.update(d)
5624 return self._set_from_binary(p)
5626 __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
5629 _IMP_algebra.ParabolicFit2D_swigregister(ParabolicFit2D)
5630 class Plane3D(_GeometricPrimitive3D):
5631 r"""Proxy of C++ IMP::algebra::Plane3D class."""
5633 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5635 def __init__(self, *args):
5637 __init__(Plane3D self) -> Plane3D
5638 __init__(Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
5639 __init__(Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
5641 _IMP_algebra.Plane3D_swiginit(self, _IMP_algebra.new_Plane3D(*args))
5643 def get_point_on_plane(self):
5644 r"""get_point_on_plane(Plane3D self) -> Vector3D"""
5645 return _IMP_algebra.Plane3D_get_point_on_plane(self)
5647 def get_normal(self):
5648 r"""get_normal(Plane3D self) -> Vector3D"""
5649 return _IMP_algebra.Plane3D_get_normal(self)
5652 r"""get_projected(Plane3D self, Vector3D p) -> Vector3D"""
5653 return _IMP_algebra.Plane3D_get_projected(self, p)
5655 def get_is_above(self, p):
5656 r"""get_is_above(Plane3D self, Vector3D p) -> bool"""
5657 return _IMP_algebra.Plane3D_get_is_above(self, p)
5659 def get_is_below(self, p):
5660 r"""get_is_below(Plane3D self, Vector3D p) -> bool"""
5661 return _IMP_algebra.Plane3D_get_is_below(self, p)
5664 r"""get_height(Plane3D self, Vector3D p) -> double"""
5665 return _IMP_algebra.Plane3D_get_height(self, p)
5667 def show(self, *args):
5668 r"""show(Plane3D self, _ostream out=std::cout)"""
5669 return _IMP_algebra.Plane3D_show(self, *args)
5671 def get_opposite(self):
5672 r"""get_opposite(Plane3D self) -> Plane3D"""
5673 return _IMP_algebra.Plane3D_get_opposite(self)
5675 def get_distance_from_origin(self):
5676 r"""get_distance_from_origin(Plane3D self) -> double"""
5677 return _IMP_algebra.Plane3D_get_distance_from_origin(self)
5680 r"""__str__(Plane3D self) -> std::string"""
5681 return _IMP_algebra.Plane3D___str__(self)
5684 r"""__repr__(Plane3D self) -> std::string"""
5685 return _IMP_algebra.Plane3D___repr__(self)
5687 def _get_as_binary(self):
5688 r"""_get_as_binary(Plane3D self) -> PyObject *"""
5689 return _IMP_algebra.Plane3D__get_as_binary(self)
5691 def _set_from_binary(self, p):
5692 r"""_set_from_binary(Plane3D self, PyObject * p)"""
5693 return _IMP_algebra.Plane3D__set_from_binary(self, p)
5695 def __getstate__(self):
5696 p = self._get_as_binary()
5697 if len(self.__dict__) > 1:
5698 d = self.__dict__.copy()
5703 def __setstate__(self, p):
5704 if not hasattr(self,
'this'):
5706 if isinstance(p, tuple):
5708 self.__dict__.update(d)
5709 return self._set_from_binary(p)
5711 __swig_destroy__ = _IMP_algebra.delete_Plane3D
5714 _IMP_algebra.Plane3D_swigregister(Plane3D)
5717 r"""get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
5718 return _IMP_algebra.get_reflected(pln, p)
5720 def get_plane_3d_geometry(g):
5721 r"""get_plane_3d_geometry(Plane3D g) -> Plane3D"""
5722 return _IMP_algebra.get_plane_3d_geometry(g)
5723 class Reflection3D(_GeometricPrimitive3D):
5724 r"""Proxy of C++ IMP::algebra::Reflection3D class."""
5726 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5728 def __init__(self, *args):
5730 __init__(Reflection3D self) -> Reflection3D
5731 __init__(Reflection3D self, Plane3D pl) -> Reflection3D
5733 _IMP_algebra.Reflection3D_swiginit(self, _IMP_algebra.new_Reflection3D(*args))
5736 r"""get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
5737 return _IMP_algebra.Reflection3D_get_reflected(self, v)
5739 def show(self, *args):
5740 r"""show(Reflection3D self, _ostream out=std::cout)"""
5741 return _IMP_algebra.Reflection3D_show(self, *args)
5744 r"""__str__(Reflection3D self) -> std::string"""
5745 return _IMP_algebra.Reflection3D___str__(self)
5748 r"""__repr__(Reflection3D self) -> std::string"""
5749 return _IMP_algebra.Reflection3D___repr__(self)
5751 def _get_as_binary(self):
5752 r"""_get_as_binary(Reflection3D self) -> PyObject *"""
5753 return _IMP_algebra.Reflection3D__get_as_binary(self)
5755 def _set_from_binary(self, p):
5756 r"""_set_from_binary(Reflection3D self, PyObject * p)"""
5757 return _IMP_algebra.Reflection3D__set_from_binary(self, p)
5759 def __getstate__(self):
5760 p = self._get_as_binary()
5761 if len(self.__dict__) > 1:
5762 d = self.__dict__.copy()
5767 def __setstate__(self, p):
5768 if not hasattr(self,
'this'):
5770 if isinstance(p, tuple):
5772 self.__dict__.update(d)
5773 return self._set_from_binary(p)
5775 __swig_destroy__ = _IMP_algebra.delete_Reflection3D
5778 _IMP_algebra.Reflection3D_swigregister(Reflection3D)
5779 class Cylinder3D(_GeometricPrimitive3D):
5780 r"""Proxy of C++ IMP::algebra::Cylinder3D class."""
5782 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5784 def __init__(self, *args):
5786 __init__(Cylinder3D self) -> Cylinder3D
5787 __init__(Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
5789 _IMP_algebra.Cylinder3D_swiginit(self, _IMP_algebra.new_Cylinder3D(*args))
5791 def get_radius(self):
5792 r"""get_radius(Cylinder3D self) -> double"""
5793 return _IMP_algebra.Cylinder3D_get_radius(self)
5796 r"""get_segment(Cylinder3D self) -> Segment3D"""
5797 return _IMP_algebra.Cylinder3D_get_segment(self)
5799 def get_surface_point_at(self, relative_height, angle):
5800 r"""get_surface_point_at(Cylinder3D self, double relative_height, double angle) -> Vector3D"""
5801 return _IMP_algebra.Cylinder3D_get_surface_point_at(self, relative_height, angle)
5803 def get_inner_point_at(self, relative_height, relative_radius, angle):
5804 r"""get_inner_point_at(Cylinder3D self, double relative_height, double relative_radius, double angle) -> Vector3D"""
5805 return _IMP_algebra.Cylinder3D_get_inner_point_at(self, relative_height, relative_radius, angle)
5807 def show(self, *args):
5808 r"""show(Cylinder3D self, _ostream out=std::cout)"""
5809 return _IMP_algebra.Cylinder3D_show(self, *args)
5812 r"""__str__(Cylinder3D self) -> std::string"""
5813 return _IMP_algebra.Cylinder3D___str__(self)
5816 r"""__repr__(Cylinder3D self) -> std::string"""
5817 return _IMP_algebra.Cylinder3D___repr__(self)
5819 def _get_as_binary(self):
5820 r"""_get_as_binary(Cylinder3D self) -> PyObject *"""
5821 return _IMP_algebra.Cylinder3D__get_as_binary(self)
5823 def _set_from_binary(self, p):
5824 r"""_set_from_binary(Cylinder3D self, PyObject * p)"""
5825 return _IMP_algebra.Cylinder3D__set_from_binary(self, p)
5827 def __getstate__(self):
5828 p = self._get_as_binary()
5829 if len(self.__dict__) > 1:
5830 d = self.__dict__.copy()
5835 def __setstate__(self, p):
5836 if not hasattr(self,
'this'):
5838 if isinstance(p, tuple):
5840 self.__dict__.update(d)
5841 return self._set_from_binary(p)
5843 __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
5846 _IMP_algebra.Cylinder3D_swigregister(Cylinder3D)
5848 def get_cylinder_3d_geometry(g):
5849 r"""get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
5850 return _IMP_algebra.get_cylinder_3d_geometry(g)
5851 class Ellipsoid3D(_GeometricPrimitive3D):
5852 r"""Proxy of C++ IMP::algebra::Ellipsoid3D class."""
5854 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5856 def __init__(self, *args):
5858 __init__(Ellipsoid3D self) -> Ellipsoid3D
5859 __init__(Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
5860 __init__(Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
5862 _IMP_algebra.Ellipsoid3D_swiginit(self, _IMP_algebra.new_Ellipsoid3D(*args))
5864 def get_radii(self):
5865 r"""get_radii(Ellipsoid3D self) -> Vector3D"""
5866 return _IMP_algebra.Ellipsoid3D_get_radii(self)
5868 def get_reference_frame(self):
5869 r"""get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
5870 return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)
5872 def show(self, *args):
5873 r"""show(Ellipsoid3D self, _ostream out=std::cout)"""
5874 return _IMP_algebra.Ellipsoid3D_show(self, *args)
5877 r"""__str__(Ellipsoid3D self) -> std::string"""
5878 return _IMP_algebra.Ellipsoid3D___str__(self)
5881 r"""__repr__(Ellipsoid3D self) -> std::string"""
5882 return _IMP_algebra.Ellipsoid3D___repr__(self)
5884 def _get_as_binary(self):
5885 r"""_get_as_binary(Ellipsoid3D self) -> PyObject *"""
5886 return _IMP_algebra.Ellipsoid3D__get_as_binary(self)
5888 def _set_from_binary(self, p):
5889 r"""_set_from_binary(Ellipsoid3D self, PyObject * p)"""
5890 return _IMP_algebra.Ellipsoid3D__set_from_binary(self, p)
5892 def __getstate__(self):
5893 p = self._get_as_binary()
5894 if len(self.__dict__) > 1:
5895 d = self.__dict__.copy()
5900 def __setstate__(self, p):
5901 if not hasattr(self,
'this'):
5903 if isinstance(p, tuple):
5905 self.__dict__.update(d)
5906 return self._set_from_binary(p)
5908 __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
5911 _IMP_algebra.Ellipsoid3D_swigregister(Ellipsoid3D)
5913 def get_ellipsoid_3d_geometry(g):
5914 r"""get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
5915 return _IMP_algebra.get_ellipsoid_3d_geometry(g)
5916 class ConnollySurfacePoint(object):
5917 r"""Proxy of C++ IMP::algebra::ConnollySurfacePoint class."""
5919 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5921 def __init__(self, *args):
5923 __init__(ConnollySurfacePoint self) -> ConnollySurfacePoint
5924 __init__(ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
5926 _IMP_algebra.ConnollySurfacePoint_swiginit(self, _IMP_algebra.new_ConnollySurfacePoint(*args))
5929 r"""get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
5930 return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)
5932 def get_surface_point(self):
5933 r"""get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
5934 return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)
5937 r"""get_area(ConnollySurfacePoint self) -> double"""
5938 return _IMP_algebra.ConnollySurfacePoint_get_area(self)
5940 def get_normal(self):
5941 r"""get_normal(ConnollySurfacePoint self) -> Vector3D"""
5942 return _IMP_algebra.ConnollySurfacePoint_get_normal(self)
5944 def show(self, *args):
5945 r"""show(ConnollySurfacePoint self, _ostream out=std::cout)"""
5946 return _IMP_algebra.ConnollySurfacePoint_show(self, *args)
5949 r"""__str__(ConnollySurfacePoint self) -> std::string"""
5950 return _IMP_algebra.ConnollySurfacePoint___str__(self)
5953 r"""__repr__(ConnollySurfacePoint self) -> std::string"""
5954 return _IMP_algebra.ConnollySurfacePoint___repr__(self)
5956 def _get_as_binary(self):
5957 r"""_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
5958 return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)
5960 def _set_from_binary(self, p):
5961 r"""_set_from_binary(ConnollySurfacePoint self, PyObject * p)"""
5962 return _IMP_algebra.ConnollySurfacePoint__set_from_binary(self, p)
5964 def __getstate__(self):
5965 p = self._get_as_binary()
5966 if len(self.__dict__) > 1:
5967 d = self.__dict__.copy()
5972 def __setstate__(self, p):
5973 if not hasattr(self,
'this'):
5975 if isinstance(p, tuple):
5977 self.__dict__.update(d)
5978 return self._set_from_binary(p)
5980 __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
5983 _IMP_algebra.ConnollySurfacePoint_swigregister(ConnollySurfacePoint)
5986 r"""get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
5987 return _IMP_algebra.get_connolly_surface(spheres, density, probe_radius)
5988 class LogEmbedding3D(object):
5989 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 3 > class."""
5991 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5993 def __init__(self, *args):
5995 __init__(LogEmbedding3D self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
5996 __init__(LogEmbedding3D self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
5997 __init__(LogEmbedding3D self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
5998 __init__(LogEmbedding3D self) -> LogEmbedding3D
6000 _IMP_algebra.LogEmbedding3D_swiginit(self, _IMP_algebra.new_LogEmbedding3D(*args))
6002 def set_origin(self, o):
6003 r"""set_origin(LogEmbedding3D self, Vector3D o)"""
6004 return _IMP_algebra.LogEmbedding3D_set_origin(self, o)
6006 def get_origin(self):
6007 r"""get_origin(LogEmbedding3D self) -> Vector3D"""
6008 return _IMP_algebra.LogEmbedding3D_get_origin(self)
6010 def get_dimension(self):
6011 r"""get_dimension(LogEmbedding3D self) -> unsigned int"""
6012 return _IMP_algebra.LogEmbedding3D_get_dimension(self)
6014 def set_unit_cell(self, *args):
6016 set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
6017 set_unit_cell(LogEmbedding3D self, Vector3D o)
6019 return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)
6021 def get_unit_cell(self):
6022 r"""get_unit_cell(LogEmbedding3D self) -> Vector3D"""
6023 return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)
6025 def get_extended_index(self, o):
6026 r"""get_extended_index(LogEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
6027 return _IMP_algebra.LogEmbedding3D_get_extended_index(self, o)
6030 r"""get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
6031 return _IMP_algebra.LogEmbedding3D_get_index(self, o)
6033 def get_center(self, *args):
6035 get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
6036 get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
6038 return _IMP_algebra.LogEmbedding3D_get_center(self, *args)
6040 def get_bounding_box(self, *args):
6042 get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
6043 get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
6045 return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)
6047 def show(self, *args):
6048 r"""show(LogEmbedding3D self, _ostream out=std::cout)"""
6049 return _IMP_algebra.LogEmbedding3D_show(self, *args)
6052 r"""__str__(LogEmbedding3D self) -> std::string"""
6053 return _IMP_algebra.LogEmbedding3D___str__(self)
6056 r"""__repr__(LogEmbedding3D self) -> std::string"""
6057 return _IMP_algebra.LogEmbedding3D___repr__(self)
6059 def __cmp__(self, arg2):
6060 r"""__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
6061 return _IMP_algebra.LogEmbedding3D___cmp__(self, arg2)
6063 def __eq__(self, arg2):
6064 r"""__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
6065 return _IMP_algebra.LogEmbedding3D___eq__(self, arg2)
6067 def _get_as_binary(self):
6068 r"""_get_as_binary(LogEmbedding3D self) -> PyObject *"""
6069 return _IMP_algebra.LogEmbedding3D__get_as_binary(self)
6071 def _set_from_binary(self, p):
6072 r"""_set_from_binary(LogEmbedding3D self, PyObject * p)"""
6073 return _IMP_algebra.LogEmbedding3D__set_from_binary(self, p)
6075 def __getstate__(self):
6076 p = self._get_as_binary()
6077 if len(self.__dict__) > 1:
6078 d = self.__dict__.copy()
6083 def __setstate__(self, p):
6084 if not hasattr(self,
'this'):
6086 if isinstance(p, tuple):
6088 self.__dict__.update(d)
6089 return self._set_from_binary(p)
6091 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
6094 _IMP_algebra.LogEmbedding3D_swigregister(LogEmbedding3D)
6095 class LogEmbeddingKD(object):
6096 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< -1 > class."""
6098 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6100 def __init__(self, *args):
6102 __init__(LogEmbeddingKD self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
6103 __init__(LogEmbeddingKD self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
6104 __init__(LogEmbeddingKD self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
6105 __init__(LogEmbeddingKD self) -> LogEmbeddingKD
6107 _IMP_algebra.LogEmbeddingKD_swiginit(self, _IMP_algebra.new_LogEmbeddingKD(*args))
6109 def set_origin(self, o):
6110 r"""set_origin(LogEmbeddingKD self, VectorKD o)"""
6111 return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)
6113 def get_origin(self):
6114 r"""get_origin(LogEmbeddingKD self) -> VectorKD"""
6115 return _IMP_algebra.LogEmbeddingKD_get_origin(self)
6117 def get_dimension(self):
6118 r"""get_dimension(LogEmbeddingKD self) -> unsigned int"""
6119 return _IMP_algebra.LogEmbeddingKD_get_dimension(self)
6121 def set_unit_cell(self, *args):
6123 set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
6124 set_unit_cell(LogEmbeddingKD self, VectorKD o)
6126 return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)
6128 def get_unit_cell(self):
6129 r"""get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
6130 return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)
6132 def get_extended_index(self, o):
6133 r"""get_extended_index(LogEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
6134 return _IMP_algebra.LogEmbeddingKD_get_extended_index(self, o)
6137 r"""get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
6138 return _IMP_algebra.LogEmbeddingKD_get_index(self, o)
6140 def get_center(self, *args):
6142 get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
6143 get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
6145 return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)
6147 def get_bounding_box(self, *args):
6149 get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
6150 get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
6152 return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)
6154 def show(self, *args):
6155 r"""show(LogEmbeddingKD self, _ostream out=std::cout)"""
6156 return _IMP_algebra.LogEmbeddingKD_show(self, *args)
6159 r"""__str__(LogEmbeddingKD self) -> std::string"""
6160 return _IMP_algebra.LogEmbeddingKD___str__(self)
6163 r"""__repr__(LogEmbeddingKD self) -> std::string"""
6164 return _IMP_algebra.LogEmbeddingKD___repr__(self)
6166 def __cmp__(self, arg2):
6167 r"""__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
6168 return _IMP_algebra.LogEmbeddingKD___cmp__(self, arg2)
6170 def __eq__(self, arg2):
6171 r"""__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
6172 return _IMP_algebra.LogEmbeddingKD___eq__(self, arg2)
6174 def _get_as_binary(self):
6175 r"""_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
6176 return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)
6178 def _set_from_binary(self, p):
6179 r"""_set_from_binary(LogEmbeddingKD self, PyObject * p)"""
6180 return _IMP_algebra.LogEmbeddingKD__set_from_binary(self, p)
6182 def __getstate__(self):
6183 p = self._get_as_binary()
6184 if len(self.__dict__) > 1:
6185 d = self.__dict__.copy()
6190 def __setstate__(self, p):
6191 if not hasattr(self,
'this'):
6193 if isinstance(p, tuple):
6195 self.__dict__.update(d)
6196 return self._set_from_binary(p)
6198 __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
6201 _IMP_algebra.LogEmbeddingKD_swigregister(LogEmbeddingKD)
6202 class DenseFloatLogGridKD(object):
6203 r"""Proxy of C++ IMP::algebra::DenseFloatLogGridKD class."""
6205 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6207 def __init__(self, sz, le):
6208 r"""__init__(DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
6209 _IMP_algebra.DenseFloatLogGridKD_swiginit(self, _IMP_algebra.new_DenseFloatLogGridKD(sz, le))
6211 def add_voxel(self, i, q):
6212 r"""add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
6213 return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, i, q)
6215 def __getitem__(self, *args):
6217 __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
6218 __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
6220 return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)
6222 def __setitem__(self, *args):
6224 __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
6225 __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
6227 return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)
6229 def get_bounding_box(self, *args):
6231 get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6232 get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
6234 return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)
6238 get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6239 get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6241 return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)
6243 def get_all_indexes(self):
6244 r"""get_all_indexes(DenseFloatLogGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >"""
6245 return _IMP_algebra.DenseFloatLogGridKD_get_all_indexes(self)
6247 def get_extended_indexes(self, *args):
6249 get_extended_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6250 get_extended_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6252 return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)
6254 def get_center(self, *args):
6256 get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6257 get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
6259 return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)
6261 def get_extended_index(self, v):
6262 r"""get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6263 return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, v)
6266 r"""get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6267 return _IMP_algebra.DenseFloatLogGridKD_get_index(self, v)
6269 def get_origin(self):
6270 r"""get_origin(DenseFloatLogGridKD self) -> VectorKD"""
6271 return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)
6273 def get_dimension(self):
6274 r"""get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
6275 return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)
6277 def get_unit_cell(self):
6278 r"""get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
6279 return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)
6281 def get_has_index(self, v):
6282 r"""get_has_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> bool"""
6283 return _IMP_algebra.DenseFloatLogGridKD_get_has_index(self, v)
6286 r"""__str__(DenseFloatLogGridKD self) -> std::string"""
6287 return _IMP_algebra.DenseFloatLogGridKD___str__(self)
6290 r"""__repr__(DenseFloatLogGridKD self) -> std::string"""
6291 return _IMP_algebra.DenseFloatLogGridKD___repr__(self)
6293 def show(self, *args):
6294 r"""show(DenseFloatLogGridKD self, _ostream out=std::cout)"""
6295 return _IMP_algebra.DenseFloatLogGridKD_show(self, *args)
6296 __swig_destroy__ = _IMP_algebra.delete_DenseFloatLogGridKD
6299 _IMP_algebra.DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
6300 class DenseIntLogGrid3D(object):
6301 r"""Proxy of C++ IMP::algebra::DenseIntLogGrid3D class."""
6303 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6305 def __init__(self, sz, le):
6306 r"""__init__(DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
6307 _IMP_algebra.DenseIntLogGrid3D_swiginit(self, _IMP_algebra.new_DenseIntLogGrid3D(sz, le))
6309 def add_voxel(self, i, q):
6310 r"""add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6311 return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, i, q)
6313 def __getitem__(self, *args):
6315 __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
6316 __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
6318 return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)
6320 def __setitem__(self, *args):
6322 __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
6323 __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
6325 return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)
6327 def get_bounding_box(self, *args):
6329 get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6330 get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
6332 return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)
6336 get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6337 get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6339 return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)
6341 def get_all_indexes(self):
6342 r"""get_all_indexes(DenseIntLogGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6343 return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)
6345 def get_extended_indexes(self, *args):
6347 get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6348 get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6350 return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)
6352 def get_center(self, *args):
6354 get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6355 get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
6357 return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)
6359 def get_extended_index(self, v):
6360 r"""get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6361 return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, v)
6364 r"""get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6365 return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)
6367 def get_origin(self):
6368 r"""get_origin(DenseIntLogGrid3D self) -> Vector3D"""
6369 return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)
6371 def get_dimension(self):
6372 r"""get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
6373 return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)
6375 def get_unit_cell(self):
6376 r"""get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
6377 return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)
6379 def get_has_index(self, v):
6380 r"""get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
6381 return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, v)
6384 r"""__str__(DenseIntLogGrid3D self) -> std::string"""
6385 return _IMP_algebra.DenseIntLogGrid3D___str__(self)
6388 r"""__repr__(DenseIntLogGrid3D self) -> std::string"""
6389 return _IMP_algebra.DenseIntLogGrid3D___repr__(self)
6391 def show(self, *args):
6392 r"""show(DenseIntLogGrid3D self, _ostream out=std::cout)"""
6393 return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)
6394 __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D
6397 _IMP_algebra.DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
6399 r"""Proxy of C++ IMP::algebra::DenseGrid3D< double > class."""
6401 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6403 def __init__(self, *args):
6405 __init__(DenseDoubleGrid3D self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
6406 __init__(DenseDoubleGrid3D self) -> DenseDoubleGrid3D
6408 _IMP_algebra.DenseDoubleGrid3D_swiginit(self, _IMP_algebra.new_DenseDoubleGrid3D(*args))
6410 def add_voxel(self, i, q):
6411 r"""add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
6412 return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, i, q)
6414 def __getitem__(self, *args):
6416 __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
6417 __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
6419 return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)
6421 def __setitem__(self, *args):
6423 __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
6424 __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
6426 return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)
6428 def get_bounding_box(self, *args):
6430 get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6431 get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
6433 return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)
6437 get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6438 get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6440 return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)
6442 def get_all_indexes(self):
6443 r"""get_all_indexes(DenseDoubleGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6444 return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)
6446 def get_extended_indexes(self, *args):
6448 get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6449 get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6451 return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)
6453 def get_center(self, *args):
6455 get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6456 get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
6458 return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)
6460 def get_extended_index(self, v):
6461 r"""get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6462 return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, v)
6465 r"""get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6466 return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)
6468 def get_origin(self):
6469 r"""get_origin(DenseDoubleGrid3D self) -> Vector3D"""
6470 return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)
6472 def get_dimension(self):
6473 r"""get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
6474 return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)
6476 def get_unit_cell(self):
6477 r"""get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
6478 return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)
6480 def get_has_index(self, v):
6481 r"""get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
6482 return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, v)
6485 r"""__str__(DenseDoubleGrid3D self) -> std::string"""
6486 return _IMP_algebra.DenseDoubleGrid3D___str__(self)
6489 r"""__repr__(DenseDoubleGrid3D self) -> std::string"""
6490 return _IMP_algebra.DenseDoubleGrid3D___repr__(self)
6492 def show(self, *args):
6493 r"""show(DenseDoubleGrid3D self, _ostream out=std::cout)"""
6494 return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)
6495 __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D
6498 _IMP_algebra.DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
6500 r"""Proxy of C++ IMP::algebra::DenseGrid3D< float > class."""
6502 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6504 def __init__(self, *args):
6506 __init__(DenseFloatGrid3D self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
6507 __init__(DenseFloatGrid3D self) -> DenseFloatGrid3D
6509 _IMP_algebra.DenseFloatGrid3D_swiginit(self, _IMP_algebra.new_DenseFloatGrid3D(*args))
6511 def add_voxel(self, i, q):
6512 r"""add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
6513 return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, i, q)
6515 def __getitem__(self, *args):
6517 __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
6518 __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
6520 return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)
6522 def __setitem__(self, *args):
6524 __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
6525 __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
6527 return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)
6529 def get_bounding_box(self, *args):
6531 get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6532 get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
6534 return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)
6538 get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6539 get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6541 return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)
6543 def get_all_indexes(self):
6544 r"""get_all_indexes(DenseFloatGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6545 return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)
6547 def get_extended_indexes(self, *args):
6549 get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6550 get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6552 return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)
6554 def get_center(self, *args):
6556 get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6557 get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
6559 return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)
6561 def get_extended_index(self, v):
6562 r"""get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6563 return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, v)
6566 r"""get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6567 return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)
6569 def get_origin(self):
6570 r"""get_origin(DenseFloatGrid3D self) -> Vector3D"""
6571 return _IMP_algebra.DenseFloatGrid3D_get_origin(self)
6573 def get_dimension(self):
6574 r"""get_dimension(DenseFloatGrid3D self) -> unsigned int"""
6575 return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)
6577 def get_unit_cell(self):
6578 r"""get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
6579 return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)
6581 def get_has_index(self, v):
6582 r"""get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
6583 return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, v)
6586 r"""__str__(DenseFloatGrid3D self) -> std::string"""
6587 return _IMP_algebra.DenseFloatGrid3D___str__(self)
6590 r"""__repr__(DenseFloatGrid3D self) -> std::string"""
6591 return _IMP_algebra.DenseFloatGrid3D___repr__(self)
6593 def show(self, *args):
6594 r"""show(DenseFloatGrid3D self, _ostream out=std::cout)"""
6595 return _IMP_algebra.DenseFloatGrid3D_show(self, *args)
6596 __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D
6599 _IMP_algebra.DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
6601 r"""Proxy of C++ IMP::algebra::SparseUnboundedGrid3D< int > class."""
6603 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6605 def __init__(self, *args):
6607 __init__(SparseUnboundedIntGrid3D self, double side, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6608 __init__(SparseUnboundedIntGrid3D self, Vector3D sides, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6609 __init__(SparseUnboundedIntGrid3D self) -> SparseUnboundedIntGrid3D
6611 _IMP_algebra.SparseUnboundedIntGrid3D_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGrid3D(*args))
6613 def add_voxel(self, i, q):
6614 r"""add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6615 return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, i, q)
6617 def __getitem__(self, *args):
6619 __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
6620 __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
6622 return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)
6624 def __setitem__(self, *args):
6626 __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
6627 __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
6629 return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)
6631 def get_bounding_box(self, *args):
6633 get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6634 get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
6636 return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)
6640 get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6641 get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6643 return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)
6645 def get_all_indexes(self):
6646 r"""get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6647 return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)
6649 def get_extended_indexes(self, *args):
6651 get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6652 get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6654 return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)
6656 def get_center(self, *args):
6658 get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6659 get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
6661 return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)
6663 def get_extended_index(self, v):
6664 r"""get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6665 return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, v)
6668 r"""get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6669 return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)
6671 def get_origin(self):
6672 r"""get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
6673 return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)
6675 def get_dimension(self):
6676 r"""get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
6677 return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)
6679 def get_unit_cell(self):
6680 r"""get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
6681 return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)
6683 def get_has_index(self, v):
6684 r"""get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
6685 return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, v)
6688 r"""__str__(SparseUnboundedIntGrid3D self) -> std::string"""
6689 return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)
6692 r"""__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
6693 return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)
6695 def show(self, *args):
6696 r"""show(SparseUnboundedIntGrid3D self, _ostream out=std::cout)"""
6697 return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)
6698 __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D
6701 _IMP_algebra.SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
6702 class SparseUnboundedIntGridKD(object):
6703 r"""Proxy of C++ IMP::algebra::SparseUnboundedGridD< -1,int > class."""
6705 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6707 def __init__(self, *args):
6709 __init__(SparseUnboundedIntGridKD self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
6710 __init__(SparseUnboundedIntGridKD self) -> SparseUnboundedIntGridKD
6712 _IMP_algebra.SparseUnboundedIntGridKD_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGridKD(*args))
6714 def add_voxel(self, i, q):
6715 r"""add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
6716 return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, i, q)
6718 def __getitem__(self, *args):
6720 __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
6721 __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
6723 return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)
6725 def __setitem__(self, *args):
6727 __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
6728 __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
6730 return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)
6732 def get_bounding_box(self, *args):
6734 get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6735 get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
6737 return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)
6741 get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6742 get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6744 return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)
6746 def get_all_indexes(self):
6747 r"""get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >"""
6748 return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)
6750 def get_extended_indexes(self, *args):
6752 get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6753 get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6755 return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)
6757 def get_center(self, *args):
6759 get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6760 get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
6762 return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)
6764 def get_extended_index(self, v):
6765 r"""get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6766 return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, v)
6769 r"""get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6770 return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)
6772 def get_origin(self):
6773 r"""get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
6774 return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)
6776 def get_dimension(self):
6777 r"""get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
6778 return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)
6780 def get_unit_cell(self):
6781 r"""get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
6782 return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)
6784 def get_has_index(self, v):
6785 r"""get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
6786 return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, v)
6789 r"""__str__(SparseUnboundedIntGridKD self) -> std::string"""
6790 return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)
6793 r"""__repr__(SparseUnboundedIntGridKD self) -> std::string"""
6794 return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)
6796 def show(self, *args):
6797 r"""show(SparseUnboundedIntGridKD self, _ostream out=std::cout)"""
6798 return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)
6799 __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD
6802 _IMP_algebra.SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
6803 class GridIndex1D(IMP._Value):
6804 r"""Proxy of C++ IMP::algebra::GridIndexD< 1 > class."""
6806 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6808 def __init__(self, *args):
6810 __init__(GridIndex1D self) -> GridIndex1D
6811 __init__(GridIndex1D self, int x) -> GridIndex1D
6812 __init__(GridIndex1D self, int x, int y) -> GridIndex1D
6813 __init__(GridIndex1D self, int x, int y, int z) -> GridIndex1D
6814 __init__(GridIndex1D self, int i, int j, int k, int l) -> GridIndex1D
6815 __init__(GridIndex1D self, int i, int j, int k, int l, int m) -> GridIndex1D
6816 __init__(GridIndex1D self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
6818 _IMP_algebra.GridIndex1D_swiginit(self, _IMP_algebra.new_GridIndex1D(*args))
6820 def get_dimension(self):
6821 r"""get_dimension(GridIndex1D self) -> unsigned int"""
6822 return _IMP_algebra.GridIndex1D_get_dimension(self)
6824 def __getitem__(self, i):
6825 r"""__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
6826 return _IMP_algebra.GridIndex1D___getitem__(self, i)
6828 def show(self, *args):
6829 r"""show(GridIndex1D self, _ostream out=std::cout)"""
6830 return _IMP_algebra.GridIndex1D_show(self, *args)
6833 r"""__len__(GridIndex1D self) -> unsigned int"""
6834 return _IMP_algebra.GridIndex1D___len__(self)
6836 def __cmp__(self, o):
6837 r"""__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
6838 return _IMP_algebra.GridIndex1D___cmp__(self, o)
6840 def __eq__(self, o):
6841 r"""__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
6842 return _IMP_algebra.GridIndex1D___eq__(self, o)
6844 def __ne__(self, o):
6845 r"""__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
6846 return _IMP_algebra.GridIndex1D___ne__(self, o)
6848 def __lt__(self, o):
6849 r"""__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
6850 return _IMP_algebra.GridIndex1D___lt__(self, o)
6852 def __gt__(self, o):
6853 r"""__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
6854 return _IMP_algebra.GridIndex1D___gt__(self, o)
6856 def __ge__(self, o):
6857 r"""__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
6858 return _IMP_algebra.GridIndex1D___ge__(self, o)
6860 def __le__(self, o):
6861 r"""__le__(GridIndex1D self, GridIndex1D o) -> bool"""
6862 return _IMP_algebra.GridIndex1D___le__(self, o)
6865 r"""__hash__(GridIndex1D self) -> std::size_t"""
6866 return _IMP_algebra.GridIndex1D___hash__(self)
6869 r"""__str__(GridIndex1D self) -> std::string"""
6870 return _IMP_algebra.GridIndex1D___str__(self)
6873 r"""__repr__(GridIndex1D self) -> std::string"""
6874 return _IMP_algebra.GridIndex1D___repr__(self)
6876 def _get_as_binary(self):
6877 r"""_get_as_binary(GridIndex1D self) -> PyObject *"""
6878 return _IMP_algebra.GridIndex1D__get_as_binary(self)
6880 def _set_from_binary(self, p):
6881 r"""_set_from_binary(GridIndex1D self, PyObject * p)"""
6882 return _IMP_algebra.GridIndex1D__set_from_binary(self, p)
6884 def __getstate__(self):
6885 p = self._get_as_binary()
6886 if len(self.__dict__) > 1:
6887 d = self.__dict__.copy()
6892 def __setstate__(self, p):
6893 if not hasattr(self,
'this'):
6895 if isinstance(p, tuple):
6897 self.__dict__.update(d)
6898 return self._set_from_binary(p)
6900 __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
6903 _IMP_algebra.GridIndex1D_swigregister(GridIndex1D)
6904 class GridIndex2D(IMP._Value):
6905 r"""Proxy of C++ IMP::algebra::GridIndexD< 2 > class."""
6907 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6909 def __init__(self, *args):
6911 __init__(GridIndex2D self) -> GridIndex2D
6912 __init__(GridIndex2D self, int x) -> GridIndex2D
6913 __init__(GridIndex2D self, int x, int y) -> GridIndex2D
6914 __init__(GridIndex2D self, int x, int y, int z) -> GridIndex2D
6915 __init__(GridIndex2D self, int i, int j, int k, int l) -> GridIndex2D
6916 __init__(GridIndex2D self, int i, int j, int k, int l, int m) -> GridIndex2D
6917 __init__(GridIndex2D self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
6919 _IMP_algebra.GridIndex2D_swiginit(self, _IMP_algebra.new_GridIndex2D(*args))
6921 def get_dimension(self):
6922 r"""get_dimension(GridIndex2D self) -> unsigned int"""
6923 return _IMP_algebra.GridIndex2D_get_dimension(self)
6925 def __getitem__(self, i):
6926 r"""__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
6927 return _IMP_algebra.GridIndex2D___getitem__(self, i)
6929 def show(self, *args):
6930 r"""show(GridIndex2D self, _ostream out=std::cout)"""
6931 return _IMP_algebra.GridIndex2D_show(self, *args)
6934 r"""__len__(GridIndex2D self) -> unsigned int"""
6935 return _IMP_algebra.GridIndex2D___len__(self)
6937 def __cmp__(self, o):
6938 r"""__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
6939 return _IMP_algebra.GridIndex2D___cmp__(self, o)
6941 def __eq__(self, o):
6942 r"""__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
6943 return _IMP_algebra.GridIndex2D___eq__(self, o)
6945 def __ne__(self, o):
6946 r"""__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
6947 return _IMP_algebra.GridIndex2D___ne__(self, o)
6949 def __lt__(self, o):
6950 r"""__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
6951 return _IMP_algebra.GridIndex2D___lt__(self, o)
6953 def __gt__(self, o):
6954 r"""__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
6955 return _IMP_algebra.GridIndex2D___gt__(self, o)
6957 def __ge__(self, o):
6958 r"""__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
6959 return _IMP_algebra.GridIndex2D___ge__(self, o)
6961 def __le__(self, o):
6962 r"""__le__(GridIndex2D self, GridIndex2D o) -> bool"""
6963 return _IMP_algebra.GridIndex2D___le__(self, o)
6966 r"""__hash__(GridIndex2D self) -> std::size_t"""
6967 return _IMP_algebra.GridIndex2D___hash__(self)
6970 r"""__str__(GridIndex2D self) -> std::string"""
6971 return _IMP_algebra.GridIndex2D___str__(self)
6974 r"""__repr__(GridIndex2D self) -> std::string"""
6975 return _IMP_algebra.GridIndex2D___repr__(self)
6977 def _get_as_binary(self):
6978 r"""_get_as_binary(GridIndex2D self) -> PyObject *"""
6979 return _IMP_algebra.GridIndex2D__get_as_binary(self)
6981 def _set_from_binary(self, p):
6982 r"""_set_from_binary(GridIndex2D self, PyObject * p)"""
6983 return _IMP_algebra.GridIndex2D__set_from_binary(self, p)
6985 def __getstate__(self):
6986 p = self._get_as_binary()
6987 if len(self.__dict__) > 1:
6988 d = self.__dict__.copy()
6993 def __setstate__(self, p):
6994 if not hasattr(self,
'this'):
6996 if isinstance(p, tuple):
6998 self.__dict__.update(d)
6999 return self._set_from_binary(p)
7001 __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
7004 _IMP_algebra.GridIndex2D_swigregister(GridIndex2D)
7005 class GridIndex3D(IMP._Value):
7006 r"""Proxy of C++ IMP::algebra::GridIndexD< 3 > class."""
7008 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7010 def __init__(self, *args):
7012 __init__(GridIndex3D self) -> GridIndex3D
7013 __init__(GridIndex3D self, int x) -> GridIndex3D
7014 __init__(GridIndex3D self, int x, int y) -> GridIndex3D
7015 __init__(GridIndex3D self, int x, int y, int z) -> GridIndex3D
7016 __init__(GridIndex3D self, int i, int j, int k, int l) -> GridIndex3D
7017 __init__(GridIndex3D self, int i, int j, int k, int l, int m) -> GridIndex3D
7018 __init__(GridIndex3D self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
7020 _IMP_algebra.GridIndex3D_swiginit(self, _IMP_algebra.new_GridIndex3D(*args))
7022 def get_dimension(self):
7023 r"""get_dimension(GridIndex3D self) -> unsigned int"""
7024 return _IMP_algebra.GridIndex3D_get_dimension(self)
7026 def __getitem__(self, i):
7027 r"""__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
7028 return _IMP_algebra.GridIndex3D___getitem__(self, i)
7030 def show(self, *args):
7031 r"""show(GridIndex3D self, _ostream out=std::cout)"""
7032 return _IMP_algebra.GridIndex3D_show(self, *args)
7035 r"""__len__(GridIndex3D self) -> unsigned int"""
7036 return _IMP_algebra.GridIndex3D___len__(self)
7038 def __cmp__(self, o):
7039 r"""__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
7040 return _IMP_algebra.GridIndex3D___cmp__(self, o)
7042 def __eq__(self, o):
7043 r"""__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
7044 return _IMP_algebra.GridIndex3D___eq__(self, o)
7046 def __ne__(self, o):
7047 r"""__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
7048 return _IMP_algebra.GridIndex3D___ne__(self, o)
7050 def __lt__(self, o):
7051 r"""__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
7052 return _IMP_algebra.GridIndex3D___lt__(self, o)
7054 def __gt__(self, o):
7055 r"""__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
7056 return _IMP_algebra.GridIndex3D___gt__(self, o)
7058 def __ge__(self, o):
7059 r"""__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
7060 return _IMP_algebra.GridIndex3D___ge__(self, o)
7062 def __le__(self, o):
7063 r"""__le__(GridIndex3D self, GridIndex3D o) -> bool"""
7064 return _IMP_algebra.GridIndex3D___le__(self, o)
7067 r"""__hash__(GridIndex3D self) -> std::size_t"""
7068 return _IMP_algebra.GridIndex3D___hash__(self)
7071 r"""__str__(GridIndex3D self) -> std::string"""
7072 return _IMP_algebra.GridIndex3D___str__(self)
7075 r"""__repr__(GridIndex3D self) -> std::string"""
7076 return _IMP_algebra.GridIndex3D___repr__(self)
7078 def _get_as_binary(self):
7079 r"""_get_as_binary(GridIndex3D self) -> PyObject *"""
7080 return _IMP_algebra.GridIndex3D__get_as_binary(self)
7082 def _set_from_binary(self, p):
7083 r"""_set_from_binary(GridIndex3D self, PyObject * p)"""
7084 return _IMP_algebra.GridIndex3D__set_from_binary(self, p)
7086 def __getstate__(self):
7087 p = self._get_as_binary()
7088 if len(self.__dict__) > 1:
7089 d = self.__dict__.copy()
7094 def __setstate__(self, p):
7095 if not hasattr(self,
'this'):
7097 if isinstance(p, tuple):
7099 self.__dict__.update(d)
7100 return self._set_from_binary(p)
7102 __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
7105 _IMP_algebra.GridIndex3D_swigregister(GridIndex3D)
7106 class GridIndex4D(IMP._Value):
7107 r"""Proxy of C++ IMP::algebra::GridIndexD< 4 > class."""
7109 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7111 def __init__(self, *args):
7113 __init__(GridIndex4D self) -> GridIndex4D
7114 __init__(GridIndex4D self, int x) -> GridIndex4D
7115 __init__(GridIndex4D self, int x, int y) -> GridIndex4D
7116 __init__(GridIndex4D self, int x, int y, int z) -> GridIndex4D
7117 __init__(GridIndex4D self, int i, int j, int k, int l) -> GridIndex4D
7118 __init__(GridIndex4D self, int i, int j, int k, int l, int m) -> GridIndex4D
7119 __init__(GridIndex4D self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
7121 _IMP_algebra.GridIndex4D_swiginit(self, _IMP_algebra.new_GridIndex4D(*args))
7123 def get_dimension(self):
7124 r"""get_dimension(GridIndex4D self) -> unsigned int"""
7125 return _IMP_algebra.GridIndex4D_get_dimension(self)
7127 def __getitem__(self, i):
7128 r"""__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
7129 return _IMP_algebra.GridIndex4D___getitem__(self, i)
7131 def show(self, *args):
7132 r"""show(GridIndex4D self, _ostream out=std::cout)"""
7133 return _IMP_algebra.GridIndex4D_show(self, *args)
7136 r"""__len__(GridIndex4D self) -> unsigned int"""
7137 return _IMP_algebra.GridIndex4D___len__(self)
7139 def __cmp__(self, o):
7140 r"""__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
7141 return _IMP_algebra.GridIndex4D___cmp__(self, o)
7143 def __eq__(self, o):
7144 r"""__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
7145 return _IMP_algebra.GridIndex4D___eq__(self, o)
7147 def __ne__(self, o):
7148 r"""__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
7149 return _IMP_algebra.GridIndex4D___ne__(self, o)
7151 def __lt__(self, o):
7152 r"""__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
7153 return _IMP_algebra.GridIndex4D___lt__(self, o)
7155 def __gt__(self, o):
7156 r"""__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
7157 return _IMP_algebra.GridIndex4D___gt__(self, o)
7159 def __ge__(self, o):
7160 r"""__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
7161 return _IMP_algebra.GridIndex4D___ge__(self, o)
7163 def __le__(self, o):
7164 r"""__le__(GridIndex4D self, GridIndex4D o) -> bool"""
7165 return _IMP_algebra.GridIndex4D___le__(self, o)
7168 r"""__hash__(GridIndex4D self) -> std::size_t"""
7169 return _IMP_algebra.GridIndex4D___hash__(self)
7172 r"""__str__(GridIndex4D self) -> std::string"""
7173 return _IMP_algebra.GridIndex4D___str__(self)
7176 r"""__repr__(GridIndex4D self) -> std::string"""
7177 return _IMP_algebra.GridIndex4D___repr__(self)
7179 def _get_as_binary(self):
7180 r"""_get_as_binary(GridIndex4D self) -> PyObject *"""
7181 return _IMP_algebra.GridIndex4D__get_as_binary(self)
7183 def _set_from_binary(self, p):
7184 r"""_set_from_binary(GridIndex4D self, PyObject * p)"""
7185 return _IMP_algebra.GridIndex4D__set_from_binary(self, p)
7187 def __getstate__(self):
7188 p = self._get_as_binary()
7189 if len(self.__dict__) > 1:
7190 d = self.__dict__.copy()
7195 def __setstate__(self, p):
7196 if not hasattr(self,
'this'):
7198 if isinstance(p, tuple):
7200 self.__dict__.update(d)
7201 return self._set_from_binary(p)
7203 __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
7206 _IMP_algebra.GridIndex4D_swigregister(GridIndex4D)
7207 class GridIndex5D(IMP._Value):
7208 r"""Proxy of C++ IMP::algebra::GridIndexD< 5 > class."""
7210 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7212 def __init__(self, *args):
7214 __init__(GridIndex5D self) -> GridIndex5D
7215 __init__(GridIndex5D self, int x) -> GridIndex5D
7216 __init__(GridIndex5D self, int x, int y) -> GridIndex5D
7217 __init__(GridIndex5D self, int x, int y, int z) -> GridIndex5D
7218 __init__(GridIndex5D self, int i, int j, int k, int l) -> GridIndex5D
7219 __init__(GridIndex5D self, int i, int j, int k, int l, int m) -> GridIndex5D
7220 __init__(GridIndex5D self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
7222 _IMP_algebra.GridIndex5D_swiginit(self, _IMP_algebra.new_GridIndex5D(*args))
7224 def get_dimension(self):
7225 r"""get_dimension(GridIndex5D self) -> unsigned int"""
7226 return _IMP_algebra.GridIndex5D_get_dimension(self)
7228 def __getitem__(self, i):
7229 r"""__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
7230 return _IMP_algebra.GridIndex5D___getitem__(self, i)
7232 def show(self, *args):
7233 r"""show(GridIndex5D self, _ostream out=std::cout)"""
7234 return _IMP_algebra.GridIndex5D_show(self, *args)
7237 r"""__len__(GridIndex5D self) -> unsigned int"""
7238 return _IMP_algebra.GridIndex5D___len__(self)
7240 def __cmp__(self, o):
7241 r"""__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
7242 return _IMP_algebra.GridIndex5D___cmp__(self, o)
7244 def __eq__(self, o):
7245 r"""__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
7246 return _IMP_algebra.GridIndex5D___eq__(self, o)
7248 def __ne__(self, o):
7249 r"""__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
7250 return _IMP_algebra.GridIndex5D___ne__(self, o)
7252 def __lt__(self, o):
7253 r"""__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
7254 return _IMP_algebra.GridIndex5D___lt__(self, o)
7256 def __gt__(self, o):
7257 r"""__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
7258 return _IMP_algebra.GridIndex5D___gt__(self, o)
7260 def __ge__(self, o):
7261 r"""__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
7262 return _IMP_algebra.GridIndex5D___ge__(self, o)
7264 def __le__(self, o):
7265 r"""__le__(GridIndex5D self, GridIndex5D o) -> bool"""
7266 return _IMP_algebra.GridIndex5D___le__(self, o)
7269 r"""__hash__(GridIndex5D self) -> std::size_t"""
7270 return _IMP_algebra.GridIndex5D___hash__(self)
7273 r"""__str__(GridIndex5D self) -> std::string"""
7274 return _IMP_algebra.GridIndex5D___str__(self)
7277 r"""__repr__(GridIndex5D self) -> std::string"""
7278 return _IMP_algebra.GridIndex5D___repr__(self)
7280 def _get_as_binary(self):
7281 r"""_get_as_binary(GridIndex5D self) -> PyObject *"""
7282 return _IMP_algebra.GridIndex5D__get_as_binary(self)
7284 def _set_from_binary(self, p):
7285 r"""_set_from_binary(GridIndex5D self, PyObject * p)"""
7286 return _IMP_algebra.GridIndex5D__set_from_binary(self, p)
7288 def __getstate__(self):
7289 p = self._get_as_binary()
7290 if len(self.__dict__) > 1:
7291 d = self.__dict__.copy()
7296 def __setstate__(self, p):
7297 if not hasattr(self,
'this'):
7299 if isinstance(p, tuple):
7301 self.__dict__.update(d)
7302 return self._set_from_binary(p)
7304 __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
7307 _IMP_algebra.GridIndex5D_swigregister(GridIndex5D)
7308 class GridIndex6D(IMP._Value):
7309 r"""Proxy of C++ IMP::algebra::GridIndexD< 6 > class."""
7311 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7313 def __init__(self, *args):
7315 __init__(GridIndex6D self) -> GridIndex6D
7316 __init__(GridIndex6D self, int x) -> GridIndex6D
7317 __init__(GridIndex6D self, int x, int y) -> GridIndex6D
7318 __init__(GridIndex6D self, int x, int y, int z) -> GridIndex6D
7319 __init__(GridIndex6D self, int i, int j, int k, int l) -> GridIndex6D
7320 __init__(GridIndex6D self, int i, int j, int k, int l, int m) -> GridIndex6D
7321 __init__(GridIndex6D self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
7323 _IMP_algebra.GridIndex6D_swiginit(self, _IMP_algebra.new_GridIndex6D(*args))
7325 def get_dimension(self):
7326 r"""get_dimension(GridIndex6D self) -> unsigned int"""
7327 return _IMP_algebra.GridIndex6D_get_dimension(self)
7329 def __getitem__(self, i):
7330 r"""__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
7331 return _IMP_algebra.GridIndex6D___getitem__(self, i)
7333 def show(self, *args):
7334 r"""show(GridIndex6D self, _ostream out=std::cout)"""
7335 return _IMP_algebra.GridIndex6D_show(self, *args)
7338 r"""__len__(GridIndex6D self) -> unsigned int"""
7339 return _IMP_algebra.GridIndex6D___len__(self)
7341 def __cmp__(self, o):
7342 r"""__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
7343 return _IMP_algebra.GridIndex6D___cmp__(self, o)
7345 def __eq__(self, o):
7346 r"""__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
7347 return _IMP_algebra.GridIndex6D___eq__(self, o)
7349 def __ne__(self, o):
7350 r"""__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
7351 return _IMP_algebra.GridIndex6D___ne__(self, o)
7353 def __lt__(self, o):
7354 r"""__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
7355 return _IMP_algebra.GridIndex6D___lt__(self, o)
7357 def __gt__(self, o):
7358 r"""__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
7359 return _IMP_algebra.GridIndex6D___gt__(self, o)
7361 def __ge__(self, o):
7362 r"""__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
7363 return _IMP_algebra.GridIndex6D___ge__(self, o)
7365 def __le__(self, o):
7366 r"""__le__(GridIndex6D self, GridIndex6D o) -> bool"""
7367 return _IMP_algebra.GridIndex6D___le__(self, o)
7370 r"""__hash__(GridIndex6D self) -> std::size_t"""
7371 return _IMP_algebra.GridIndex6D___hash__(self)
7374 r"""__str__(GridIndex6D self) -> std::string"""
7375 return _IMP_algebra.GridIndex6D___str__(self)
7378 r"""__repr__(GridIndex6D self) -> std::string"""
7379 return _IMP_algebra.GridIndex6D___repr__(self)
7381 def _get_as_binary(self):
7382 r"""_get_as_binary(GridIndex6D self) -> PyObject *"""
7383 return _IMP_algebra.GridIndex6D__get_as_binary(self)
7385 def _set_from_binary(self, p):
7386 r"""_set_from_binary(GridIndex6D self, PyObject * p)"""
7387 return _IMP_algebra.GridIndex6D__set_from_binary(self, p)
7389 def __getstate__(self):
7390 p = self._get_as_binary()
7391 if len(self.__dict__) > 1:
7392 d = self.__dict__.copy()
7397 def __setstate__(self, p):
7398 if not hasattr(self,
'this'):
7400 if isinstance(p, tuple):
7402 self.__dict__.update(d)
7403 return self._set_from_binary(p)
7405 __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
7408 _IMP_algebra.GridIndex6D_swigregister(GridIndex6D)
7409 class GridIndexKD(IMP._Value):
7410 r"""Proxy of C++ IMP::algebra::GridIndexD< -1 > class."""
7412 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7414 def __init__(self, *args):
7416 __init__(GridIndexKD self) -> GridIndexKD
7417 __init__(GridIndexKD self, int x) -> GridIndexKD
7418 __init__(GridIndexKD self, int x, int y) -> GridIndexKD
7419 __init__(GridIndexKD self, int x, int y, int z) -> GridIndexKD
7420 __init__(GridIndexKD self, int i, int j, int k, int l) -> GridIndexKD
7421 __init__(GridIndexKD self, int i, int j, int k, int l, int m) -> GridIndexKD
7422 __init__(GridIndexKD self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
7424 _IMP_algebra.GridIndexKD_swiginit(self, _IMP_algebra.new_GridIndexKD(*args))
7426 def get_dimension(self):
7427 r"""get_dimension(GridIndexKD self) -> unsigned int"""
7428 return _IMP_algebra.GridIndexKD_get_dimension(self)
7430 def __getitem__(self, i):
7431 r"""__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
7432 return _IMP_algebra.GridIndexKD___getitem__(self, i)
7434 def show(self, *args):
7435 r"""show(GridIndexKD self, _ostream out=std::cout)"""
7436 return _IMP_algebra.GridIndexKD_show(self, *args)
7439 r"""__len__(GridIndexKD self) -> unsigned int"""
7440 return _IMP_algebra.GridIndexKD___len__(self)
7442 def __cmp__(self, o):
7443 r"""__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
7444 return _IMP_algebra.GridIndexKD___cmp__(self, o)
7446 def __eq__(self, o):
7447 r"""__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
7448 return _IMP_algebra.GridIndexKD___eq__(self, o)
7450 def __ne__(self, o):
7451 r"""__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
7452 return _IMP_algebra.GridIndexKD___ne__(self, o)
7454 def __lt__(self, o):
7455 r"""__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
7456 return _IMP_algebra.GridIndexKD___lt__(self, o)
7458 def __gt__(self, o):
7459 r"""__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
7460 return _IMP_algebra.GridIndexKD___gt__(self, o)
7462 def __ge__(self, o):
7463 r"""__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
7464 return _IMP_algebra.GridIndexKD___ge__(self, o)
7466 def __le__(self, o):
7467 r"""__le__(GridIndexKD self, GridIndexKD o) -> bool"""
7468 return _IMP_algebra.GridIndexKD___le__(self, o)
7471 r"""__hash__(GridIndexKD self) -> std::size_t"""
7472 return _IMP_algebra.GridIndexKD___hash__(self)
7475 r"""__str__(GridIndexKD self) -> std::string"""
7476 return _IMP_algebra.GridIndexKD___str__(self)
7479 r"""__repr__(GridIndexKD self) -> std::string"""
7480 return _IMP_algebra.GridIndexKD___repr__(self)
7482 def _get_as_binary(self):
7483 r"""_get_as_binary(GridIndexKD self) -> PyObject *"""
7484 return _IMP_algebra.GridIndexKD__get_as_binary(self)
7486 def _set_from_binary(self, p):
7487 r"""_set_from_binary(GridIndexKD self, PyObject * p)"""
7488 return _IMP_algebra.GridIndexKD__set_from_binary(self, p)
7490 def __getstate__(self):
7491 p = self._get_as_binary()
7492 if len(self.__dict__) > 1:
7493 d = self.__dict__.copy()
7498 def __setstate__(self, p):
7499 if not hasattr(self,
'this'):
7501 if isinstance(p, tuple):
7503 self.__dict__.update(d)
7504 return self._set_from_binary(p)
7506 __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
7509 _IMP_algebra.GridIndexKD_swigregister(GridIndexKD)
7510 class ExtendedGridIndex1D(IMP._Value):
7511 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 1 > class."""
7513 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7515 def __init__(self, *args):
7517 __init__(ExtendedGridIndex1D self, IMP::Ints vals) -> ExtendedGridIndex1D
7518 __init__(ExtendedGridIndex1D self, int x) -> ExtendedGridIndex1D
7519 __init__(ExtendedGridIndex1D self, int x, int y) -> ExtendedGridIndex1D
7520 __init__(ExtendedGridIndex1D self, int x, int y, int z) -> ExtendedGridIndex1D
7521 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l) -> ExtendedGridIndex1D
7522 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
7523 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
7524 __init__(ExtendedGridIndex1D self) -> ExtendedGridIndex1D
7526 _IMP_algebra.ExtendedGridIndex1D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex1D(*args))
7528 def get_dimension(self):
7529 r"""get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
7530 return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)
7532 def __cmp__(self, o):
7533 r"""__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
7534 return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, o)
7536 def __eq__(self, o):
7537 r"""__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7538 return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)
7540 def __ne__(self, o):
7541 r"""__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7542 return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)
7544 def __lt__(self, o):
7545 r"""__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7546 return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)
7548 def __gt__(self, o):
7549 r"""__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7550 return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)
7552 def __ge__(self, o):
7553 r"""__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7554 return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)
7556 def __le__(self, o):
7557 r"""__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7558 return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)
7560 def __setitem__(self, i, v):
7561 r"""__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
7562 return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, i, v)
7564 def __getitem__(self, i):
7565 r"""__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
7566 return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)
7568 def show(self, *args):
7569 r"""show(ExtendedGridIndex1D self, _ostream out=std::cout)"""
7570 return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)
7573 r"""__len__(ExtendedGridIndex1D self) -> unsigned int"""
7574 return _IMP_algebra.ExtendedGridIndex1D___len__(self)
7577 r"""__hash__(ExtendedGridIndex1D self) -> std::size_t"""
7578 return _IMP_algebra.ExtendedGridIndex1D___hash__(self)
7580 def get_uniform_offset(self, ii):
7581 r"""get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
7582 return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, ii)
7584 def get_offset(self, i, j, k):
7585 r"""get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
7586 return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, i, j, k)
7589 r"""__str__(ExtendedGridIndex1D self) -> std::string"""
7590 return _IMP_algebra.ExtendedGridIndex1D___str__(self)
7593 r"""__repr__(ExtendedGridIndex1D self) -> std::string"""
7594 return _IMP_algebra.ExtendedGridIndex1D___repr__(self)
7596 def _get_as_binary(self):
7597 r"""_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
7598 return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)
7600 def _set_from_binary(self, p):
7601 r"""_set_from_binary(ExtendedGridIndex1D self, PyObject * p)"""
7602 return _IMP_algebra.ExtendedGridIndex1D__set_from_binary(self, p)
7604 def __getstate__(self):
7605 p = self._get_as_binary()
7606 if len(self.__dict__) > 1:
7607 d = self.__dict__.copy()
7612 def __setstate__(self, p):
7613 if not hasattr(self,
'this'):
7615 if isinstance(p, tuple):
7617 self.__dict__.update(d)
7618 return self._set_from_binary(p)
7620 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
7623 _IMP_algebra.ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
7624 class ExtendedGridIndex2D(IMP._Value):
7625 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 2 > class."""
7627 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7629 def __init__(self, *args):
7631 __init__(ExtendedGridIndex2D self, IMP::Ints vals) -> ExtendedGridIndex2D
7632 __init__(ExtendedGridIndex2D self, int x) -> ExtendedGridIndex2D
7633 __init__(ExtendedGridIndex2D self, int x, int y) -> ExtendedGridIndex2D
7634 __init__(ExtendedGridIndex2D self, int x, int y, int z) -> ExtendedGridIndex2D
7635 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l) -> ExtendedGridIndex2D
7636 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
7637 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
7638 __init__(ExtendedGridIndex2D self) -> ExtendedGridIndex2D
7640 _IMP_algebra.ExtendedGridIndex2D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex2D(*args))
7642 def get_dimension(self):
7643 r"""get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
7644 return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)
7646 def __cmp__(self, o):
7647 r"""__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
7648 return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, o)
7650 def __eq__(self, o):
7651 r"""__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7652 return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)
7654 def __ne__(self, o):
7655 r"""__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7656 return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)
7658 def __lt__(self, o):
7659 r"""__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7660 return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)
7662 def __gt__(self, o):
7663 r"""__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7664 return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)
7666 def __ge__(self, o):
7667 r"""__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7668 return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)
7670 def __le__(self, o):
7671 r"""__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7672 return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)
7674 def __setitem__(self, i, v):
7675 r"""__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
7676 return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, i, v)
7678 def __getitem__(self, i):
7679 r"""__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
7680 return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)
7682 def show(self, *args):
7683 r"""show(ExtendedGridIndex2D self, _ostream out=std::cout)"""
7684 return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)
7687 r"""__len__(ExtendedGridIndex2D self) -> unsigned int"""
7688 return _IMP_algebra.ExtendedGridIndex2D___len__(self)
7691 r"""__hash__(ExtendedGridIndex2D self) -> std::size_t"""
7692 return _IMP_algebra.ExtendedGridIndex2D___hash__(self)
7694 def get_uniform_offset(self, ii):
7695 r"""get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
7696 return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, ii)
7698 def get_offset(self, i, j, k):
7699 r"""get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
7700 return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, i, j, k)
7703 r"""__str__(ExtendedGridIndex2D self) -> std::string"""
7704 return _IMP_algebra.ExtendedGridIndex2D___str__(self)
7707 r"""__repr__(ExtendedGridIndex2D self) -> std::string"""
7708 return _IMP_algebra.ExtendedGridIndex2D___repr__(self)
7710 def _get_as_binary(self):
7711 r"""_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
7712 return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)
7714 def _set_from_binary(self, p):
7715 r"""_set_from_binary(ExtendedGridIndex2D self, PyObject * p)"""
7716 return _IMP_algebra.ExtendedGridIndex2D__set_from_binary(self, p)
7718 def __getstate__(self):
7719 p = self._get_as_binary()
7720 if len(self.__dict__) > 1:
7721 d = self.__dict__.copy()
7726 def __setstate__(self, p):
7727 if not hasattr(self,
'this'):
7729 if isinstance(p, tuple):
7731 self.__dict__.update(d)
7732 return self._set_from_binary(p)
7734 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
7737 _IMP_algebra.ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
7738 class ExtendedGridIndex3D(IMP._Value):
7739 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 3 > class."""
7741 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7743 def __init__(self, *args):
7745 __init__(ExtendedGridIndex3D self, IMP::Ints vals) -> ExtendedGridIndex3D
7746 __init__(ExtendedGridIndex3D self, int x) -> ExtendedGridIndex3D
7747 __init__(ExtendedGridIndex3D self, int x, int y) -> ExtendedGridIndex3D
7748 __init__(ExtendedGridIndex3D self, int x, int y, int z) -> ExtendedGridIndex3D
7749 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l) -> ExtendedGridIndex3D
7750 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
7751 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
7752 __init__(ExtendedGridIndex3D self) -> ExtendedGridIndex3D
7754 _IMP_algebra.ExtendedGridIndex3D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex3D(*args))
7756 def get_dimension(self):
7757 r"""get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
7758 return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)
7760 def __cmp__(self, o):
7761 r"""__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
7762 return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, o)
7764 def __eq__(self, o):
7765 r"""__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7766 return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)
7768 def __ne__(self, o):
7769 r"""__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7770 return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)
7772 def __lt__(self, o):
7773 r"""__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7774 return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)
7776 def __gt__(self, o):
7777 r"""__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7778 return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)
7780 def __ge__(self, o):
7781 r"""__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7782 return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)
7784 def __le__(self, o):
7785 r"""__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7786 return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)
7788 def __setitem__(self, i, v):
7789 r"""__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
7790 return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, i, v)
7792 def __getitem__(self, i):
7793 r"""__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
7794 return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)
7796 def show(self, *args):
7797 r"""show(ExtendedGridIndex3D self, _ostream out=std::cout)"""
7798 return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)
7801 r"""__len__(ExtendedGridIndex3D self) -> unsigned int"""
7802 return _IMP_algebra.ExtendedGridIndex3D___len__(self)
7805 r"""__hash__(ExtendedGridIndex3D self) -> std::size_t"""
7806 return _IMP_algebra.ExtendedGridIndex3D___hash__(self)
7808 def get_uniform_offset(self, ii):
7809 r"""get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
7810 return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, ii)
7812 def get_offset(self, i, j, k):
7813 r"""get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
7814 return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, i, j, k)
7817 r"""__str__(ExtendedGridIndex3D self) -> std::string"""
7818 return _IMP_algebra.ExtendedGridIndex3D___str__(self)
7821 r"""__repr__(ExtendedGridIndex3D self) -> std::string"""
7822 return _IMP_algebra.ExtendedGridIndex3D___repr__(self)
7824 def _get_as_binary(self):
7825 r"""_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
7826 return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)
7828 def _set_from_binary(self, p):
7829 r"""_set_from_binary(ExtendedGridIndex3D self, PyObject * p)"""
7830 return _IMP_algebra.ExtendedGridIndex3D__set_from_binary(self, p)
7832 def __getstate__(self):
7833 p = self._get_as_binary()
7834 if len(self.__dict__) > 1:
7835 d = self.__dict__.copy()
7840 def __setstate__(self, p):
7841 if not hasattr(self,
'this'):
7843 if isinstance(p, tuple):
7845 self.__dict__.update(d)
7846 return self._set_from_binary(p)
7848 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
7851 _IMP_algebra.ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
7852 class ExtendedGridIndex4D(IMP._Value):
7853 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 4 > class."""
7855 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7857 def __init__(self, *args):
7859 __init__(ExtendedGridIndex4D self, IMP::Ints vals) -> ExtendedGridIndex4D
7860 __init__(ExtendedGridIndex4D self, int x) -> ExtendedGridIndex4D
7861 __init__(ExtendedGridIndex4D self, int x, int y) -> ExtendedGridIndex4D
7862 __init__(ExtendedGridIndex4D self, int x, int y, int z) -> ExtendedGridIndex4D
7863 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l) -> ExtendedGridIndex4D
7864 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
7865 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
7866 __init__(ExtendedGridIndex4D self) -> ExtendedGridIndex4D
7868 _IMP_algebra.ExtendedGridIndex4D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex4D(*args))
7870 def get_dimension(self):
7871 r"""get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
7872 return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)
7874 def __cmp__(self, o):
7875 r"""__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
7876 return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, o)
7878 def __eq__(self, o):
7879 r"""__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7880 return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)
7882 def __ne__(self, o):
7883 r"""__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7884 return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)
7886 def __lt__(self, o):
7887 r"""__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7888 return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)
7890 def __gt__(self, o):
7891 r"""__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7892 return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)
7894 def __ge__(self, o):
7895 r"""__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7896 return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)
7898 def __le__(self, o):
7899 r"""__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7900 return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)
7902 def __setitem__(self, i, v):
7903 r"""__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
7904 return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, i, v)
7906 def __getitem__(self, i):
7907 r"""__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
7908 return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)
7910 def show(self, *args):
7911 r"""show(ExtendedGridIndex4D self, _ostream out=std::cout)"""
7912 return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)
7915 r"""__len__(ExtendedGridIndex4D self) -> unsigned int"""
7916 return _IMP_algebra.ExtendedGridIndex4D___len__(self)
7919 r"""__hash__(ExtendedGridIndex4D self) -> std::size_t"""
7920 return _IMP_algebra.ExtendedGridIndex4D___hash__(self)
7922 def get_uniform_offset(self, ii):
7923 r"""get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
7924 return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, ii)
7926 def get_offset(self, i, j, k):
7927 r"""get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
7928 return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, i, j, k)
7931 r"""__str__(ExtendedGridIndex4D self) -> std::string"""
7932 return _IMP_algebra.ExtendedGridIndex4D___str__(self)
7935 r"""__repr__(ExtendedGridIndex4D self) -> std::string"""
7936 return _IMP_algebra.ExtendedGridIndex4D___repr__(self)
7938 def _get_as_binary(self):
7939 r"""_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
7940 return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)
7942 def _set_from_binary(self, p):
7943 r"""_set_from_binary(ExtendedGridIndex4D self, PyObject * p)"""
7944 return _IMP_algebra.ExtendedGridIndex4D__set_from_binary(self, p)
7946 def __getstate__(self):
7947 p = self._get_as_binary()
7948 if len(self.__dict__) > 1:
7949 d = self.__dict__.copy()
7954 def __setstate__(self, p):
7955 if not hasattr(self,
'this'):
7957 if isinstance(p, tuple):
7959 self.__dict__.update(d)
7960 return self._set_from_binary(p)
7962 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
7965 _IMP_algebra.ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
7966 class ExtendedGridIndex5D(IMP._Value):
7967 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 5 > class."""
7969 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7971 def __init__(self, *args):
7973 __init__(ExtendedGridIndex5D self, IMP::Ints vals) -> ExtendedGridIndex5D
7974 __init__(ExtendedGridIndex5D self, int x) -> ExtendedGridIndex5D
7975 __init__(ExtendedGridIndex5D self, int x, int y) -> ExtendedGridIndex5D
7976 __init__(ExtendedGridIndex5D self, int x, int y, int z) -> ExtendedGridIndex5D
7977 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l) -> ExtendedGridIndex5D
7978 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
7979 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
7980 __init__(ExtendedGridIndex5D self) -> ExtendedGridIndex5D
7982 _IMP_algebra.ExtendedGridIndex5D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex5D(*args))
7984 def get_dimension(self):
7985 r"""get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
7986 return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)
7988 def __cmp__(self, o):
7989 r"""__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
7990 return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, o)
7992 def __eq__(self, o):
7993 r"""__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7994 return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)
7996 def __ne__(self, o):
7997 r"""__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7998 return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)
8000 def __lt__(self, o):
8001 r"""__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8002 return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)
8004 def __gt__(self, o):
8005 r"""__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8006 return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)
8008 def __ge__(self, o):
8009 r"""__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8010 return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)
8012 def __le__(self, o):
8013 r"""__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8014 return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)
8016 def __setitem__(self, i, v):
8017 r"""__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
8018 return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, i, v)
8020 def __getitem__(self, i):
8021 r"""__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
8022 return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)
8024 def show(self, *args):
8025 r"""show(ExtendedGridIndex5D self, _ostream out=std::cout)"""
8026 return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)
8029 r"""__len__(ExtendedGridIndex5D self) -> unsigned int"""
8030 return _IMP_algebra.ExtendedGridIndex5D___len__(self)
8033 r"""__hash__(ExtendedGridIndex5D self) -> std::size_t"""
8034 return _IMP_algebra.ExtendedGridIndex5D___hash__(self)
8036 def get_uniform_offset(self, ii):
8037 r"""get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
8038 return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, ii)
8040 def get_offset(self, i, j, k):
8041 r"""get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
8042 return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, i, j, k)
8045 r"""__str__(ExtendedGridIndex5D self) -> std::string"""
8046 return _IMP_algebra.ExtendedGridIndex5D___str__(self)
8049 r"""__repr__(ExtendedGridIndex5D self) -> std::string"""
8050 return _IMP_algebra.ExtendedGridIndex5D___repr__(self)
8052 def _get_as_binary(self):
8053 r"""_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
8054 return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)
8056 def _set_from_binary(self, p):
8057 r"""_set_from_binary(ExtendedGridIndex5D self, PyObject * p)"""
8058 return _IMP_algebra.ExtendedGridIndex5D__set_from_binary(self, p)
8060 def __getstate__(self):
8061 p = self._get_as_binary()
8062 if len(self.__dict__) > 1:
8063 d = self.__dict__.copy()
8068 def __setstate__(self, p):
8069 if not hasattr(self,
'this'):
8071 if isinstance(p, tuple):
8073 self.__dict__.update(d)
8074 return self._set_from_binary(p)
8076 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
8079 _IMP_algebra.ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
8080 class ExtendedGridIndex6D(IMP._Value):
8081 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 6 > class."""
8083 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8085 def __init__(self, *args):
8087 __init__(ExtendedGridIndex6D self, IMP::Ints vals) -> ExtendedGridIndex6D
8088 __init__(ExtendedGridIndex6D self, int x) -> ExtendedGridIndex6D
8089 __init__(ExtendedGridIndex6D self, int x, int y) -> ExtendedGridIndex6D
8090 __init__(ExtendedGridIndex6D self, int x, int y, int z) -> ExtendedGridIndex6D
8091 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l) -> ExtendedGridIndex6D
8092 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
8093 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
8094 __init__(ExtendedGridIndex6D self) -> ExtendedGridIndex6D
8096 _IMP_algebra.ExtendedGridIndex6D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex6D(*args))
8098 def get_dimension(self):
8099 r"""get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
8100 return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)
8102 def __cmp__(self, o):
8103 r"""__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
8104 return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, o)
8106 def __eq__(self, o):
8107 r"""__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8108 return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)
8110 def __ne__(self, o):
8111 r"""__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8112 return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)
8114 def __lt__(self, o):
8115 r"""__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8116 return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)
8118 def __gt__(self, o):
8119 r"""__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8120 return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)
8122 def __ge__(self, o):
8123 r"""__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8124 return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)
8126 def __le__(self, o):
8127 r"""__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8128 return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)
8130 def __setitem__(self, i, v):
8131 r"""__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
8132 return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, i, v)
8134 def __getitem__(self, i):
8135 r"""__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
8136 return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)
8138 def show(self, *args):
8139 r"""show(ExtendedGridIndex6D self, _ostream out=std::cout)"""
8140 return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)
8143 r"""__len__(ExtendedGridIndex6D self) -> unsigned int"""
8144 return _IMP_algebra.ExtendedGridIndex6D___len__(self)
8147 r"""__hash__(ExtendedGridIndex6D self) -> std::size_t"""
8148 return _IMP_algebra.ExtendedGridIndex6D___hash__(self)
8150 def get_uniform_offset(self, ii):
8151 r"""get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
8152 return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, ii)
8154 def get_offset(self, i, j, k):
8155 r"""get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
8156 return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, i, j, k)
8159 r"""__str__(ExtendedGridIndex6D self) -> std::string"""
8160 return _IMP_algebra.ExtendedGridIndex6D___str__(self)
8163 r"""__repr__(ExtendedGridIndex6D self) -> std::string"""
8164 return _IMP_algebra.ExtendedGridIndex6D___repr__(self)
8166 def _get_as_binary(self):
8167 r"""_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
8168 return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)
8170 def _set_from_binary(self, p):
8171 r"""_set_from_binary(ExtendedGridIndex6D self, PyObject * p)"""
8172 return _IMP_algebra.ExtendedGridIndex6D__set_from_binary(self, p)
8174 def __getstate__(self):
8175 p = self._get_as_binary()
8176 if len(self.__dict__) > 1:
8177 d = self.__dict__.copy()
8182 def __setstate__(self, p):
8183 if not hasattr(self,
'this'):
8185 if isinstance(p, tuple):
8187 self.__dict__.update(d)
8188 return self._set_from_binary(p)
8190 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
8193 _IMP_algebra.ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
8194 class ExtendedGridIndexKD(IMP._Value):
8195 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< -1 > class."""
8197 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8199 def __init__(self, *args):
8201 __init__(ExtendedGridIndexKD self, IMP::Ints vals) -> ExtendedGridIndexKD
8202 __init__(ExtendedGridIndexKD self, int x) -> ExtendedGridIndexKD
8203 __init__(ExtendedGridIndexKD self, int x, int y) -> ExtendedGridIndexKD
8204 __init__(ExtendedGridIndexKD self, int x, int y, int z) -> ExtendedGridIndexKD
8205 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l) -> ExtendedGridIndexKD
8206 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
8207 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
8208 __init__(ExtendedGridIndexKD self) -> ExtendedGridIndexKD
8210 _IMP_algebra.ExtendedGridIndexKD_swiginit(self, _IMP_algebra.new_ExtendedGridIndexKD(*args))
8212 def get_dimension(self):
8213 r"""get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
8214 return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)
8216 def __cmp__(self, o):
8217 r"""__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
8218 return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, o)
8220 def __eq__(self, o):
8221 r"""__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8222 return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)
8224 def __ne__(self, o):
8225 r"""__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8226 return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)
8228 def __lt__(self, o):
8229 r"""__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8230 return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)
8232 def __gt__(self, o):
8233 r"""__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8234 return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)
8236 def __ge__(self, o):
8237 r"""__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8238 return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)
8240 def __le__(self, o):
8241 r"""__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8242 return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)
8244 def __setitem__(self, i, v):
8245 r"""__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
8246 return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, i, v)
8248 def __getitem__(self, i):
8249 r"""__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
8250 return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)
8252 def show(self, *args):
8253 r"""show(ExtendedGridIndexKD self, _ostream out=std::cout)"""
8254 return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)
8257 r"""__len__(ExtendedGridIndexKD self) -> unsigned int"""
8258 return _IMP_algebra.ExtendedGridIndexKD___len__(self)
8261 r"""__hash__(ExtendedGridIndexKD self) -> std::size_t"""
8262 return _IMP_algebra.ExtendedGridIndexKD___hash__(self)
8264 def get_uniform_offset(self, ii):
8265 r"""get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
8266 return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, ii)
8268 def get_offset(self, i, j, k):
8269 r"""get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
8270 return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, i, j, k)
8273 r"""__str__(ExtendedGridIndexKD self) -> std::string"""
8274 return _IMP_algebra.ExtendedGridIndexKD___str__(self)
8277 r"""__repr__(ExtendedGridIndexKD self) -> std::string"""
8278 return _IMP_algebra.ExtendedGridIndexKD___repr__(self)
8280 def _get_as_binary(self):
8281 r"""_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
8282 return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)
8284 def _set_from_binary(self, p):
8285 r"""_set_from_binary(ExtendedGridIndexKD self, PyObject * p)"""
8286 return _IMP_algebra.ExtendedGridIndexKD__set_from_binary(self, p)
8288 def __getstate__(self):
8289 p = self._get_as_binary()
8290 if len(self.__dict__) > 1:
8291 d = self.__dict__.copy()
8296 def __setstate__(self, p):
8297 if not hasattr(self,
'this'):
8299 if isinstance(p, tuple):
8301 self.__dict__.update(d)
8302 return self._set_from_binary(p)
8304 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
8307 _IMP_algebra.ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
8308 class BoundedGridRange1D(object):
8309 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 1 > class."""
8311 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8314 def get_is_bounded():
8315 r"""get_is_bounded() -> bool"""
8316 return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
8318 def __init__(self, *args):
8320 __init__(BoundedGridRange1D self) -> BoundedGridRange1D
8321 __init__(BoundedGridRange1D self, IMP::Ints const & counts) -> BoundedGridRange1D
8323 _IMP_algebra.BoundedGridRange1D_swiginit(self, _IMP_algebra.new_BoundedGridRange1D(*args))
8325 def get_number_of_voxels(self, *args):
8327 get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
8328 get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
8330 return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)
8332 def get_end_index(self):
8333 r"""get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8334 return _IMP_algebra.BoundedGridRange1D_get_end_index(self)
8336 def show(self, *args):
8337 r"""show(BoundedGridRange1D self, _ostream out=std::cout)"""
8338 return _IMP_algebra.BoundedGridRange1D_show(self, *args)
8340 def get_all_indexes(self):
8341 r"""get_all_indexes(BoundedGridRange1D self) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8342 return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)
8345 r"""get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8346 return _IMP_algebra.BoundedGridRange1D_get_indexes(self, lb, ub)
8348 def get_extended_indexes(self, lb, ub):
8349 r"""get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
8350 return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, lb, ub)
8353 r"""get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
8354 return _IMP_algebra.BoundedGridRange1D_get_index(self, v)
8356 def get_has_index(self, v):
8357 r"""get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
8358 return _IMP_algebra.BoundedGridRange1D_get_has_index(self, v)
8360 def get_minimum_extended_index(self):
8361 r"""get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8362 return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)
8364 def get_maximum_extended_index(self):
8365 r"""get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8366 return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)
8369 r"""__str__(BoundedGridRange1D self) -> std::string"""
8370 return _IMP_algebra.BoundedGridRange1D___str__(self)
8373 r"""__repr__(BoundedGridRange1D self) -> std::string"""
8374 return _IMP_algebra.BoundedGridRange1D___repr__(self)
8376 def __cmp__(self, arg2):
8377 r"""__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
8378 return _IMP_algebra.BoundedGridRange1D___cmp__(self, arg2)
8380 def __eq__(self, arg2):
8381 r"""__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
8382 return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)
8384 def _get_as_binary(self):
8385 r"""_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
8386 return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)
8388 def _set_from_binary(self, p):
8389 r"""_set_from_binary(BoundedGridRange1D self, PyObject * p)"""
8390 return _IMP_algebra.BoundedGridRange1D__set_from_binary(self, p)
8392 def __getstate__(self):
8393 p = self._get_as_binary()
8394 if len(self.__dict__) > 1:
8395 d = self.__dict__.copy()
8400 def __setstate__(self, p):
8401 if not hasattr(self,
'this'):
8403 if isinstance(p, tuple):
8405 self.__dict__.update(d)
8406 return self._set_from_binary(p)
8408 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
8411 _IMP_algebra.BoundedGridRange1D_swigregister(BoundedGridRange1D)
8412 class BoundedGridRange2D(object):
8413 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 2 > class."""
8415 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8418 def get_is_bounded():
8419 r"""get_is_bounded() -> bool"""
8420 return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
8422 def __init__(self, *args):
8424 __init__(BoundedGridRange2D self) -> BoundedGridRange2D
8425 __init__(BoundedGridRange2D self, IMP::Ints const & counts) -> BoundedGridRange2D
8427 _IMP_algebra.BoundedGridRange2D_swiginit(self, _IMP_algebra.new_BoundedGridRange2D(*args))
8429 def get_number_of_voxels(self, *args):
8431 get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
8432 get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
8434 return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)
8436 def get_end_index(self):
8437 r"""get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8438 return _IMP_algebra.BoundedGridRange2D_get_end_index(self)
8440 def show(self, *args):
8441 r"""show(BoundedGridRange2D self, _ostream out=std::cout)"""
8442 return _IMP_algebra.BoundedGridRange2D_show(self, *args)
8444 def get_all_indexes(self):
8445 r"""get_all_indexes(BoundedGridRange2D self) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8446 return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)
8449 r"""get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8450 return _IMP_algebra.BoundedGridRange2D_get_indexes(self, lb, ub)
8452 def get_extended_indexes(self, lb, ub):
8453 r"""get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
8454 return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, lb, ub)
8457 r"""get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
8458 return _IMP_algebra.BoundedGridRange2D_get_index(self, v)
8460 def get_has_index(self, v):
8461 r"""get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
8462 return _IMP_algebra.BoundedGridRange2D_get_has_index(self, v)
8464 def get_minimum_extended_index(self):
8465 r"""get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8466 return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)
8468 def get_maximum_extended_index(self):
8469 r"""get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8470 return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)
8473 r"""__str__(BoundedGridRange2D self) -> std::string"""
8474 return _IMP_algebra.BoundedGridRange2D___str__(self)
8477 r"""__repr__(BoundedGridRange2D self) -> std::string"""
8478 return _IMP_algebra.BoundedGridRange2D___repr__(self)
8480 def __cmp__(self, arg2):
8481 r"""__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
8482 return _IMP_algebra.BoundedGridRange2D___cmp__(self, arg2)
8484 def __eq__(self, arg2):
8485 r"""__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
8486 return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)
8488 def _get_as_binary(self):
8489 r"""_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
8490 return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)
8492 def _set_from_binary(self, p):
8493 r"""_set_from_binary(BoundedGridRange2D self, PyObject * p)"""
8494 return _IMP_algebra.BoundedGridRange2D__set_from_binary(self, p)
8496 def __getstate__(self):
8497 p = self._get_as_binary()
8498 if len(self.__dict__) > 1:
8499 d = self.__dict__.copy()
8504 def __setstate__(self, p):
8505 if not hasattr(self,
'this'):
8507 if isinstance(p, tuple):
8509 self.__dict__.update(d)
8510 return self._set_from_binary(p)
8512 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
8515 _IMP_algebra.BoundedGridRange2D_swigregister(BoundedGridRange2D)
8516 class BoundedGridRange3D(object):
8517 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 3 > class."""
8519 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8522 def get_is_bounded():
8523 r"""get_is_bounded() -> bool"""
8524 return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
8526 def __init__(self, *args):
8528 __init__(BoundedGridRange3D self) -> BoundedGridRange3D
8529 __init__(BoundedGridRange3D self, IMP::Ints const & counts) -> BoundedGridRange3D
8531 _IMP_algebra.BoundedGridRange3D_swiginit(self, _IMP_algebra.new_BoundedGridRange3D(*args))
8533 def get_number_of_voxels(self, *args):
8535 get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
8536 get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
8538 return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)
8540 def get_end_index(self):
8541 r"""get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8542 return _IMP_algebra.BoundedGridRange3D_get_end_index(self)
8544 def show(self, *args):
8545 r"""show(BoundedGridRange3D self, _ostream out=std::cout)"""
8546 return _IMP_algebra.BoundedGridRange3D_show(self, *args)
8548 def get_all_indexes(self):
8549 r"""get_all_indexes(BoundedGridRange3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8550 return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)
8553 r"""get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8554 return _IMP_algebra.BoundedGridRange3D_get_indexes(self, lb, ub)
8556 def get_extended_indexes(self, lb, ub):
8557 r"""get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
8558 return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, lb, ub)
8561 r"""get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
8562 return _IMP_algebra.BoundedGridRange3D_get_index(self, v)
8564 def get_has_index(self, v):
8565 r"""get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
8566 return _IMP_algebra.BoundedGridRange3D_get_has_index(self, v)
8568 def get_minimum_extended_index(self):
8569 r"""get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8570 return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)
8572 def get_maximum_extended_index(self):
8573 r"""get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8574 return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)
8577 r"""__str__(BoundedGridRange3D self) -> std::string"""
8578 return _IMP_algebra.BoundedGridRange3D___str__(self)
8581 r"""__repr__(BoundedGridRange3D self) -> std::string"""
8582 return _IMP_algebra.BoundedGridRange3D___repr__(self)
8584 def __cmp__(self, arg2):
8585 r"""__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
8586 return _IMP_algebra.BoundedGridRange3D___cmp__(self, arg2)
8588 def __eq__(self, arg2):
8589 r"""__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
8590 return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)
8592 def _get_as_binary(self):
8593 r"""_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
8594 return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)
8596 def _set_from_binary(self, p):
8597 r"""_set_from_binary(BoundedGridRange3D self, PyObject * p)"""
8598 return _IMP_algebra.BoundedGridRange3D__set_from_binary(self, p)
8600 def __getstate__(self):
8601 p = self._get_as_binary()
8602 if len(self.__dict__) > 1:
8603 d = self.__dict__.copy()
8608 def __setstate__(self, p):
8609 if not hasattr(self,
'this'):
8611 if isinstance(p, tuple):
8613 self.__dict__.update(d)
8614 return self._set_from_binary(p)
8616 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
8619 _IMP_algebra.BoundedGridRange3D_swigregister(BoundedGridRange3D)
8620 class BoundedGridRange4D(object):
8621 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 4 > class."""
8623 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8626 def get_is_bounded():
8627 r"""get_is_bounded() -> bool"""
8628 return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
8630 def __init__(self, *args):
8632 __init__(BoundedGridRange4D self) -> BoundedGridRange4D
8633 __init__(BoundedGridRange4D self, IMP::Ints const & counts) -> BoundedGridRange4D
8635 _IMP_algebra.BoundedGridRange4D_swiginit(self, _IMP_algebra.new_BoundedGridRange4D(*args))
8637 def get_number_of_voxels(self, *args):
8639 get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
8640 get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
8642 return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)
8644 def get_end_index(self):
8645 r"""get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8646 return _IMP_algebra.BoundedGridRange4D_get_end_index(self)
8648 def show(self, *args):
8649 r"""show(BoundedGridRange4D self, _ostream out=std::cout)"""
8650 return _IMP_algebra.BoundedGridRange4D_show(self, *args)
8652 def get_all_indexes(self):
8653 r"""get_all_indexes(BoundedGridRange4D self) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8654 return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)
8657 r"""get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8658 return _IMP_algebra.BoundedGridRange4D_get_indexes(self, lb, ub)
8660 def get_extended_indexes(self, lb, ub):
8661 r"""get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
8662 return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, lb, ub)
8665 r"""get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
8666 return _IMP_algebra.BoundedGridRange4D_get_index(self, v)
8668 def get_has_index(self, v):
8669 r"""get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
8670 return _IMP_algebra.BoundedGridRange4D_get_has_index(self, v)
8672 def get_minimum_extended_index(self):
8673 r"""get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8674 return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)
8676 def get_maximum_extended_index(self):
8677 r"""get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8678 return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)
8681 r"""__str__(BoundedGridRange4D self) -> std::string"""
8682 return _IMP_algebra.BoundedGridRange4D___str__(self)
8685 r"""__repr__(BoundedGridRange4D self) -> std::string"""
8686 return _IMP_algebra.BoundedGridRange4D___repr__(self)
8688 def __cmp__(self, arg2):
8689 r"""__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
8690 return _IMP_algebra.BoundedGridRange4D___cmp__(self, arg2)
8692 def __eq__(self, arg2):
8693 r"""__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
8694 return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)
8696 def _get_as_binary(self):
8697 r"""_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
8698 return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)
8700 def _set_from_binary(self, p):
8701 r"""_set_from_binary(BoundedGridRange4D self, PyObject * p)"""
8702 return _IMP_algebra.BoundedGridRange4D__set_from_binary(self, p)
8704 def __getstate__(self):
8705 p = self._get_as_binary()
8706 if len(self.__dict__) > 1:
8707 d = self.__dict__.copy()
8712 def __setstate__(self, p):
8713 if not hasattr(self,
'this'):
8715 if isinstance(p, tuple):
8717 self.__dict__.update(d)
8718 return self._set_from_binary(p)
8720 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
8723 _IMP_algebra.BoundedGridRange4D_swigregister(BoundedGridRange4D)
8724 class BoundedGridRange5D(object):
8725 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 5 > class."""
8727 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8730 def get_is_bounded():
8731 r"""get_is_bounded() -> bool"""
8732 return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
8734 def __init__(self, *args):
8736 __init__(BoundedGridRange5D self) -> BoundedGridRange5D
8737 __init__(BoundedGridRange5D self, IMP::Ints const & counts) -> BoundedGridRange5D
8739 _IMP_algebra.BoundedGridRange5D_swiginit(self, _IMP_algebra.new_BoundedGridRange5D(*args))
8741 def get_number_of_voxels(self, *args):
8743 get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
8744 get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
8746 return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)
8748 def get_end_index(self):
8749 r"""get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8750 return _IMP_algebra.BoundedGridRange5D_get_end_index(self)
8752 def show(self, *args):
8753 r"""show(BoundedGridRange5D self, _ostream out=std::cout)"""
8754 return _IMP_algebra.BoundedGridRange5D_show(self, *args)
8756 def get_all_indexes(self):
8757 r"""get_all_indexes(BoundedGridRange5D self) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8758 return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)
8761 r"""get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8762 return _IMP_algebra.BoundedGridRange5D_get_indexes(self, lb, ub)
8764 def get_extended_indexes(self, lb, ub):
8765 r"""get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
8766 return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, lb, ub)
8769 r"""get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
8770 return _IMP_algebra.BoundedGridRange5D_get_index(self, v)
8772 def get_has_index(self, v):
8773 r"""get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
8774 return _IMP_algebra.BoundedGridRange5D_get_has_index(self, v)
8776 def get_minimum_extended_index(self):
8777 r"""get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8778 return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)
8780 def get_maximum_extended_index(self):
8781 r"""get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8782 return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)
8785 r"""__str__(BoundedGridRange5D self) -> std::string"""
8786 return _IMP_algebra.BoundedGridRange5D___str__(self)
8789 r"""__repr__(BoundedGridRange5D self) -> std::string"""
8790 return _IMP_algebra.BoundedGridRange5D___repr__(self)
8792 def __cmp__(self, arg2):
8793 r"""__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
8794 return _IMP_algebra.BoundedGridRange5D___cmp__(self, arg2)
8796 def __eq__(self, arg2):
8797 r"""__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
8798 return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)
8800 def _get_as_binary(self):
8801 r"""_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
8802 return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)
8804 def _set_from_binary(self, p):
8805 r"""_set_from_binary(BoundedGridRange5D self, PyObject * p)"""
8806 return _IMP_algebra.BoundedGridRange5D__set_from_binary(self, p)
8808 def __getstate__(self):
8809 p = self._get_as_binary()
8810 if len(self.__dict__) > 1:
8811 d = self.__dict__.copy()
8816 def __setstate__(self, p):
8817 if not hasattr(self,
'this'):
8819 if isinstance(p, tuple):
8821 self.__dict__.update(d)
8822 return self._set_from_binary(p)
8824 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
8827 _IMP_algebra.BoundedGridRange5D_swigregister(BoundedGridRange5D)
8828 class BoundedGridRange6D(object):
8829 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 6 > class."""
8831 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8834 def get_is_bounded():
8835 r"""get_is_bounded() -> bool"""
8836 return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
8838 def __init__(self, *args):
8840 __init__(BoundedGridRange6D self) -> BoundedGridRange6D
8841 __init__(BoundedGridRange6D self, IMP::Ints const & counts) -> BoundedGridRange6D
8843 _IMP_algebra.BoundedGridRange6D_swiginit(self, _IMP_algebra.new_BoundedGridRange6D(*args))
8845 def get_number_of_voxels(self, *args):
8847 get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
8848 get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
8850 return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)
8852 def get_end_index(self):
8853 r"""get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8854 return _IMP_algebra.BoundedGridRange6D_get_end_index(self)
8856 def show(self, *args):
8857 r"""show(BoundedGridRange6D self, _ostream out=std::cout)"""
8858 return _IMP_algebra.BoundedGridRange6D_show(self, *args)
8860 def get_all_indexes(self):
8861 r"""get_all_indexes(BoundedGridRange6D self) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8862 return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)
8865 r"""get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8866 return _IMP_algebra.BoundedGridRange6D_get_indexes(self, lb, ub)
8868 def get_extended_indexes(self, lb, ub):
8869 r"""get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
8870 return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, lb, ub)
8873 r"""get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
8874 return _IMP_algebra.BoundedGridRange6D_get_index(self, v)
8876 def get_has_index(self, v):
8877 r"""get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
8878 return _IMP_algebra.BoundedGridRange6D_get_has_index(self, v)
8880 def get_minimum_extended_index(self):
8881 r"""get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8882 return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)
8884 def get_maximum_extended_index(self):
8885 r"""get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8886 return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)
8889 r"""__str__(BoundedGridRange6D self) -> std::string"""
8890 return _IMP_algebra.BoundedGridRange6D___str__(self)
8893 r"""__repr__(BoundedGridRange6D self) -> std::string"""
8894 return _IMP_algebra.BoundedGridRange6D___repr__(self)
8896 def __cmp__(self, arg2):
8897 r"""__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
8898 return _IMP_algebra.BoundedGridRange6D___cmp__(self, arg2)
8900 def __eq__(self, arg2):
8901 r"""__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
8902 return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)
8904 def _get_as_binary(self):
8905 r"""_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
8906 return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)
8908 def _set_from_binary(self, p):
8909 r"""_set_from_binary(BoundedGridRange6D self, PyObject * p)"""
8910 return _IMP_algebra.BoundedGridRange6D__set_from_binary(self, p)
8912 def __getstate__(self):
8913 p = self._get_as_binary()
8914 if len(self.__dict__) > 1:
8915 d = self.__dict__.copy()
8920 def __setstate__(self, p):
8921 if not hasattr(self,
'this'):
8923 if isinstance(p, tuple):
8925 self.__dict__.update(d)
8926 return self._set_from_binary(p)
8928 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
8931 _IMP_algebra.BoundedGridRange6D_swigregister(BoundedGridRange6D)
8932 class BoundedGridRangeKD(object):
8933 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< -1 > class."""
8935 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8938 def get_is_bounded():
8939 r"""get_is_bounded() -> bool"""
8940 return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
8942 def __init__(self, *args):
8944 __init__(BoundedGridRangeKD self) -> BoundedGridRangeKD
8945 __init__(BoundedGridRangeKD self, IMP::Ints const & counts) -> BoundedGridRangeKD
8947 _IMP_algebra.BoundedGridRangeKD_swiginit(self, _IMP_algebra.new_BoundedGridRangeKD(*args))
8949 def get_number_of_voxels(self, *args):
8951 get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
8952 get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
8954 return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)
8956 def get_end_index(self):
8957 r"""get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8958 return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)
8960 def show(self, *args):
8961 r"""show(BoundedGridRangeKD self, _ostream out=std::cout)"""
8962 return _IMP_algebra.BoundedGridRangeKD_show(self, *args)
8964 def get_all_indexes(self):
8965 r"""get_all_indexes(BoundedGridRangeKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8966 return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)
8969 r"""get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8970 return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, lb, ub)
8972 def get_extended_indexes(self, lb, ub):
8973 r"""get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
8974 return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, lb, ub)
8977 r"""get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
8978 return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)
8980 def get_has_index(self, v):
8981 r"""get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
8982 return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, v)
8984 def get_minimum_extended_index(self):
8985 r"""get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8986 return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)
8988 def get_maximum_extended_index(self):
8989 r"""get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8990 return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)
8993 r"""__str__(BoundedGridRangeKD self) -> std::string"""
8994 return _IMP_algebra.BoundedGridRangeKD___str__(self)
8997 r"""__repr__(BoundedGridRangeKD self) -> std::string"""
8998 return _IMP_algebra.BoundedGridRangeKD___repr__(self)
9000 def __cmp__(self, arg2):
9001 r"""__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
9002 return _IMP_algebra.BoundedGridRangeKD___cmp__(self, arg2)
9004 def __eq__(self, arg2):
9005 r"""__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
9006 return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)
9008 def _get_as_binary(self):
9009 r"""_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
9010 return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)
9012 def _set_from_binary(self, p):
9013 r"""_set_from_binary(BoundedGridRangeKD self, PyObject * p)"""
9014 return _IMP_algebra.BoundedGridRangeKD__set_from_binary(self, p)
9016 def __getstate__(self):
9017 p = self._get_as_binary()
9018 if len(self.__dict__) > 1:
9019 d = self.__dict__.copy()
9024 def __setstate__(self, p):
9025 if not hasattr(self,
'this'):
9027 if isinstance(p, tuple):
9029 self.__dict__.update(d)
9030 return self._set_from_binary(p)
9032 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
9035 _IMP_algebra.BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
9036 class UnboundedGridRange1D(object):
9037 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 1 > class."""
9039 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9041 def __init__(self, *args):
9043 __init__(UnboundedGridRange1D self) -> UnboundedGridRange1D
9044 __init__(UnboundedGridRange1D self, IMP::Ints const & arg2) -> UnboundedGridRange1D
9046 _IMP_algebra.UnboundedGridRange1D_swiginit(self, _IMP_algebra.new_UnboundedGridRange1D(*args))
9048 def set_number_of_voxels(self, arg2):
9049 r"""set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
9050 return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, arg2)
9052 def get_number_of_voxels(self, arg2):
9053 r"""get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
9054 return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, arg2)
9057 def get_is_bounded():
9058 r"""get_is_bounded() -> bool"""
9059 return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
9061 def get_has_index(self, arg2):
9062 r"""get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
9063 return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, arg2)
9065 def show(self, *args):
9066 r"""show(UnboundedGridRange1D self, _ostream out=std::cout)"""
9067 return _IMP_algebra.UnboundedGridRange1D_show(self, *args)
9069 def get_extended_indexes(self, lb, ub):
9070 r"""get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
9071 return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, lb, ub)
9074 r"""__str__(UnboundedGridRange1D self) -> std::string"""
9075 return _IMP_algebra.UnboundedGridRange1D___str__(self)
9078 r"""__repr__(UnboundedGridRange1D self) -> std::string"""
9079 return _IMP_algebra.UnboundedGridRange1D___repr__(self)
9081 def __cmp__(self, arg2):
9082 r"""__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
9083 return _IMP_algebra.UnboundedGridRange1D___cmp__(self, arg2)
9085 def __eq__(self, arg2):
9086 r"""__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
9087 return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)
9089 def _get_as_binary(self):
9090 r"""_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
9091 return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)
9093 def _set_from_binary(self, p):
9094 r"""_set_from_binary(UnboundedGridRange1D self, PyObject * p)"""
9095 return _IMP_algebra.UnboundedGridRange1D__set_from_binary(self, p)
9097 def __getstate__(self):
9098 p = self._get_as_binary()
9099 if len(self.__dict__) > 1:
9100 d = self.__dict__.copy()
9105 def __setstate__(self, p):
9106 if not hasattr(self,
'this'):
9108 if isinstance(p, tuple):
9110 self.__dict__.update(d)
9111 return self._set_from_binary(p)
9113 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
9116 _IMP_algebra.UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
9117 class UnboundedGridRange2D(object):
9118 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 2 > class."""
9120 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9122 def __init__(self, *args):
9124 __init__(UnboundedGridRange2D self) -> UnboundedGridRange2D
9125 __init__(UnboundedGridRange2D self, IMP::Ints const & arg2) -> UnboundedGridRange2D
9127 _IMP_algebra.UnboundedGridRange2D_swiginit(self, _IMP_algebra.new_UnboundedGridRange2D(*args))
9129 def set_number_of_voxels(self, arg2):
9130 r"""set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
9131 return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, arg2)
9133 def get_number_of_voxels(self, arg2):
9134 r"""get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
9135 return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, arg2)
9138 def get_is_bounded():
9139 r"""get_is_bounded() -> bool"""
9140 return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
9142 def get_has_index(self, arg2):
9143 r"""get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
9144 return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, arg2)
9146 def show(self, *args):
9147 r"""show(UnboundedGridRange2D self, _ostream out=std::cout)"""
9148 return _IMP_algebra.UnboundedGridRange2D_show(self, *args)
9150 def get_extended_indexes(self, lb, ub):
9151 r"""get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
9152 return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, lb, ub)
9155 r"""__str__(UnboundedGridRange2D self) -> std::string"""
9156 return _IMP_algebra.UnboundedGridRange2D___str__(self)
9159 r"""__repr__(UnboundedGridRange2D self) -> std::string"""
9160 return _IMP_algebra.UnboundedGridRange2D___repr__(self)
9162 def __cmp__(self, arg2):
9163 r"""__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
9164 return _IMP_algebra.UnboundedGridRange2D___cmp__(self, arg2)
9166 def __eq__(self, arg2):
9167 r"""__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
9168 return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)
9170 def _get_as_binary(self):
9171 r"""_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
9172 return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)
9174 def _set_from_binary(self, p):
9175 r"""_set_from_binary(UnboundedGridRange2D self, PyObject * p)"""
9176 return _IMP_algebra.UnboundedGridRange2D__set_from_binary(self, p)
9178 def __getstate__(self):
9179 p = self._get_as_binary()
9180 if len(self.__dict__) > 1:
9181 d = self.__dict__.copy()
9186 def __setstate__(self, p):
9187 if not hasattr(self,
'this'):
9189 if isinstance(p, tuple):
9191 self.__dict__.update(d)
9192 return self._set_from_binary(p)
9194 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
9197 _IMP_algebra.UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
9198 class UnboundedGridRange3D(object):
9199 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 3 > class."""
9201 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9203 def __init__(self, *args):
9205 __init__(UnboundedGridRange3D self) -> UnboundedGridRange3D
9206 __init__(UnboundedGridRange3D self, IMP::Ints const & arg2) -> UnboundedGridRange3D
9208 _IMP_algebra.UnboundedGridRange3D_swiginit(self, _IMP_algebra.new_UnboundedGridRange3D(*args))
9210 def set_number_of_voxels(self, arg2):
9211 r"""set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
9212 return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, arg2)
9214 def get_number_of_voxels(self, arg2):
9215 r"""get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
9216 return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, arg2)
9219 def get_is_bounded():
9220 r"""get_is_bounded() -> bool"""
9221 return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
9223 def get_has_index(self, arg2):
9224 r"""get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
9225 return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, arg2)
9227 def show(self, *args):
9228 r"""show(UnboundedGridRange3D self, _ostream out=std::cout)"""
9229 return _IMP_algebra.UnboundedGridRange3D_show(self, *args)
9231 def get_extended_indexes(self, lb, ub):
9232 r"""get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
9233 return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, lb, ub)
9236 r"""__str__(UnboundedGridRange3D self) -> std::string"""
9237 return _IMP_algebra.UnboundedGridRange3D___str__(self)
9240 r"""__repr__(UnboundedGridRange3D self) -> std::string"""
9241 return _IMP_algebra.UnboundedGridRange3D___repr__(self)
9243 def __cmp__(self, arg2):
9244 r"""__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
9245 return _IMP_algebra.UnboundedGridRange3D___cmp__(self, arg2)
9247 def __eq__(self, arg2):
9248 r"""__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
9249 return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)
9251 def _get_as_binary(self):
9252 r"""_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
9253 return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)
9255 def _set_from_binary(self, p):
9256 r"""_set_from_binary(UnboundedGridRange3D self, PyObject * p)"""
9257 return _IMP_algebra.UnboundedGridRange3D__set_from_binary(self, p)
9259 def __getstate__(self):
9260 p = self._get_as_binary()
9261 if len(self.__dict__) > 1:
9262 d = self.__dict__.copy()
9267 def __setstate__(self, p):
9268 if not hasattr(self,
'this'):
9270 if isinstance(p, tuple):
9272 self.__dict__.update(d)
9273 return self._set_from_binary(p)
9275 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
9278 _IMP_algebra.UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
9279 class UnboundedGridRange4D(object):
9280 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 4 > class."""
9282 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9284 def __init__(self, *args):
9286 __init__(UnboundedGridRange4D self) -> UnboundedGridRange4D
9287 __init__(UnboundedGridRange4D self, IMP::Ints const & arg2) -> UnboundedGridRange4D
9289 _IMP_algebra.UnboundedGridRange4D_swiginit(self, _IMP_algebra.new_UnboundedGridRange4D(*args))
9291 def set_number_of_voxels(self, arg2):
9292 r"""set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
9293 return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, arg2)
9295 def get_number_of_voxels(self, arg2):
9296 r"""get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
9297 return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, arg2)
9300 def get_is_bounded():
9301 r"""get_is_bounded() -> bool"""
9302 return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
9304 def get_has_index(self, arg2):
9305 r"""get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
9306 return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, arg2)
9308 def show(self, *args):
9309 r"""show(UnboundedGridRange4D self, _ostream out=std::cout)"""
9310 return _IMP_algebra.UnboundedGridRange4D_show(self, *args)
9312 def get_extended_indexes(self, lb, ub):
9313 r"""get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
9314 return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, lb, ub)
9317 r"""__str__(UnboundedGridRange4D self) -> std::string"""
9318 return _IMP_algebra.UnboundedGridRange4D___str__(self)
9321 r"""__repr__(UnboundedGridRange4D self) -> std::string"""
9322 return _IMP_algebra.UnboundedGridRange4D___repr__(self)
9324 def __cmp__(self, arg2):
9325 r"""__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
9326 return _IMP_algebra.UnboundedGridRange4D___cmp__(self, arg2)
9328 def __eq__(self, arg2):
9329 r"""__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
9330 return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)
9332 def _get_as_binary(self):
9333 r"""_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
9334 return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)
9336 def _set_from_binary(self, p):
9337 r"""_set_from_binary(UnboundedGridRange4D self, PyObject * p)"""
9338 return _IMP_algebra.UnboundedGridRange4D__set_from_binary(self, p)
9340 def __getstate__(self):
9341 p = self._get_as_binary()
9342 if len(self.__dict__) > 1:
9343 d = self.__dict__.copy()
9348 def __setstate__(self, p):
9349 if not hasattr(self,
'this'):
9351 if isinstance(p, tuple):
9353 self.__dict__.update(d)
9354 return self._set_from_binary(p)
9356 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
9359 _IMP_algebra.UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
9360 class UnboundedGridRange5D(object):
9361 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 5 > class."""
9363 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9365 def __init__(self, *args):
9367 __init__(UnboundedGridRange5D self) -> UnboundedGridRange5D
9368 __init__(UnboundedGridRange5D self, IMP::Ints const & arg2) -> UnboundedGridRange5D
9370 _IMP_algebra.UnboundedGridRange5D_swiginit(self, _IMP_algebra.new_UnboundedGridRange5D(*args))
9372 def set_number_of_voxels(self, arg2):
9373 r"""set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
9374 return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, arg2)
9376 def get_number_of_voxels(self, arg2):
9377 r"""get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
9378 return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, arg2)
9381 def get_is_bounded():
9382 r"""get_is_bounded() -> bool"""
9383 return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
9385 def get_has_index(self, arg2):
9386 r"""get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
9387 return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, arg2)
9389 def show(self, *args):
9390 r"""show(UnboundedGridRange5D self, _ostream out=std::cout)"""
9391 return _IMP_algebra.UnboundedGridRange5D_show(self, *args)
9393 def get_extended_indexes(self, lb, ub):
9394 r"""get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
9395 return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, lb, ub)
9398 r"""__str__(UnboundedGridRange5D self) -> std::string"""
9399 return _IMP_algebra.UnboundedGridRange5D___str__(self)
9402 r"""__repr__(UnboundedGridRange5D self) -> std::string"""
9403 return _IMP_algebra.UnboundedGridRange5D___repr__(self)
9405 def __cmp__(self, arg2):
9406 r"""__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
9407 return _IMP_algebra.UnboundedGridRange5D___cmp__(self, arg2)
9409 def __eq__(self, arg2):
9410 r"""__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
9411 return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)
9413 def _get_as_binary(self):
9414 r"""_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
9415 return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)
9417 def _set_from_binary(self, p):
9418 r"""_set_from_binary(UnboundedGridRange5D self, PyObject * p)"""
9419 return _IMP_algebra.UnboundedGridRange5D__set_from_binary(self, p)
9421 def __getstate__(self):
9422 p = self._get_as_binary()
9423 if len(self.__dict__) > 1:
9424 d = self.__dict__.copy()
9429 def __setstate__(self, p):
9430 if not hasattr(self,
'this'):
9432 if isinstance(p, tuple):
9434 self.__dict__.update(d)
9435 return self._set_from_binary(p)
9437 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
9440 _IMP_algebra.UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
9441 class UnboundedGridRange6D(object):
9442 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 6 > class."""
9444 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9446 def __init__(self, *args):
9448 __init__(UnboundedGridRange6D self) -> UnboundedGridRange6D
9449 __init__(UnboundedGridRange6D self, IMP::Ints const & arg2) -> UnboundedGridRange6D
9451 _IMP_algebra.UnboundedGridRange6D_swiginit(self, _IMP_algebra.new_UnboundedGridRange6D(*args))
9453 def set_number_of_voxels(self, arg2):
9454 r"""set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
9455 return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, arg2)
9457 def get_number_of_voxels(self, arg2):
9458 r"""get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
9459 return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, arg2)
9462 def get_is_bounded():
9463 r"""get_is_bounded() -> bool"""
9464 return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
9466 def get_has_index(self, arg2):
9467 r"""get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
9468 return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, arg2)
9470 def show(self, *args):
9471 r"""show(UnboundedGridRange6D self, _ostream out=std::cout)"""
9472 return _IMP_algebra.UnboundedGridRange6D_show(self, *args)
9474 def get_extended_indexes(self, lb, ub):
9475 r"""get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
9476 return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, lb, ub)
9479 r"""__str__(UnboundedGridRange6D self) -> std::string"""
9480 return _IMP_algebra.UnboundedGridRange6D___str__(self)
9483 r"""__repr__(UnboundedGridRange6D self) -> std::string"""
9484 return _IMP_algebra.UnboundedGridRange6D___repr__(self)
9486 def __cmp__(self, arg2):
9487 r"""__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
9488 return _IMP_algebra.UnboundedGridRange6D___cmp__(self, arg2)
9490 def __eq__(self, arg2):
9491 r"""__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
9492 return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)
9494 def _get_as_binary(self):
9495 r"""_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
9496 return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)
9498 def _set_from_binary(self, p):
9499 r"""_set_from_binary(UnboundedGridRange6D self, PyObject * p)"""
9500 return _IMP_algebra.UnboundedGridRange6D__set_from_binary(self, p)
9502 def __getstate__(self):
9503 p = self._get_as_binary()
9504 if len(self.__dict__) > 1:
9505 d = self.__dict__.copy()
9510 def __setstate__(self, p):
9511 if not hasattr(self,
'this'):
9513 if isinstance(p, tuple):
9515 self.__dict__.update(d)
9516 return self._set_from_binary(p)
9518 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
9521 _IMP_algebra.UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
9522 class UnboundedGridRangeKD(object):
9523 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< -1 > class."""
9525 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9527 def __init__(self, *args):
9529 __init__(UnboundedGridRangeKD self) -> UnboundedGridRangeKD
9530 __init__(UnboundedGridRangeKD self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
9532 _IMP_algebra.UnboundedGridRangeKD_swiginit(self, _IMP_algebra.new_UnboundedGridRangeKD(*args))
9534 def set_number_of_voxels(self, arg2):
9535 r"""set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
9536 return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, arg2)
9538 def get_number_of_voxels(self, arg2):
9539 r"""get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
9540 return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, arg2)
9543 def get_is_bounded():
9544 r"""get_is_bounded() -> bool"""
9545 return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
9547 def get_has_index(self, arg2):
9548 r"""get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
9549 return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, arg2)
9551 def show(self, *args):
9552 r"""show(UnboundedGridRangeKD self, _ostream out=std::cout)"""
9553 return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)
9555 def get_extended_indexes(self, lb, ub):
9556 r"""get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
9557 return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, lb, ub)
9560 r"""__str__(UnboundedGridRangeKD self) -> std::string"""
9561 return _IMP_algebra.UnboundedGridRangeKD___str__(self)
9564 r"""__repr__(UnboundedGridRangeKD self) -> std::string"""
9565 return _IMP_algebra.UnboundedGridRangeKD___repr__(self)
9567 def __cmp__(self, arg2):
9568 r"""__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
9569 return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, arg2)
9571 def __eq__(self, arg2):
9572 r"""__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
9573 return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)
9575 def _get_as_binary(self):
9576 r"""_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
9577 return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)
9579 def _set_from_binary(self, p):
9580 r"""_set_from_binary(UnboundedGridRangeKD self, PyObject * p)"""
9581 return _IMP_algebra.UnboundedGridRangeKD__set_from_binary(self, p)
9583 def __getstate__(self):
9584 p = self._get_as_binary()
9585 if len(self.__dict__) > 1:
9586 d = self.__dict__.copy()
9591 def __setstate__(self, p):
9592 if not hasattr(self,
'this'):
9594 if isinstance(p, tuple):
9596 self.__dict__.update(d)
9597 return self._set_from_binary(p)
9599 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
9602 _IMP_algebra.UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
9603 class DefaultEmbedding1D(object):
9604 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 1 > class."""
9606 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9608 def __init__(self, *args):
9610 __init__(DefaultEmbedding1D self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
9611 __init__(DefaultEmbedding1D self) -> DefaultEmbedding1D
9613 _IMP_algebra.DefaultEmbedding1D_swiginit(self, _IMP_algebra.new_DefaultEmbedding1D(*args))
9615 def set_origin(self, o):
9616 r"""set_origin(DefaultEmbedding1D self, Vector1D o)"""
9617 return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)
9619 def get_origin(self):
9620 r"""get_origin(DefaultEmbedding1D self) -> Vector1D"""
9621 return _IMP_algebra.DefaultEmbedding1D_get_origin(self)
9623 def get_dimension(self):
9624 r"""get_dimension(DefaultEmbedding1D self) -> unsigned int"""
9625 return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)
9627 def set_unit_cell(self, o):
9628 r"""set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
9629 return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, o)
9631 def get_inverse_unit_cell(self):
9632 r"""get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9633 return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)
9635 def get_unit_cell(self):
9636 r"""get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9637 return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)
9639 def get_extended_index(self, o):
9640 r"""get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
9641 return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, o)
9644 r"""get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
9645 return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)
9647 def get_center(self, *args):
9649 get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
9650 get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
9652 return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)
9654 def get_bounding_box(self, *args):
9656 get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
9657 get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
9659 return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)
9661 def show(self, *args):
9662 r"""show(DefaultEmbedding1D self, _ostream out=std::cout)"""
9663 return _IMP_algebra.DefaultEmbedding1D_show(self, *args)
9666 r"""__str__(DefaultEmbedding1D self) -> std::string"""
9667 return _IMP_algebra.DefaultEmbedding1D___str__(self)
9670 r"""__repr__(DefaultEmbedding1D self) -> std::string"""
9671 return _IMP_algebra.DefaultEmbedding1D___repr__(self)
9673 def __cmp__(self, arg2):
9674 r"""__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
9675 return _IMP_algebra.DefaultEmbedding1D___cmp__(self, arg2)
9677 def __eq__(self, arg2):
9678 r"""__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
9679 return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)
9681 def _get_as_binary(self):
9682 r"""_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
9683 return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)
9685 def _set_from_binary(self, p):
9686 r"""_set_from_binary(DefaultEmbedding1D self, PyObject * p)"""
9687 return _IMP_algebra.DefaultEmbedding1D__set_from_binary(self, p)
9689 def __getstate__(self):
9690 p = self._get_as_binary()
9691 if len(self.__dict__) > 1:
9692 d = self.__dict__.copy()
9697 def __setstate__(self, p):
9698 if not hasattr(self,
'this'):
9700 if isinstance(p, tuple):
9702 self.__dict__.update(d)
9703 return self._set_from_binary(p)
9705 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
9708 _IMP_algebra.DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
9709 class DefaultEmbedding2D(object):
9710 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 2 > class."""
9712 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9714 def __init__(self, *args):
9716 __init__(DefaultEmbedding2D self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
9717 __init__(DefaultEmbedding2D self) -> DefaultEmbedding2D
9719 _IMP_algebra.DefaultEmbedding2D_swiginit(self, _IMP_algebra.new_DefaultEmbedding2D(*args))
9721 def set_origin(self, o):
9722 r"""set_origin(DefaultEmbedding2D self, Vector2D o)"""
9723 return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)
9725 def get_origin(self):
9726 r"""get_origin(DefaultEmbedding2D self) -> Vector2D"""
9727 return _IMP_algebra.DefaultEmbedding2D_get_origin(self)
9729 def get_dimension(self):
9730 r"""get_dimension(DefaultEmbedding2D self) -> unsigned int"""
9731 return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)
9733 def set_unit_cell(self, o):
9734 r"""set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
9735 return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, o)
9737 def get_inverse_unit_cell(self):
9738 r"""get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9739 return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)
9741 def get_unit_cell(self):
9742 r"""get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9743 return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)
9745 def get_extended_index(self, o):
9746 r"""get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
9747 return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, o)
9750 r"""get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
9751 return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)
9753 def get_center(self, *args):
9755 get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
9756 get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
9758 return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)
9760 def get_bounding_box(self, *args):
9762 get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
9763 get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
9765 return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)
9767 def show(self, *args):
9768 r"""show(DefaultEmbedding2D self, _ostream out=std::cout)"""
9769 return _IMP_algebra.DefaultEmbedding2D_show(self, *args)
9772 r"""__str__(DefaultEmbedding2D self) -> std::string"""
9773 return _IMP_algebra.DefaultEmbedding2D___str__(self)
9776 r"""__repr__(DefaultEmbedding2D self) -> std::string"""
9777 return _IMP_algebra.DefaultEmbedding2D___repr__(self)
9779 def __cmp__(self, arg2):
9780 r"""__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
9781 return _IMP_algebra.DefaultEmbedding2D___cmp__(self, arg2)
9783 def __eq__(self, arg2):
9784 r"""__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
9785 return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)
9787 def _get_as_binary(self):
9788 r"""_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
9789 return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)
9791 def _set_from_binary(self, p):
9792 r"""_set_from_binary(DefaultEmbedding2D self, PyObject * p)"""
9793 return _IMP_algebra.DefaultEmbedding2D__set_from_binary(self, p)
9795 def __getstate__(self):
9796 p = self._get_as_binary()
9797 if len(self.__dict__) > 1:
9798 d = self.__dict__.copy()
9803 def __setstate__(self, p):
9804 if not hasattr(self,
'this'):
9806 if isinstance(p, tuple):
9808 self.__dict__.update(d)
9809 return self._set_from_binary(p)
9811 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
9814 _IMP_algebra.DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
9815 class DefaultEmbedding3D(object):
9816 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 3 > class."""
9818 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9820 def __init__(self, *args):
9822 __init__(DefaultEmbedding3D self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
9823 __init__(DefaultEmbedding3D self) -> DefaultEmbedding3D
9825 _IMP_algebra.DefaultEmbedding3D_swiginit(self, _IMP_algebra.new_DefaultEmbedding3D(*args))
9827 def set_origin(self, o):
9828 r"""set_origin(DefaultEmbedding3D self, Vector3D o)"""
9829 return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)
9831 def get_origin(self):
9832 r"""get_origin(DefaultEmbedding3D self) -> Vector3D"""
9833 return _IMP_algebra.DefaultEmbedding3D_get_origin(self)
9835 def get_dimension(self):
9836 r"""get_dimension(DefaultEmbedding3D self) -> unsigned int"""
9837 return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)
9839 def set_unit_cell(self, o):
9840 r"""set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
9841 return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, o)
9843 def get_inverse_unit_cell(self):
9844 r"""get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9845 return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)
9847 def get_unit_cell(self):
9848 r"""get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9849 return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)
9851 def get_extended_index(self, o):
9852 r"""get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
9853 return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, o)
9856 r"""get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
9857 return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)
9859 def get_center(self, *args):
9861 get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
9862 get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
9864 return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)
9866 def get_bounding_box(self, *args):
9868 get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
9869 get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
9871 return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)
9873 def show(self, *args):
9874 r"""show(DefaultEmbedding3D self, _ostream out=std::cout)"""
9875 return _IMP_algebra.DefaultEmbedding3D_show(self, *args)
9878 r"""__str__(DefaultEmbedding3D self) -> std::string"""
9879 return _IMP_algebra.DefaultEmbedding3D___str__(self)
9882 r"""__repr__(DefaultEmbedding3D self) -> std::string"""
9883 return _IMP_algebra.DefaultEmbedding3D___repr__(self)
9885 def __cmp__(self, arg2):
9886 r"""__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
9887 return _IMP_algebra.DefaultEmbedding3D___cmp__(self, arg2)
9889 def __eq__(self, arg2):
9890 r"""__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
9891 return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)
9893 def _get_as_binary(self):
9894 r"""_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
9895 return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)
9897 def _set_from_binary(self, p):
9898 r"""_set_from_binary(DefaultEmbedding3D self, PyObject * p)"""
9899 return _IMP_algebra.DefaultEmbedding3D__set_from_binary(self, p)
9901 def __getstate__(self):
9902 p = self._get_as_binary()
9903 if len(self.__dict__) > 1:
9904 d = self.__dict__.copy()
9909 def __setstate__(self, p):
9910 if not hasattr(self,
'this'):
9912 if isinstance(p, tuple):
9914 self.__dict__.update(d)
9915 return self._set_from_binary(p)
9917 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
9920 _IMP_algebra.DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
9921 class DefaultEmbedding4D(object):
9922 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 4 > class."""
9924 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9926 def __init__(self, *args):
9928 __init__(DefaultEmbedding4D self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
9929 __init__(DefaultEmbedding4D self) -> DefaultEmbedding4D
9931 _IMP_algebra.DefaultEmbedding4D_swiginit(self, _IMP_algebra.new_DefaultEmbedding4D(*args))
9933 def set_origin(self, o):
9934 r"""set_origin(DefaultEmbedding4D self, Vector4D o)"""
9935 return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)
9937 def get_origin(self):
9938 r"""get_origin(DefaultEmbedding4D self) -> Vector4D"""
9939 return _IMP_algebra.DefaultEmbedding4D_get_origin(self)
9941 def get_dimension(self):
9942 r"""get_dimension(DefaultEmbedding4D self) -> unsigned int"""
9943 return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)
9945 def set_unit_cell(self, o):
9946 r"""set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
9947 return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, o)
9949 def get_inverse_unit_cell(self):
9950 r"""get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9951 return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)
9953 def get_unit_cell(self):
9954 r"""get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9955 return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)
9957 def get_extended_index(self, o):
9958 r"""get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
9959 return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, o)
9962 r"""get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
9963 return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)
9965 def get_center(self, *args):
9967 get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
9968 get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
9970 return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)
9972 def get_bounding_box(self, *args):
9974 get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
9975 get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
9977 return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)
9979 def show(self, *args):
9980 r"""show(DefaultEmbedding4D self, _ostream out=std::cout)"""
9981 return _IMP_algebra.DefaultEmbedding4D_show(self, *args)
9984 r"""__str__(DefaultEmbedding4D self) -> std::string"""
9985 return _IMP_algebra.DefaultEmbedding4D___str__(self)
9988 r"""__repr__(DefaultEmbedding4D self) -> std::string"""
9989 return _IMP_algebra.DefaultEmbedding4D___repr__(self)
9991 def __cmp__(self, arg2):
9992 r"""__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
9993 return _IMP_algebra.DefaultEmbedding4D___cmp__(self, arg2)
9995 def __eq__(self, arg2):
9996 r"""__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
9997 return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)
9999 def _get_as_binary(self):
10000 r"""_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
10001 return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)
10003 def _set_from_binary(self, p):
10004 r"""_set_from_binary(DefaultEmbedding4D self, PyObject * p)"""
10005 return _IMP_algebra.DefaultEmbedding4D__set_from_binary(self, p)
10007 def __getstate__(self):
10008 p = self._get_as_binary()
10009 if len(self.__dict__) > 1:
10010 d = self.__dict__.copy()
10015 def __setstate__(self, p):
10016 if not hasattr(self,
'this'):
10018 if isinstance(p, tuple):
10020 self.__dict__.update(d)
10021 return self._set_from_binary(p)
10023 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
10026 _IMP_algebra.DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
10027 class DefaultEmbedding5D(object):
10028 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 5 > class."""
10030 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10032 def __init__(self, *args):
10034 __init__(DefaultEmbedding5D self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
10035 __init__(DefaultEmbedding5D self) -> DefaultEmbedding5D
10037 _IMP_algebra.DefaultEmbedding5D_swiginit(self, _IMP_algebra.new_DefaultEmbedding5D(*args))
10039 def set_origin(self, o):
10040 r"""set_origin(DefaultEmbedding5D self, Vector5D o)"""
10041 return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)
10043 def get_origin(self):
10044 r"""get_origin(DefaultEmbedding5D self) -> Vector5D"""
10045 return _IMP_algebra.DefaultEmbedding5D_get_origin(self)
10047 def get_dimension(self):
10048 r"""get_dimension(DefaultEmbedding5D self) -> unsigned int"""
10049 return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)
10051 def set_unit_cell(self, o):
10052 r"""set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
10053 return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, o)
10055 def get_inverse_unit_cell(self):
10056 r"""get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10057 return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)
10059 def get_unit_cell(self):
10060 r"""get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10061 return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)
10063 def get_extended_index(self, o):
10064 r"""get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10065 return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, o)
10068 r"""get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
10069 return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)
10071 def get_center(self, *args):
10073 get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10074 get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
10076 return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)
10078 def get_bounding_box(self, *args):
10080 get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10081 get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10083 return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)
10085 def show(self, *args):
10086 r"""show(DefaultEmbedding5D self, _ostream out=std::cout)"""
10087 return _IMP_algebra.DefaultEmbedding5D_show(self, *args)
10090 r"""__str__(DefaultEmbedding5D self) -> std::string"""
10091 return _IMP_algebra.DefaultEmbedding5D___str__(self)
10093 def __repr__(self):
10094 r"""__repr__(DefaultEmbedding5D self) -> std::string"""
10095 return _IMP_algebra.DefaultEmbedding5D___repr__(self)
10097 def __cmp__(self, arg2):
10098 r"""__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
10099 return _IMP_algebra.DefaultEmbedding5D___cmp__(self, arg2)
10101 def __eq__(self, arg2):
10102 r"""__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
10103 return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)
10105 def _get_as_binary(self):
10106 r"""_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
10107 return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)
10109 def _set_from_binary(self, p):
10110 r"""_set_from_binary(DefaultEmbedding5D self, PyObject * p)"""
10111 return _IMP_algebra.DefaultEmbedding5D__set_from_binary(self, p)
10113 def __getstate__(self):
10114 p = self._get_as_binary()
10115 if len(self.__dict__) > 1:
10116 d = self.__dict__.copy()
10121 def __setstate__(self, p):
10122 if not hasattr(self,
'this'):
10124 if isinstance(p, tuple):
10126 self.__dict__.update(d)
10127 return self._set_from_binary(p)
10129 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
10132 _IMP_algebra.DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
10133 class DefaultEmbedding6D(object):
10134 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 6 > class."""
10136 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10138 def __init__(self, *args):
10140 __init__(DefaultEmbedding6D self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
10141 __init__(DefaultEmbedding6D self) -> DefaultEmbedding6D
10143 _IMP_algebra.DefaultEmbedding6D_swiginit(self, _IMP_algebra.new_DefaultEmbedding6D(*args))
10145 def set_origin(self, o):
10146 r"""set_origin(DefaultEmbedding6D self, Vector6D o)"""
10147 return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)
10149 def get_origin(self):
10150 r"""get_origin(DefaultEmbedding6D self) -> Vector6D"""
10151 return _IMP_algebra.DefaultEmbedding6D_get_origin(self)
10153 def get_dimension(self):
10154 r"""get_dimension(DefaultEmbedding6D self) -> unsigned int"""
10155 return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)
10157 def set_unit_cell(self, o):
10158 r"""set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
10159 return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, o)
10161 def get_inverse_unit_cell(self):
10162 r"""get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10163 return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)
10165 def get_unit_cell(self):
10166 r"""get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10167 return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)
10169 def get_extended_index(self, o):
10170 r"""get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10171 return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, o)
10174 r"""get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
10175 return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)
10177 def get_center(self, *args):
10179 get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10180 get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
10182 return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)
10184 def get_bounding_box(self, *args):
10186 get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10187 get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10189 return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)
10191 def show(self, *args):
10192 r"""show(DefaultEmbedding6D self, _ostream out=std::cout)"""
10193 return _IMP_algebra.DefaultEmbedding6D_show(self, *args)
10196 r"""__str__(DefaultEmbedding6D self) -> std::string"""
10197 return _IMP_algebra.DefaultEmbedding6D___str__(self)
10199 def __repr__(self):
10200 r"""__repr__(DefaultEmbedding6D self) -> std::string"""
10201 return _IMP_algebra.DefaultEmbedding6D___repr__(self)
10203 def __cmp__(self, arg2):
10204 r"""__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
10205 return _IMP_algebra.DefaultEmbedding6D___cmp__(self, arg2)
10207 def __eq__(self, arg2):
10208 r"""__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
10209 return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)
10211 def _get_as_binary(self):
10212 r"""_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
10213 return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)
10215 def _set_from_binary(self, p):
10216 r"""_set_from_binary(DefaultEmbedding6D self, PyObject * p)"""
10217 return _IMP_algebra.DefaultEmbedding6D__set_from_binary(self, p)
10219 def __getstate__(self):
10220 p = self._get_as_binary()
10221 if len(self.__dict__) > 1:
10222 d = self.__dict__.copy()
10227 def __setstate__(self, p):
10228 if not hasattr(self,
'this'):
10230 if isinstance(p, tuple):
10232 self.__dict__.update(d)
10233 return self._set_from_binary(p)
10235 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
10238 _IMP_algebra.DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
10239 class DefaultEmbeddingKD(object):
10240 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< -1 > class."""
10242 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10244 def __init__(self, *args):
10246 __init__(DefaultEmbeddingKD self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
10247 __init__(DefaultEmbeddingKD self) -> DefaultEmbeddingKD
10249 _IMP_algebra.DefaultEmbeddingKD_swiginit(self, _IMP_algebra.new_DefaultEmbeddingKD(*args))
10251 def set_origin(self, o):
10252 r"""set_origin(DefaultEmbeddingKD self, VectorKD o)"""
10253 return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)
10255 def get_origin(self):
10256 r"""get_origin(DefaultEmbeddingKD self) -> VectorKD"""
10257 return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)
10259 def get_dimension(self):
10260 r"""get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
10261 return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)
10263 def set_unit_cell(self, o):
10264 r"""set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
10265 return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, o)
10267 def get_inverse_unit_cell(self):
10268 r"""get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10269 return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)
10271 def get_unit_cell(self):
10272 r"""get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10273 return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)
10275 def get_extended_index(self, o):
10276 r"""get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
10277 return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, o)
10280 r"""get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
10281 return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)
10283 def get_center(self, *args):
10285 get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
10286 get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
10288 return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)
10290 def get_bounding_box(self, *args):
10292 get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
10293 get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
10295 return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)
10297 def show(self, *args):
10298 r"""show(DefaultEmbeddingKD self, _ostream out=std::cout)"""
10299 return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)
10302 r"""__str__(DefaultEmbeddingKD self) -> std::string"""
10303 return _IMP_algebra.DefaultEmbeddingKD___str__(self)
10305 def __repr__(self):
10306 r"""__repr__(DefaultEmbeddingKD self) -> std::string"""
10307 return _IMP_algebra.DefaultEmbeddingKD___repr__(self)
10309 def __cmp__(self, arg2):
10310 r"""__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
10311 return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, arg2)
10313 def __eq__(self, arg2):
10314 r"""__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
10315 return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)
10317 def _get_as_binary(self):
10318 r"""_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
10319 return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)
10321 def _set_from_binary(self, p):
10322 r"""_set_from_binary(DefaultEmbeddingKD self, PyObject * p)"""
10323 return _IMP_algebra.DefaultEmbeddingKD__set_from_binary(self, p)
10325 def __getstate__(self):
10326 p = self._get_as_binary()
10327 if len(self.__dict__) > 1:
10328 d = self.__dict__.copy()
10333 def __setstate__(self, p):
10334 if not hasattr(self,
'this'):
10336 if isinstance(p, tuple):
10338 self.__dict__.update(d)
10339 return self._set_from_binary(p)
10341 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
10344 _IMP_algebra.DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
10345 class LogEmbedding1D(object):
10346 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 1 > class."""
10348 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10350 def __init__(self, *args):
10352 __init__(LogEmbedding1D self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
10353 __init__(LogEmbedding1D self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
10354 __init__(LogEmbedding1D self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
10355 __init__(LogEmbedding1D self) -> LogEmbedding1D
10357 _IMP_algebra.LogEmbedding1D_swiginit(self, _IMP_algebra.new_LogEmbedding1D(*args))
10359 def set_origin(self, o):
10360 r"""set_origin(LogEmbedding1D self, Vector1D o)"""
10361 return _IMP_algebra.LogEmbedding1D_set_origin(self, o)
10363 def get_origin(self):
10364 r"""get_origin(LogEmbedding1D self) -> Vector1D"""
10365 return _IMP_algebra.LogEmbedding1D_get_origin(self)
10367 def get_dimension(self):
10368 r"""get_dimension(LogEmbedding1D self) -> unsigned int"""
10369 return _IMP_algebra.LogEmbedding1D_get_dimension(self)
10371 def set_unit_cell(self, *args):
10373 set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
10374 set_unit_cell(LogEmbedding1D self, Vector1D o)
10376 return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)
10378 def get_unit_cell(self):
10379 r"""get_unit_cell(LogEmbedding1D self) -> Vector1D"""
10380 return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)
10382 def get_extended_index(self, o):
10383 r"""get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
10384 return _IMP_algebra.LogEmbedding1D_get_extended_index(self, o)
10387 r"""get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
10388 return _IMP_algebra.LogEmbedding1D_get_index(self, o)
10390 def get_center(self, *args):
10392 get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
10393 get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
10395 return _IMP_algebra.LogEmbedding1D_get_center(self, *args)
10397 def get_bounding_box(self, *args):
10399 get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
10400 get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
10402 return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)
10404 def show(self, *args):
10405 r"""show(LogEmbedding1D self, _ostream out=std::cout)"""
10406 return _IMP_algebra.LogEmbedding1D_show(self, *args)
10409 r"""__str__(LogEmbedding1D self) -> std::string"""
10410 return _IMP_algebra.LogEmbedding1D___str__(self)
10412 def __repr__(self):
10413 r"""__repr__(LogEmbedding1D self) -> std::string"""
10414 return _IMP_algebra.LogEmbedding1D___repr__(self)
10416 def __cmp__(self, arg2):
10417 r"""__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
10418 return _IMP_algebra.LogEmbedding1D___cmp__(self, arg2)
10420 def __eq__(self, arg2):
10421 r"""__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
10422 return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)
10424 def _get_as_binary(self):
10425 r"""_get_as_binary(LogEmbedding1D self) -> PyObject *"""
10426 return _IMP_algebra.LogEmbedding1D__get_as_binary(self)
10428 def _set_from_binary(self, p):
10429 r"""_set_from_binary(LogEmbedding1D self, PyObject * p)"""
10430 return _IMP_algebra.LogEmbedding1D__set_from_binary(self, p)
10432 def __getstate__(self):
10433 p = self._get_as_binary()
10434 if len(self.__dict__) > 1:
10435 d = self.__dict__.copy()
10440 def __setstate__(self, p):
10441 if not hasattr(self,
'this'):
10443 if isinstance(p, tuple):
10445 self.__dict__.update(d)
10446 return self._set_from_binary(p)
10448 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
10451 _IMP_algebra.LogEmbedding1D_swigregister(LogEmbedding1D)
10452 class LogEmbedding2D(object):
10453 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 2 > class."""
10455 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10457 def __init__(self, *args):
10459 __init__(LogEmbedding2D self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
10460 __init__(LogEmbedding2D self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
10461 __init__(LogEmbedding2D self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
10462 __init__(LogEmbedding2D self) -> LogEmbedding2D
10464 _IMP_algebra.LogEmbedding2D_swiginit(self, _IMP_algebra.new_LogEmbedding2D(*args))
10466 def set_origin(self, o):
10467 r"""set_origin(LogEmbedding2D self, Vector2D o)"""
10468 return _IMP_algebra.LogEmbedding2D_set_origin(self, o)
10470 def get_origin(self):
10471 r"""get_origin(LogEmbedding2D self) -> Vector2D"""
10472 return _IMP_algebra.LogEmbedding2D_get_origin(self)
10474 def get_dimension(self):
10475 r"""get_dimension(LogEmbedding2D self) -> unsigned int"""
10476 return _IMP_algebra.LogEmbedding2D_get_dimension(self)
10478 def set_unit_cell(self, *args):
10480 set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
10481 set_unit_cell(LogEmbedding2D self, Vector2D o)
10483 return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)
10485 def get_unit_cell(self):
10486 r"""get_unit_cell(LogEmbedding2D self) -> Vector2D"""
10487 return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)
10489 def get_extended_index(self, o):
10490 r"""get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
10491 return _IMP_algebra.LogEmbedding2D_get_extended_index(self, o)
10494 r"""get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
10495 return _IMP_algebra.LogEmbedding2D_get_index(self, o)
10497 def get_center(self, *args):
10499 get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
10500 get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
10502 return _IMP_algebra.LogEmbedding2D_get_center(self, *args)
10504 def get_bounding_box(self, *args):
10506 get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
10507 get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
10509 return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)
10511 def show(self, *args):
10512 r"""show(LogEmbedding2D self, _ostream out=std::cout)"""
10513 return _IMP_algebra.LogEmbedding2D_show(self, *args)
10516 r"""__str__(LogEmbedding2D self) -> std::string"""
10517 return _IMP_algebra.LogEmbedding2D___str__(self)
10519 def __repr__(self):
10520 r"""__repr__(LogEmbedding2D self) -> std::string"""
10521 return _IMP_algebra.LogEmbedding2D___repr__(self)
10523 def __cmp__(self, arg2):
10524 r"""__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
10525 return _IMP_algebra.LogEmbedding2D___cmp__(self, arg2)
10527 def __eq__(self, arg2):
10528 r"""__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
10529 return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)
10531 def _get_as_binary(self):
10532 r"""_get_as_binary(LogEmbedding2D self) -> PyObject *"""
10533 return _IMP_algebra.LogEmbedding2D__get_as_binary(self)
10535 def _set_from_binary(self, p):
10536 r"""_set_from_binary(LogEmbedding2D self, PyObject * p)"""
10537 return _IMP_algebra.LogEmbedding2D__set_from_binary(self, p)
10539 def __getstate__(self):
10540 p = self._get_as_binary()
10541 if len(self.__dict__) > 1:
10542 d = self.__dict__.copy()
10547 def __setstate__(self, p):
10548 if not hasattr(self,
'this'):
10550 if isinstance(p, tuple):
10552 self.__dict__.update(d)
10553 return self._set_from_binary(p)
10555 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
10558 _IMP_algebra.LogEmbedding2D_swigregister(LogEmbedding2D)
10559 class LogEmbedding4D(object):
10560 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 4 > class."""
10562 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10564 def __init__(self, *args):
10566 __init__(LogEmbedding4D self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
10567 __init__(LogEmbedding4D self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
10568 __init__(LogEmbedding4D self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
10569 __init__(LogEmbedding4D self) -> LogEmbedding4D
10571 _IMP_algebra.LogEmbedding4D_swiginit(self, _IMP_algebra.new_LogEmbedding4D(*args))
10573 def set_origin(self, o):
10574 r"""set_origin(LogEmbedding4D self, Vector4D o)"""
10575 return _IMP_algebra.LogEmbedding4D_set_origin(self, o)
10577 def get_origin(self):
10578 r"""get_origin(LogEmbedding4D self) -> Vector4D"""
10579 return _IMP_algebra.LogEmbedding4D_get_origin(self)
10581 def get_dimension(self):
10582 r"""get_dimension(LogEmbedding4D self) -> unsigned int"""
10583 return _IMP_algebra.LogEmbedding4D_get_dimension(self)
10585 def set_unit_cell(self, *args):
10587 set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
10588 set_unit_cell(LogEmbedding4D self, Vector4D o)
10590 return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)
10592 def get_unit_cell(self):
10593 r"""get_unit_cell(LogEmbedding4D self) -> Vector4D"""
10594 return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)
10596 def get_extended_index(self, o):
10597 r"""get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
10598 return _IMP_algebra.LogEmbedding4D_get_extended_index(self, o)
10601 r"""get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
10602 return _IMP_algebra.LogEmbedding4D_get_index(self, o)
10604 def get_center(self, *args):
10606 get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
10607 get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
10609 return _IMP_algebra.LogEmbedding4D_get_center(self, *args)
10611 def get_bounding_box(self, *args):
10613 get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
10614 get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
10616 return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)
10618 def show(self, *args):
10619 r"""show(LogEmbedding4D self, _ostream out=std::cout)"""
10620 return _IMP_algebra.LogEmbedding4D_show(self, *args)
10623 r"""__str__(LogEmbedding4D self) -> std::string"""
10624 return _IMP_algebra.LogEmbedding4D___str__(self)
10626 def __repr__(self):
10627 r"""__repr__(LogEmbedding4D self) -> std::string"""
10628 return _IMP_algebra.LogEmbedding4D___repr__(self)
10630 def __cmp__(self, arg2):
10631 r"""__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
10632 return _IMP_algebra.LogEmbedding4D___cmp__(self, arg2)
10634 def __eq__(self, arg2):
10635 r"""__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
10636 return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)
10638 def _get_as_binary(self):
10639 r"""_get_as_binary(LogEmbedding4D self) -> PyObject *"""
10640 return _IMP_algebra.LogEmbedding4D__get_as_binary(self)
10642 def _set_from_binary(self, p):
10643 r"""_set_from_binary(LogEmbedding4D self, PyObject * p)"""
10644 return _IMP_algebra.LogEmbedding4D__set_from_binary(self, p)
10646 def __getstate__(self):
10647 p = self._get_as_binary()
10648 if len(self.__dict__) > 1:
10649 d = self.__dict__.copy()
10654 def __setstate__(self, p):
10655 if not hasattr(self,
'this'):
10657 if isinstance(p, tuple):
10659 self.__dict__.update(d)
10660 return self._set_from_binary(p)
10662 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
10665 _IMP_algebra.LogEmbedding4D_swigregister(LogEmbedding4D)
10666 class LogEmbedding5D(object):
10667 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 5 > class."""
10669 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10671 def __init__(self, *args):
10673 __init__(LogEmbedding5D self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
10674 __init__(LogEmbedding5D self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
10675 __init__(LogEmbedding5D self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
10676 __init__(LogEmbedding5D self) -> LogEmbedding5D
10678 _IMP_algebra.LogEmbedding5D_swiginit(self, _IMP_algebra.new_LogEmbedding5D(*args))
10680 def set_origin(self, o):
10681 r"""set_origin(LogEmbedding5D self, Vector5D o)"""
10682 return _IMP_algebra.LogEmbedding5D_set_origin(self, o)
10684 def get_origin(self):
10685 r"""get_origin(LogEmbedding5D self) -> Vector5D"""
10686 return _IMP_algebra.LogEmbedding5D_get_origin(self)
10688 def get_dimension(self):
10689 r"""get_dimension(LogEmbedding5D self) -> unsigned int"""
10690 return _IMP_algebra.LogEmbedding5D_get_dimension(self)
10692 def set_unit_cell(self, *args):
10694 set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
10695 set_unit_cell(LogEmbedding5D self, Vector5D o)
10697 return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)
10699 def get_unit_cell(self):
10700 r"""get_unit_cell(LogEmbedding5D self) -> Vector5D"""
10701 return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)
10703 def get_extended_index(self, o):
10704 r"""get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10705 return _IMP_algebra.LogEmbedding5D_get_extended_index(self, o)
10708 r"""get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
10709 return _IMP_algebra.LogEmbedding5D_get_index(self, o)
10711 def get_center(self, *args):
10713 get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10714 get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
10716 return _IMP_algebra.LogEmbedding5D_get_center(self, *args)
10718 def get_bounding_box(self, *args):
10720 get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10721 get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10723 return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)
10725 def show(self, *args):
10726 r"""show(LogEmbedding5D self, _ostream out=std::cout)"""
10727 return _IMP_algebra.LogEmbedding5D_show(self, *args)
10730 r"""__str__(LogEmbedding5D self) -> std::string"""
10731 return _IMP_algebra.LogEmbedding5D___str__(self)
10733 def __repr__(self):
10734 r"""__repr__(LogEmbedding5D self) -> std::string"""
10735 return _IMP_algebra.LogEmbedding5D___repr__(self)
10737 def __cmp__(self, arg2):
10738 r"""__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
10739 return _IMP_algebra.LogEmbedding5D___cmp__(self, arg2)
10741 def __eq__(self, arg2):
10742 r"""__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
10743 return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)
10745 def _get_as_binary(self):
10746 r"""_get_as_binary(LogEmbedding5D self) -> PyObject *"""
10747 return _IMP_algebra.LogEmbedding5D__get_as_binary(self)
10749 def _set_from_binary(self, p):
10750 r"""_set_from_binary(LogEmbedding5D self, PyObject * p)"""
10751 return _IMP_algebra.LogEmbedding5D__set_from_binary(self, p)
10753 def __getstate__(self):
10754 p = self._get_as_binary()
10755 if len(self.__dict__) > 1:
10756 d = self.__dict__.copy()
10761 def __setstate__(self, p):
10762 if not hasattr(self,
'this'):
10764 if isinstance(p, tuple):
10766 self.__dict__.update(d)
10767 return self._set_from_binary(p)
10769 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
10772 _IMP_algebra.LogEmbedding5D_swigregister(LogEmbedding5D)
10773 class LogEmbedding6D(object):
10774 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 6 > class."""
10776 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10778 def __init__(self, *args):
10780 __init__(LogEmbedding6D self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
10781 __init__(LogEmbedding6D self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
10782 __init__(LogEmbedding6D self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
10783 __init__(LogEmbedding6D self) -> LogEmbedding6D
10785 _IMP_algebra.LogEmbedding6D_swiginit(self, _IMP_algebra.new_LogEmbedding6D(*args))
10787 def set_origin(self, o):
10788 r"""set_origin(LogEmbedding6D self, Vector6D o)"""
10789 return _IMP_algebra.LogEmbedding6D_set_origin(self, o)
10791 def get_origin(self):
10792 r"""get_origin(LogEmbedding6D self) -> Vector6D"""
10793 return _IMP_algebra.LogEmbedding6D_get_origin(self)
10795 def get_dimension(self):
10796 r"""get_dimension(LogEmbedding6D self) -> unsigned int"""
10797 return _IMP_algebra.LogEmbedding6D_get_dimension(self)
10799 def set_unit_cell(self, *args):
10801 set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
10802 set_unit_cell(LogEmbedding6D self, Vector6D o)
10804 return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)
10806 def get_unit_cell(self):
10807 r"""get_unit_cell(LogEmbedding6D self) -> Vector6D"""
10808 return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)
10810 def get_extended_index(self, o):
10811 r"""get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10812 return _IMP_algebra.LogEmbedding6D_get_extended_index(self, o)
10815 r"""get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
10816 return _IMP_algebra.LogEmbedding6D_get_index(self, o)
10818 def get_center(self, *args):
10820 get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10821 get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
10823 return _IMP_algebra.LogEmbedding6D_get_center(self, *args)
10825 def get_bounding_box(self, *args):
10827 get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10828 get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10830 return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)
10832 def show(self, *args):
10833 r"""show(LogEmbedding6D self, _ostream out=std::cout)"""
10834 return _IMP_algebra.LogEmbedding6D_show(self, *args)
10837 r"""__str__(LogEmbedding6D self) -> std::string"""
10838 return _IMP_algebra.LogEmbedding6D___str__(self)
10840 def __repr__(self):
10841 r"""__repr__(LogEmbedding6D self) -> std::string"""
10842 return _IMP_algebra.LogEmbedding6D___repr__(self)
10844 def __cmp__(self, arg2):
10845 r"""__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
10846 return _IMP_algebra.LogEmbedding6D___cmp__(self, arg2)
10848 def __eq__(self, arg2):
10849 r"""__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
10850 return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)
10852 def _get_as_binary(self):
10853 r"""_get_as_binary(LogEmbedding6D self) -> PyObject *"""
10854 return _IMP_algebra.LogEmbedding6D__get_as_binary(self)
10856 def _set_from_binary(self, p):
10857 r"""_set_from_binary(LogEmbedding6D self, PyObject * p)"""
10858 return _IMP_algebra.LogEmbedding6D__set_from_binary(self, p)
10860 def __getstate__(self):
10861 p = self._get_as_binary()
10862 if len(self.__dict__) > 1:
10863 d = self.__dict__.copy()
10868 def __setstate__(self, p):
10869 if not hasattr(self,
'this'):
10871 if isinstance(p, tuple):
10873 self.__dict__.update(d)
10874 return self._set_from_binary(p)
10876 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
10879 _IMP_algebra.LogEmbedding6D_swigregister(LogEmbedding6D)
10880 class SpherePatch3D(_GeometricPrimitive3D):
10881 r"""Proxy of C++ IMP::algebra::SpherePatch3D class."""
10883 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10885 def __init__(self, *args):
10887 __init__(SpherePatch3D self) -> SpherePatch3D
10888 __init__(SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
10890 _IMP_algebra.SpherePatch3D_swiginit(self, _IMP_algebra.new_SpherePatch3D(*args))
10892 def get_contains(self, p):
10893 r"""get_contains(SpherePatch3D self, Vector3D p) -> bool"""
10894 return _IMP_algebra.SpherePatch3D_get_contains(self, p)
10896 def get_plane(self):
10897 r"""get_plane(SpherePatch3D self) -> Plane3D"""
10898 return _IMP_algebra.SpherePatch3D_get_plane(self)
10900 def get_sphere(self):
10901 r"""get_sphere(SpherePatch3D self) -> Sphere3D"""
10902 return _IMP_algebra.SpherePatch3D_get_sphere(self)
10904 def show(self, *args):
10905 r"""show(SpherePatch3D self, _ostream out=std::cout)"""
10906 return _IMP_algebra.SpherePatch3D_show(self, *args)
10908 def get_boundary_point(self):
10909 r"""get_boundary_point(SpherePatch3D self) -> Vector3D"""
10910 return _IMP_algebra.SpherePatch3D_get_boundary_point(self)
10913 r"""__str__(SpherePatch3D self) -> std::string"""
10914 return _IMP_algebra.SpherePatch3D___str__(self)
10916 def __repr__(self):
10917 r"""__repr__(SpherePatch3D self) -> std::string"""
10918 return _IMP_algebra.SpherePatch3D___repr__(self)
10920 def _get_as_binary(self):
10921 r"""_get_as_binary(SpherePatch3D self) -> PyObject *"""
10922 return _IMP_algebra.SpherePatch3D__get_as_binary(self)
10924 def _set_from_binary(self, p):
10925 r"""_set_from_binary(SpherePatch3D self, PyObject * p)"""
10926 return _IMP_algebra.SpherePatch3D__set_from_binary(self, p)
10928 def __getstate__(self):
10929 p = self._get_as_binary()
10930 if len(self.__dict__) > 1:
10931 d = self.__dict__.copy()
10936 def __setstate__(self, p):
10937 if not hasattr(self,
'this'):
10939 if isinstance(p, tuple):
10941 self.__dict__.update(d)
10942 return self._set_from_binary(p)
10944 __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
10947 _IMP_algebra.SpherePatch3D_swigregister(SpherePatch3D)
10951 get_area(Plane3D g) -> double
10952 get_area(SpherePatch3D g) -> double
10954 return _IMP_algebra.get_area(*args)
10956 def get_sphere_patch_3d_geometry(g):
10957 r"""get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
10958 return _IMP_algebra.get_sphere_patch_3d_geometry(g)
10959 class Cone3D(_GeometricPrimitive3D):
10960 r"""Proxy of C++ IMP::algebra::Cone3D class."""
10962 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10964 def __init__(self, *args):
10966 __init__(Cone3D self) -> Cone3D
10967 __init__(Cone3D self, Segment3D s, double radius) -> Cone3D
10969 _IMP_algebra.Cone3D_swiginit(self, _IMP_algebra.new_Cone3D(*args))
10972 r"""get_tip(Cone3D self) -> Vector3D"""
10973 return _IMP_algebra.Cone3D_get_tip(self)
10975 def get_direction(self):
10976 r"""get_direction(Cone3D self) -> Vector3D"""
10977 return _IMP_algebra.Cone3D_get_direction(self)
10980 r"""get_height(Cone3D self) -> double"""
10981 return _IMP_algebra.Cone3D_get_height(self)
10984 r"""get_angle(Cone3D self) -> double"""
10985 return _IMP_algebra.Cone3D_get_angle(self)
10987 def get_radius(self):
10988 r"""get_radius(Cone3D self) -> double"""
10989 return _IMP_algebra.Cone3D_get_radius(self)
10991 def get_contains(self, v):
10992 r"""get_contains(Cone3D self, Vector3D v) -> bool"""
10993 return _IMP_algebra.Cone3D_get_contains(self, v)
10995 def get_base_plane(self):
10996 r"""get_base_plane(Cone3D self) -> Plane3D"""
10997 return _IMP_algebra.Cone3D_get_base_plane(self)
10999 def show(self, *args):
11000 r"""show(Cone3D self, _ostream out=std::cout)"""
11001 return _IMP_algebra.Cone3D_show(self, *args)
11004 r"""__str__(Cone3D self) -> std::string"""
11005 return _IMP_algebra.Cone3D___str__(self)
11007 def __repr__(self):
11008 r"""__repr__(Cone3D self) -> std::string"""
11009 return _IMP_algebra.Cone3D___repr__(self)
11011 def _get_as_binary(self):
11012 r"""_get_as_binary(Cone3D self) -> PyObject *"""
11013 return _IMP_algebra.Cone3D__get_as_binary(self)
11015 def _set_from_binary(self, p):
11016 r"""_set_from_binary(Cone3D self, PyObject * p)"""
11017 return _IMP_algebra.Cone3D__set_from_binary(self, p)
11019 def __getstate__(self):
11020 p = self._get_as_binary()
11021 if len(self.__dict__) > 1:
11022 d = self.__dict__.copy()
11027 def __setstate__(self, p):
11028 if not hasattr(self,
'this'):
11030 if isinstance(p, tuple):
11032 self.__dict__.update(d)
11033 return self._set_from_binary(p)
11035 __swig_destroy__ = _IMP_algebra.delete_Cone3D
11038 _IMP_algebra.Cone3D_swigregister(Cone3D)
11042 get_surface_area(BoundingBox3D g) -> double
11043 get_surface_area(Sphere3D g) -> double
11044 get_surface_area(Cylinder3D g) -> double
11045 get_surface_area(Ellipsoid3D g) -> double
11046 get_surface_area(Cone3D g) -> double
11048 return _IMP_algebra.get_surface_area(*args)
11052 get_volume(BoundingBox3D g) -> double
11053 get_volume(Sphere3D g) -> double
11054 get_volume(Cylinder3D g) -> double
11055 get_volume(Ellipsoid3D g) -> double
11056 get_volume(Cone3D g) -> double
11058 return _IMP_algebra.get_volume(*args)
11060 def get_cone_3d_geometry(g):
11061 r"""get_cone_3d_geometry(Cone3D g) -> Cone3D"""
11062 return _IMP_algebra.get_cone_3d_geometry(g)
11065 r"""write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
11066 return _IMP_algebra.write_pts(vs, out)
11069 r"""read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
11070 return _IMP_algebra.read_pts(input)
11073 r"""write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
11074 return _IMP_algebra.write_spheres(vs, out)
11077 r"""read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
11078 return _IMP_algebra.read_spheres(input)
11081 r"""get_random_vector_on_unit_sphere() -> Vector3D"""
11082 return _IMP_algebra.get_random_vector_on_unit_sphere()
11085 r"""get_grid_surface_cover(Cylinder3D cyl, int number_of_cycles, int number_of_points_on_cycle) -> IMP::algebra::Vector3Ds"""
11086 return _IMP_algebra.get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle)
11089 r"""get_random_chain(unsigned int n, double r, Vector3D start=IMP::algebra::Vector3D(0, 0, 0), IMP::algebra::Sphere3Ds const & obstacles=IMP::algebra::Sphere3Ds()) -> IMP::algebra::Vector3Ds"""
11090 return _IMP_algebra.get_random_chain(*args)
11093 r"""reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
11094 return _IMP_algebra.reversed_read(dest, size, nitems, f, reverse)
11097 r"""reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)"""
11098 return _IMP_algebra.reversed_write(src, size, nitems, f, reverse)
11101 r"""get_is_big_endian() -> bool"""
11102 return _IMP_algebra.get_is_big_endian()
11105 r"""get_is_little_endian() -> bool"""
11106 return _IMP_algebra.get_is_little_endian()
11110 get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
11111 get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
11113 return _IMP_algebra.get_shortest_segment(*args)
11115 r"""Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class."""
11117 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11119 def __init__(self, vs, query_estimate=1):
11120 r"""__init__(DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D"""
11121 _IMP_algebra.DynamicNearestNeighbor3D_swiginit(self, _IMP_algebra.new_DynamicNearestNeighbor3D(vs, query_estimate))
11123 def get_in_ball(self, id, distance):
11124 r"""get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
11125 return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, id, distance)
11127 def set_coordinates(self, id, nc):
11128 r"""set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
11129 return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, id, nc)
11131 def get_version_info(self):
11132 r"""get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
11133 return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)
11134 __swig_destroy__ = _IMP_algebra.delete_DynamicNearestNeighbor3D
11137 r"""__str__(DynamicNearestNeighbor3D self) -> std::string"""
11138 return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)
11140 def __repr__(self):
11141 r"""__repr__(DynamicNearestNeighbor3D self) -> std::string"""
11142 return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)
11146 return _object_cast_to_DynamicNearestNeighbor3D(o)
11150 _IMP_algebra.DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
11152 r"""Proxy of C++ IMP::algebra::VectorKDMetric class."""
11154 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11156 def __init__(self, name):
11157 r"""__init__(VectorKDMetric self, std::string name) -> VectorKDMetric"""
11158 if self.__class__ == VectorKDMetric:
11162 _IMP_algebra.VectorKDMetric_swiginit(self, _IMP_algebra.new_VectorKDMetric(_self, name))
11164 if self.__class__ != VectorKDMetric:
11165 _director_objects.register(self)
11171 r"""get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
11172 return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)
11175 r"""get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
11176 return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)
11179 r"""__str__(VectorKDMetric self) -> std::string"""
11180 return _IMP_algebra.VectorKDMetric___str__(self)
11182 def __repr__(self):
11183 r"""__repr__(VectorKDMetric self) -> std::string"""
11184 return _IMP_algebra.VectorKDMetric___repr__(self)
11188 return _object_cast_to_VectorKDMetric(o)
11191 def get_type_name(self):
11192 return self.__class__.__name__
11193 def do_show(self, out):
11195 def get_version_info(self):
11196 if"IMP::algebra" ==
"IMP":
11197 return VersionInfo(self.__module__,
11204 return _object_cast_to_VectorKDMetric(o)
11206 __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
11207 def __disown__(self):
11209 _IMP_algebra.disown_VectorKDMetric(self)
11210 return weakref.proxy(self)
11212 def do_destroy(self):
11213 r"""do_destroy(VectorKDMetric self)"""
11214 return _IMP_algebra.VectorKDMetric_do_destroy(self)
11217 _IMP_algebra.VectorKDMetric_swigregister(VectorKDMetric)
11218 class EuclideanVectorKDMetric(VectorKDMetric):
11219 r"""Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class."""
11221 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11223 def __init__(self, *args):
11224 r"""__init__(EuclideanVectorKDMetric self, std::string name="EuclideanVectorKDMetric%1%") -> EuclideanVectorKDMetric"""
11225 _IMP_algebra.EuclideanVectorKDMetric_swiginit(self, _IMP_algebra.new_EuclideanVectorKDMetric(*args))
11227 def get_version_info(self):
11228 r"""get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
11229 return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)
11230 __swig_destroy__ = _IMP_algebra.delete_EuclideanVectorKDMetric
11233 r"""__str__(EuclideanVectorKDMetric self) -> std::string"""
11234 return _IMP_algebra.EuclideanVectorKDMetric___str__(self)
11236 def __repr__(self):
11237 r"""__repr__(EuclideanVectorKDMetric self) -> std::string"""
11238 return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)
11242 return _object_cast_to_EuclideanVectorKDMetric(o)
11245 def _get_as_binary(self):
11246 r"""_get_as_binary(EuclideanVectorKDMetric self) -> PyObject *"""
11247 return _IMP_algebra.EuclideanVectorKDMetric__get_as_binary(self)
11249 def _set_from_binary(self, p):
11250 r"""_set_from_binary(EuclideanVectorKDMetric self, PyObject * p)"""
11251 return _IMP_algebra.EuclideanVectorKDMetric__set_from_binary(self, p)
11253 def __getstate__(self):
11254 p = self._get_as_binary()
11255 if len(self.__dict__) > 1:
11256 d = self.__dict__.copy()
11261 def __setstate__(self, p):
11262 if not hasattr(self,
'this'):
11264 if isinstance(p, tuple):
11266 self.__dict__.update(d)
11267 return self._set_from_binary(p)
11271 _IMP_algebra.EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
11272 class MaxVectorKDMetric(VectorKDMetric):
11273 r"""Proxy of C++ IMP::algebra::MaxVectorKDMetric class."""
11275 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11277 def __init__(self, *args):
11278 r"""__init__(MaxVectorKDMetric self, std::string name="MaxVectorKDMetric%1%") -> MaxVectorKDMetric"""
11279 _IMP_algebra.MaxVectorKDMetric_swiginit(self, _IMP_algebra.new_MaxVectorKDMetric(*args))
11281 def get_version_info(self):
11282 r"""get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
11283 return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)
11284 __swig_destroy__ = _IMP_algebra.delete_MaxVectorKDMetric
11287 r"""__str__(MaxVectorKDMetric self) -> std::string"""
11288 return _IMP_algebra.MaxVectorKDMetric___str__(self)
11290 def __repr__(self):
11291 r"""__repr__(MaxVectorKDMetric self) -> std::string"""
11292 return _IMP_algebra.MaxVectorKDMetric___repr__(self)
11296 return _object_cast_to_MaxVectorKDMetric(o)
11299 def _get_as_binary(self):
11300 r"""_get_as_binary(MaxVectorKDMetric self) -> PyObject *"""
11301 return _IMP_algebra.MaxVectorKDMetric__get_as_binary(self)
11303 def _set_from_binary(self, p):
11304 r"""_set_from_binary(MaxVectorKDMetric self, PyObject * p)"""
11305 return _IMP_algebra.MaxVectorKDMetric__set_from_binary(self, p)
11307 def __getstate__(self):
11308 p = self._get_as_binary()
11309 if len(self.__dict__) > 1:
11310 d = self.__dict__.copy()
11315 def __setstate__(self, p):
11316 if not hasattr(self,
'this'):
11318 if isinstance(p, tuple):
11320 self.__dict__.update(d)
11321 return self._set_from_binary(p)
11325 _IMP_algebra.MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
11326 class Gaussian3D(_GeometricPrimitive3D):
11327 r"""Proxy of C++ IMP::algebra::Gaussian3D class."""
11329 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11331 def __init__(self, *args):
11333 __init__(Gaussian3D self) -> Gaussian3D
11334 __init__(Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
11336 _IMP_algebra.Gaussian3D_swiginit(self, _IMP_algebra.new_Gaussian3D(*args))
11338 def get_reference_frame(self):
11339 r"""get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
11340 return _IMP_algebra.Gaussian3D_get_reference_frame(self)
11342 def get_variances(self):
11343 r"""get_variances(Gaussian3D self) -> Vector3D"""
11344 return _IMP_algebra.Gaussian3D_get_variances(self)
11346 def get_center(self):
11347 r"""get_center(Gaussian3D self) -> Vector3D"""
11348 return _IMP_algebra.Gaussian3D_get_center(self)
11350 def show(self, *args):
11351 r"""show(Gaussian3D self, _ostream out=std::cout)"""
11352 return _IMP_algebra.Gaussian3D_show(self, *args)
11355 r"""__str__(Gaussian3D self) -> std::string"""
11356 return _IMP_algebra.Gaussian3D___str__(self)
11358 def __repr__(self):
11359 r"""__repr__(Gaussian3D self) -> std::string"""
11360 return _IMP_algebra.Gaussian3D___repr__(self)
11362 def _get_as_binary(self):
11363 r"""_get_as_binary(Gaussian3D self) -> PyObject *"""
11364 return _IMP_algebra.Gaussian3D__get_as_binary(self)
11366 def _set_from_binary(self, p):
11367 r"""_set_from_binary(Gaussian3D self, PyObject * p)"""
11368 return _IMP_algebra.Gaussian3D__set_from_binary(self, p)
11370 def __getstate__(self):
11371 p = self._get_as_binary()
11372 if len(self.__dict__) > 1:
11373 d = self.__dict__.copy()
11378 def __setstate__(self, p):
11379 if not hasattr(self,
'this'):
11381 if isinstance(p, tuple):
11383 self.__dict__.update(d)
11384 return self._set_from_binary(p)
11386 __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
11389 _IMP_algebra.Gaussian3D_swigregister(Gaussian3D)
11392 r"""get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
11393 return _IMP_algebra.get_covariance(g)
11396 r"""get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
11397 return _IMP_algebra.get_gaussian_from_covariance(covariance, center)
11400 r"""get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D"""
11401 return _IMP_algebra.get_rasterized(gmm, weights, cell_width, bb)
11404 r"""get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb, double factor=2.5) -> DenseDoubleGrid3D"""
11405 return _IMP_algebra.get_rasterized_fast(gmm, weights, cell_width, bb, factor)
11407 def _pass_matrix_xf(m):
11408 r"""_pass_matrix_xf(Eigen::MatrixXf const & m) -> Eigen::MatrixXf"""
11409 return _IMP_algebra._pass_matrix_xf(m)
11411 def _pass_matrix_xd(m):
11412 r"""_pass_matrix_xd(Eigen::MatrixXd const & m) -> Eigen::MatrixXd"""
11413 return _IMP_algebra._pass_matrix_xd(m)
11415 def _pass_matrix_3d(m):
11416 r"""_pass_matrix_3d(Eigen::Matrix3d const & m) -> Eigen::Matrix3d"""
11417 return _IMP_algebra._pass_matrix_3d(m)
11419 def _pass_array_xd(m):
11420 r"""_pass_array_xd(Eigen::ArrayXXd const & m) -> Eigen::ArrayXXd"""
11421 return _IMP_algebra._pass_array_xd(m)
11423 def _pass_vector_xd(m):
11424 r"""_pass_vector_xd(Eigen::VectorXd const & m) -> Eigen::VectorXd"""
11425 return _IMP_algebra._pass_vector_xd(m)
11427 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 1 > class."""
11429 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11431 def __init__(self, vs, epsilon=0):
11432 r"""__init__(NearestNeighbor1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D"""
11433 _IMP_algebra.NearestNeighbor1D_swiginit(self, _IMP_algebra.new_NearestNeighbor1D(vs, epsilon))
11435 def set_query_log(self, fname):
11436 r"""set_query_log(NearestNeighbor1D self, std::string fname)"""
11437 return _IMP_algebra.NearestNeighbor1D_set_query_log(self, fname)
11439 def get_nearest_neighbor(self, *args):
11441 get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
11442 get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
11444 return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)
11446 def get_nearest_neighbors(self, *args):
11448 get_nearest_neighbors(NearestNeighbor1D self, unsigned int i, unsigned int k) -> IMP::Ints
11449 get_nearest_neighbors(NearestNeighbor1D self, Vector1D v, unsigned int k) -> IMP::Ints
11451 return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)
11453 def get_in_ball(self, *args):
11455 get_in_ball(NearestNeighbor1D self, unsigned int i, double distance) -> IMP::Ints
11456 get_in_ball(NearestNeighbor1D self, Vector1D pt, double distance) -> IMP::Ints
11458 return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)
11460 def get_version_info(self):
11461 r"""get_version_info(NearestNeighbor1D self) -> VersionInfo"""
11462 return _IMP_algebra.NearestNeighbor1D_get_version_info(self)
11463 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor1D
11466 r"""__str__(NearestNeighbor1D self) -> std::string"""
11467 return _IMP_algebra.NearestNeighbor1D___str__(self)
11469 def __repr__(self):
11470 r"""__repr__(NearestNeighbor1D self) -> std::string"""
11471 return _IMP_algebra.NearestNeighbor1D___repr__(self)
11475 return _object_cast_to_NearestNeighborD(o)
11479 _IMP_algebra.NearestNeighbor1D_swigregister(NearestNeighbor1D)
11481 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 2 > class."""
11483 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11485 def __init__(self, vs, epsilon=0):
11486 r"""__init__(NearestNeighbor2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D"""
11487 _IMP_algebra.NearestNeighbor2D_swiginit(self, _IMP_algebra.new_NearestNeighbor2D(vs, epsilon))
11489 def set_query_log(self, fname):
11490 r"""set_query_log(NearestNeighbor2D self, std::string fname)"""
11491 return _IMP_algebra.NearestNeighbor2D_set_query_log(self, fname)
11493 def get_nearest_neighbor(self, *args):
11495 get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
11496 get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
11498 return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)
11500 def get_nearest_neighbors(self, *args):
11502 get_nearest_neighbors(NearestNeighbor2D self, unsigned int i, unsigned int k) -> IMP::Ints
11503 get_nearest_neighbors(NearestNeighbor2D self, Vector2D v, unsigned int k) -> IMP::Ints
11505 return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)
11507 def get_in_ball(self, *args):
11509 get_in_ball(NearestNeighbor2D self, unsigned int i, double distance) -> IMP::Ints
11510 get_in_ball(NearestNeighbor2D self, Vector2D pt, double distance) -> IMP::Ints
11512 return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)
11514 def get_version_info(self):
11515 r"""get_version_info(NearestNeighbor2D self) -> VersionInfo"""
11516 return _IMP_algebra.NearestNeighbor2D_get_version_info(self)
11517 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor2D
11520 r"""__str__(NearestNeighbor2D self) -> std::string"""
11521 return _IMP_algebra.NearestNeighbor2D___str__(self)
11523 def __repr__(self):
11524 r"""__repr__(NearestNeighbor2D self) -> std::string"""
11525 return _IMP_algebra.NearestNeighbor2D___repr__(self)
11529 return _object_cast_to_NearestNeighborD(o)
11533 _IMP_algebra.NearestNeighbor2D_swigregister(NearestNeighbor2D)
11535 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 3 > class."""
11537 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11539 def __init__(self, vs, epsilon=0):
11540 r"""__init__(NearestNeighbor3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D"""
11541 _IMP_algebra.NearestNeighbor3D_swiginit(self, _IMP_algebra.new_NearestNeighbor3D(vs, epsilon))
11543 def set_query_log(self, fname):
11544 r"""set_query_log(NearestNeighbor3D self, std::string fname)"""
11545 return _IMP_algebra.NearestNeighbor3D_set_query_log(self, fname)
11547 def get_nearest_neighbor(self, *args):
11549 get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
11550 get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
11552 return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)
11554 def get_nearest_neighbors(self, *args):
11556 get_nearest_neighbors(NearestNeighbor3D self, unsigned int i, unsigned int k) -> IMP::Ints
11557 get_nearest_neighbors(NearestNeighbor3D self, Vector3D v, unsigned int k) -> IMP::Ints
11559 return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)
11561 def get_in_ball(self, *args):
11563 get_in_ball(NearestNeighbor3D self, unsigned int i, double distance) -> IMP::Ints
11564 get_in_ball(NearestNeighbor3D self, Vector3D pt, double distance) -> IMP::Ints
11566 return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)
11568 def get_version_info(self):
11569 r"""get_version_info(NearestNeighbor3D self) -> VersionInfo"""
11570 return _IMP_algebra.NearestNeighbor3D_get_version_info(self)
11571 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor3D
11574 r"""__str__(NearestNeighbor3D self) -> std::string"""
11575 return _IMP_algebra.NearestNeighbor3D___str__(self)
11577 def __repr__(self):
11578 r"""__repr__(NearestNeighbor3D self) -> std::string"""
11579 return _IMP_algebra.NearestNeighbor3D___repr__(self)
11583 return _object_cast_to_NearestNeighborD(o)
11587 _IMP_algebra.NearestNeighbor3D_swigregister(NearestNeighbor3D)
11589 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 4 > class."""
11591 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11593 def __init__(self, vs, epsilon=0):
11594 r"""__init__(NearestNeighbor4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D"""
11595 _IMP_algebra.NearestNeighbor4D_swiginit(self, _IMP_algebra.new_NearestNeighbor4D(vs, epsilon))
11597 def set_query_log(self, fname):
11598 r"""set_query_log(NearestNeighbor4D self, std::string fname)"""
11599 return _IMP_algebra.NearestNeighbor4D_set_query_log(self, fname)
11601 def get_nearest_neighbor(self, *args):
11603 get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
11604 get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
11606 return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)
11608 def get_nearest_neighbors(self, *args):
11610 get_nearest_neighbors(NearestNeighbor4D self, unsigned int i, unsigned int k) -> IMP::Ints
11611 get_nearest_neighbors(NearestNeighbor4D self, Vector4D v, unsigned int k) -> IMP::Ints
11613 return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)
11615 def get_in_ball(self, *args):
11617 get_in_ball(NearestNeighbor4D self, unsigned int i, double distance) -> IMP::Ints
11618 get_in_ball(NearestNeighbor4D self, Vector4D pt, double distance) -> IMP::Ints
11620 return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)
11622 def get_version_info(self):
11623 r"""get_version_info(NearestNeighbor4D self) -> VersionInfo"""
11624 return _IMP_algebra.NearestNeighbor4D_get_version_info(self)
11625 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor4D
11628 r"""__str__(NearestNeighbor4D self) -> std::string"""
11629 return _IMP_algebra.NearestNeighbor4D___str__(self)
11631 def __repr__(self):
11632 r"""__repr__(NearestNeighbor4D self) -> std::string"""
11633 return _IMP_algebra.NearestNeighbor4D___repr__(self)
11637 return _object_cast_to_NearestNeighborD(o)
11641 _IMP_algebra.NearestNeighbor4D_swigregister(NearestNeighbor4D)
11643 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 5 > class."""
11645 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11647 def __init__(self, vs, epsilon=0):
11648 r"""__init__(NearestNeighbor5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D"""
11649 _IMP_algebra.NearestNeighbor5D_swiginit(self, _IMP_algebra.new_NearestNeighbor5D(vs, epsilon))
11651 def set_query_log(self, fname):
11652 r"""set_query_log(NearestNeighbor5D self, std::string fname)"""
11653 return _IMP_algebra.NearestNeighbor5D_set_query_log(self, fname)
11655 def get_nearest_neighbor(self, *args):
11657 get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
11658 get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
11660 return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)
11662 def get_nearest_neighbors(self, *args):
11664 get_nearest_neighbors(NearestNeighbor5D self, unsigned int i, unsigned int k) -> IMP::Ints
11665 get_nearest_neighbors(NearestNeighbor5D self, Vector5D v, unsigned int k) -> IMP::Ints
11667 return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)
11669 def get_in_ball(self, *args):
11671 get_in_ball(NearestNeighbor5D self, unsigned int i, double distance) -> IMP::Ints
11672 get_in_ball(NearestNeighbor5D self, Vector5D pt, double distance) -> IMP::Ints
11674 return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)
11676 def get_version_info(self):
11677 r"""get_version_info(NearestNeighbor5D self) -> VersionInfo"""
11678 return _IMP_algebra.NearestNeighbor5D_get_version_info(self)
11679 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor5D
11682 r"""__str__(NearestNeighbor5D self) -> std::string"""
11683 return _IMP_algebra.NearestNeighbor5D___str__(self)
11685 def __repr__(self):
11686 r"""__repr__(NearestNeighbor5D self) -> std::string"""
11687 return _IMP_algebra.NearestNeighbor5D___repr__(self)
11691 return _object_cast_to_NearestNeighborD(o)
11695 _IMP_algebra.NearestNeighbor5D_swigregister(NearestNeighbor5D)
11697 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 6 > class."""
11699 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11701 def __init__(self, vs, epsilon=0):
11702 r"""__init__(NearestNeighbor6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D"""
11703 _IMP_algebra.NearestNeighbor6D_swiginit(self, _IMP_algebra.new_NearestNeighbor6D(vs, epsilon))
11705 def set_query_log(self, fname):
11706 r"""set_query_log(NearestNeighbor6D self, std::string fname)"""
11707 return _IMP_algebra.NearestNeighbor6D_set_query_log(self, fname)
11709 def get_nearest_neighbor(self, *args):
11711 get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
11712 get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
11714 return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)
11716 def get_nearest_neighbors(self, *args):
11718 get_nearest_neighbors(NearestNeighbor6D self, unsigned int i, unsigned int k) -> IMP::Ints
11719 get_nearest_neighbors(NearestNeighbor6D self, Vector6D v, unsigned int k) -> IMP::Ints
11721 return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)
11723 def get_in_ball(self, *args):
11725 get_in_ball(NearestNeighbor6D self, unsigned int i, double distance) -> IMP::Ints
11726 get_in_ball(NearestNeighbor6D self, Vector6D pt, double distance) -> IMP::Ints
11728 return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)
11730 def get_version_info(self):
11731 r"""get_version_info(NearestNeighbor6D self) -> VersionInfo"""
11732 return _IMP_algebra.NearestNeighbor6D_get_version_info(self)
11733 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor6D
11736 r"""__str__(NearestNeighbor6D self) -> std::string"""
11737 return _IMP_algebra.NearestNeighbor6D___str__(self)
11739 def __repr__(self):
11740 r"""__repr__(NearestNeighbor6D self) -> std::string"""
11741 return _IMP_algebra.NearestNeighbor6D___repr__(self)
11745 return _object_cast_to_NearestNeighborD(o)
11749 _IMP_algebra.NearestNeighbor6D_swigregister(NearestNeighbor6D)
11751 r"""Proxy of C++ IMP::algebra::NearestNeighborD< -1 > class."""
11753 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11755 def __init__(self, vs, epsilon=0):
11756 r"""__init__(NearestNeighborKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD"""
11757 _IMP_algebra.NearestNeighborKD_swiginit(self, _IMP_algebra.new_NearestNeighborKD(vs, epsilon))
11759 def set_query_log(self, fname):
11760 r"""set_query_log(NearestNeighborKD self, std::string fname)"""
11761 return _IMP_algebra.NearestNeighborKD_set_query_log(self, fname)
11763 def get_nearest_neighbor(self, *args):
11765 get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
11766 get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
11768 return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)
11770 def get_nearest_neighbors(self, *args):
11772 get_nearest_neighbors(NearestNeighborKD self, unsigned int i, unsigned int k) -> IMP::Ints
11773 get_nearest_neighbors(NearestNeighborKD self, VectorKD v, unsigned int k) -> IMP::Ints
11775 return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)
11777 def get_in_ball(self, *args):
11779 get_in_ball(NearestNeighborKD self, unsigned int i, double distance) -> IMP::Ints
11780 get_in_ball(NearestNeighborKD self, VectorKD pt, double distance) -> IMP::Ints
11782 return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)
11784 def get_version_info(self):
11785 r"""get_version_info(NearestNeighborKD self) -> VersionInfo"""
11786 return _IMP_algebra.NearestNeighborKD_get_version_info(self)
11787 __swig_destroy__ = _IMP_algebra.delete_NearestNeighborKD
11790 r"""__str__(NearestNeighborKD self) -> std::string"""
11791 return _IMP_algebra.NearestNeighborKD___str__(self)
11793 def __repr__(self):
11794 r"""__repr__(NearestNeighborKD self) -> std::string"""
11795 return _IMP_algebra.NearestNeighborKD___repr__(self)
11799 return _object_cast_to_NearestNeighborD(o)
11803 _IMP_algebra.NearestNeighborKD_swigregister(NearestNeighborKD)
11806 r"""get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
11807 return _IMP_algebra.get_transformation_aligning_pair(set_from, set_to)
11808 class PrincipalComponentAnalysis1D(_GeometricPrimitive1D):
11809 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 1 > class."""
11811 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11813 def __init__(self, *args):
11815 __init__(PrincipalComponentAnalysis1D self) -> PrincipalComponentAnalysis1D
11816 __init__(PrincipalComponentAnalysis1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
11818 _IMP_algebra.PrincipalComponentAnalysis1D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis1D(*args))
11821 r"""get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
11822 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)
11824 def get_principal_component(self, i):
11825 r"""get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
11826 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, i)
11828 def get_principal_values(self):
11829 r"""get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
11830 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)
11832 def get_principal_value(self, i):
11833 r"""get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
11834 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, i)
11837 r"""get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
11838 return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)
11840 def set_centroid(self, cntr):
11841 r"""set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
11842 return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)
11844 def show(self, *args):
11845 r"""show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)"""
11846 return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)
11848 def __cmp__(self, o):
11849 r"""__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
11850 return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, o)
11852 def __eq__(self, o):
11853 r"""__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11854 return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)
11856 def __ne__(self, o):
11857 r"""__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11858 return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)
11860 def __lt__(self, o):
11861 r"""__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11862 return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)
11864 def __gt__(self, o):
11865 r"""__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11866 return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)
11868 def __ge__(self, o):
11869 r"""__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11870 return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)
11872 def __le__(self, o):
11873 r"""__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11874 return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)
11877 r"""__str__(PrincipalComponentAnalysis1D self) -> std::string"""
11878 return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)
11880 def __repr__(self):
11881 r"""__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
11882 return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)
11884 def _get_as_binary(self):
11885 r"""_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
11886 return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)
11888 def _set_from_binary(self, p):
11889 r"""_set_from_binary(PrincipalComponentAnalysis1D self, PyObject * p)"""
11890 return _IMP_algebra.PrincipalComponentAnalysis1D__set_from_binary(self, p)
11892 def __getstate__(self):
11893 p = self._get_as_binary()
11894 if len(self.__dict__) > 1:
11895 d = self.__dict__.copy()
11900 def __setstate__(self, p):
11901 if not hasattr(self,
'this'):
11903 if isinstance(p, tuple):
11905 self.__dict__.update(d)
11906 return self._set_from_binary(p)
11908 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
11911 _IMP_algebra.PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
11912 class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
11913 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 2 > class."""
11915 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11917 def __init__(self, *args):
11919 __init__(PrincipalComponentAnalysis2D self) -> PrincipalComponentAnalysis2D
11920 __init__(PrincipalComponentAnalysis2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
11922 _IMP_algebra.PrincipalComponentAnalysis2D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis2D(*args))
11925 r"""get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
11926 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)
11928 def get_principal_component(self, i):
11929 r"""get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
11930 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, i)
11932 def get_principal_values(self):
11933 r"""get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
11934 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)
11936 def get_principal_value(self, i):
11937 r"""get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
11938 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, i)
11941 r"""get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
11942 return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)
11944 def set_centroid(self, cntr):
11945 r"""set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
11946 return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)
11948 def show(self, *args):
11949 r"""show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)"""
11950 return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)
11952 def __cmp__(self, o):
11953 r"""__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
11954 return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, o)
11956 def __eq__(self, o):
11957 r"""__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11958 return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)
11960 def __ne__(self, o):
11961 r"""__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11962 return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)
11964 def __lt__(self, o):
11965 r"""__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11966 return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)
11968 def __gt__(self, o):
11969 r"""__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11970 return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)
11972 def __ge__(self, o):
11973 r"""__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11974 return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)
11976 def __le__(self, o):
11977 r"""__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11978 return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)
11981 r"""__str__(PrincipalComponentAnalysis2D self) -> std::string"""
11982 return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)
11984 def __repr__(self):
11985 r"""__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
11986 return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)
11988 def _get_as_binary(self):
11989 r"""_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
11990 return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)
11992 def _set_from_binary(self, p):
11993 r"""_set_from_binary(PrincipalComponentAnalysis2D self, PyObject * p)"""
11994 return _IMP_algebra.PrincipalComponentAnalysis2D__set_from_binary(self, p)
11996 def __getstate__(self):
11997 p = self._get_as_binary()
11998 if len(self.__dict__) > 1:
11999 d = self.__dict__.copy()
12004 def __setstate__(self, p):
12005 if not hasattr(self,
'this'):
12007 if isinstance(p, tuple):
12009 self.__dict__.update(d)
12010 return self._set_from_binary(p)
12012 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
12015 _IMP_algebra.PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
12016 class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
12017 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 3 > class."""
12019 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12021 def __init__(self, *args):
12023 __init__(PrincipalComponentAnalysis3D self) -> PrincipalComponentAnalysis3D
12024 __init__(PrincipalComponentAnalysis3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
12026 _IMP_algebra.PrincipalComponentAnalysis3D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis3D(*args))
12029 r"""get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
12030 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)
12032 def get_principal_component(self, i):
12033 r"""get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
12034 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, i)
12036 def get_principal_values(self):
12037 r"""get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
12038 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)
12040 def get_principal_value(self, i):
12041 r"""get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
12042 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, i)
12045 r"""get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
12046 return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)
12048 def set_centroid(self, cntr):
12049 r"""set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
12050 return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)
12052 def show(self, *args):
12053 r"""show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)"""
12054 return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)
12056 def __cmp__(self, o):
12057 r"""__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
12058 return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, o)
12060 def __eq__(self, o):
12061 r"""__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12062 return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)
12064 def __ne__(self, o):
12065 r"""__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12066 return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)
12068 def __lt__(self, o):
12069 r"""__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12070 return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)
12072 def __gt__(self, o):
12073 r"""__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12074 return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)
12076 def __ge__(self, o):
12077 r"""__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12078 return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)
12080 def __le__(self, o):
12081 r"""__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12082 return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)
12085 r"""__str__(PrincipalComponentAnalysis3D self) -> std::string"""
12086 return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)
12088 def __repr__(self):
12089 r"""__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
12090 return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)
12092 def _get_as_binary(self):
12093 r"""_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
12094 return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)
12096 def _set_from_binary(self, p):
12097 r"""_set_from_binary(PrincipalComponentAnalysis3D self, PyObject * p)"""
12098 return _IMP_algebra.PrincipalComponentAnalysis3D__set_from_binary(self, p)
12100 def __getstate__(self):
12101 p = self._get_as_binary()
12102 if len(self.__dict__) > 1:
12103 d = self.__dict__.copy()
12108 def __setstate__(self, p):
12109 if not hasattr(self,
'this'):
12111 if isinstance(p, tuple):
12113 self.__dict__.update(d)
12114 return self._set_from_binary(p)
12116 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
12119 _IMP_algebra.PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
12120 class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
12121 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 4 > class."""
12123 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12125 def __init__(self, *args):
12127 __init__(PrincipalComponentAnalysis4D self) -> PrincipalComponentAnalysis4D
12128 __init__(PrincipalComponentAnalysis4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
12130 _IMP_algebra.PrincipalComponentAnalysis4D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis4D(*args))
12133 r"""get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
12134 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)
12136 def get_principal_component(self, i):
12137 r"""get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
12138 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, i)
12140 def get_principal_values(self):
12141 r"""get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
12142 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)
12144 def get_principal_value(self, i):
12145 r"""get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
12146 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, i)
12149 r"""get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
12150 return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)
12152 def set_centroid(self, cntr):
12153 r"""set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
12154 return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)
12156 def show(self, *args):
12157 r"""show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)"""
12158 return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)
12160 def __cmp__(self, o):
12161 r"""__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
12162 return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, o)
12164 def __eq__(self, o):
12165 r"""__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12166 return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)
12168 def __ne__(self, o):
12169 r"""__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12170 return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)
12172 def __lt__(self, o):
12173 r"""__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12174 return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)
12176 def __gt__(self, o):
12177 r"""__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12178 return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)
12180 def __ge__(self, o):
12181 r"""__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12182 return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)
12184 def __le__(self, o):
12185 r"""__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12186 return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)
12189 r"""__str__(PrincipalComponentAnalysis4D self) -> std::string"""
12190 return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)
12192 def __repr__(self):
12193 r"""__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
12194 return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)
12196 def _get_as_binary(self):
12197 r"""_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
12198 return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)
12200 def _set_from_binary(self, p):
12201 r"""_set_from_binary(PrincipalComponentAnalysis4D self, PyObject * p)"""
12202 return _IMP_algebra.PrincipalComponentAnalysis4D__set_from_binary(self, p)
12204 def __getstate__(self):
12205 p = self._get_as_binary()
12206 if len(self.__dict__) > 1:
12207 d = self.__dict__.copy()
12212 def __setstate__(self, p):
12213 if not hasattr(self,
'this'):
12215 if isinstance(p, tuple):
12217 self.__dict__.update(d)
12218 return self._set_from_binary(p)
12220 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
12223 _IMP_algebra.PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
12224 class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
12225 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 5 > class."""
12227 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12229 def __init__(self, *args):
12231 __init__(PrincipalComponentAnalysis5D self) -> PrincipalComponentAnalysis5D
12232 __init__(PrincipalComponentAnalysis5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
12234 _IMP_algebra.PrincipalComponentAnalysis5D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis5D(*args))
12237 r"""get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
12238 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)
12240 def get_principal_component(self, i):
12241 r"""get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
12242 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, i)
12244 def get_principal_values(self):
12245 r"""get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
12246 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)
12248 def get_principal_value(self, i):
12249 r"""get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
12250 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, i)
12253 r"""get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
12254 return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)
12256 def set_centroid(self, cntr):
12257 r"""set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
12258 return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)
12260 def show(self, *args):
12261 r"""show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)"""
12262 return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)
12264 def __cmp__(self, o):
12265 r"""__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
12266 return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, o)
12268 def __eq__(self, o):
12269 r"""__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12270 return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)
12272 def __ne__(self, o):
12273 r"""__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12274 return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)
12276 def __lt__(self, o):
12277 r"""__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12278 return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)
12280 def __gt__(self, o):
12281 r"""__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12282 return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)
12284 def __ge__(self, o):
12285 r"""__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12286 return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)
12288 def __le__(self, o):
12289 r"""__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12290 return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)
12293 r"""__str__(PrincipalComponentAnalysis5D self) -> std::string"""
12294 return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)
12296 def __repr__(self):
12297 r"""__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
12298 return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)
12300 def _get_as_binary(self):
12301 r"""_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
12302 return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)
12304 def _set_from_binary(self, p):
12305 r"""_set_from_binary(PrincipalComponentAnalysis5D self, PyObject * p)"""
12306 return _IMP_algebra.PrincipalComponentAnalysis5D__set_from_binary(self, p)
12308 def __getstate__(self):
12309 p = self._get_as_binary()
12310 if len(self.__dict__) > 1:
12311 d = self.__dict__.copy()
12316 def __setstate__(self, p):
12317 if not hasattr(self,
'this'):
12319 if isinstance(p, tuple):
12321 self.__dict__.update(d)
12322 return self._set_from_binary(p)
12324 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
12327 _IMP_algebra.PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
12328 class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
12329 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 6 > class."""
12331 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12333 def __init__(self, *args):
12335 __init__(PrincipalComponentAnalysis6D self) -> PrincipalComponentAnalysis6D
12336 __init__(PrincipalComponentAnalysis6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
12338 _IMP_algebra.PrincipalComponentAnalysis6D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis6D(*args))
12341 r"""get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
12342 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)
12344 def get_principal_component(self, i):
12345 r"""get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
12346 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, i)
12348 def get_principal_values(self):
12349 r"""get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
12350 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)
12352 def get_principal_value(self, i):
12353 r"""get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
12354 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, i)
12357 r"""get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
12358 return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)
12360 def set_centroid(self, cntr):
12361 r"""set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
12362 return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)
12364 def show(self, *args):
12365 r"""show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)"""
12366 return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)
12368 def __cmp__(self, o):
12369 r"""__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
12370 return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, o)
12372 def __eq__(self, o):
12373 r"""__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12374 return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)
12376 def __ne__(self, o):
12377 r"""__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12378 return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)
12380 def __lt__(self, o):
12381 r"""__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12382 return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)
12384 def __gt__(self, o):
12385 r"""__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12386 return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)
12388 def __ge__(self, o):
12389 r"""__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12390 return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)
12392 def __le__(self, o):
12393 r"""__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12394 return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)
12397 r"""__str__(PrincipalComponentAnalysis6D self) -> std::string"""
12398 return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)
12400 def __repr__(self):
12401 r"""__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
12402 return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)
12404 def _get_as_binary(self):
12405 r"""_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
12406 return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)
12408 def _set_from_binary(self, p):
12409 r"""_set_from_binary(PrincipalComponentAnalysis6D self, PyObject * p)"""
12410 return _IMP_algebra.PrincipalComponentAnalysis6D__set_from_binary(self, p)
12412 def __getstate__(self):
12413 p = self._get_as_binary()
12414 if len(self.__dict__) > 1:
12415 d = self.__dict__.copy()
12420 def __setstate__(self, p):
12421 if not hasattr(self,
'this'):
12423 if isinstance(p, tuple):
12425 self.__dict__.update(d)
12426 return self._set_from_binary(p)
12428 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
12431 _IMP_algebra.PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
12432 class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
12433 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< -1 > class."""
12435 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12437 def __init__(self, *args):
12439 __init__(PrincipalComponentAnalysisKD self) -> PrincipalComponentAnalysisKD
12440 __init__(PrincipalComponentAnalysisKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
12442 _IMP_algebra.PrincipalComponentAnalysisKD_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysisKD(*args))
12445 r"""get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
12446 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)
12448 def get_principal_component(self, i):
12449 r"""get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
12450 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, i)
12452 def get_principal_values(self):
12453 r"""get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
12454 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)
12456 def get_principal_value(self, i):
12457 r"""get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
12458 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, i)
12461 r"""get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
12462 return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)
12464 def set_centroid(self, cntr):
12465 r"""set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
12466 return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)
12468 def show(self, *args):
12469 r"""show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)"""
12470 return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)
12472 def __cmp__(self, o):
12473 r"""__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
12474 return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, o)
12476 def __eq__(self, o):
12477 r"""__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12478 return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)
12480 def __ne__(self, o):
12481 r"""__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12482 return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)
12484 def __lt__(self, o):
12485 r"""__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12486 return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)
12488 def __gt__(self, o):
12489 r"""__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12490 return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)
12492 def __ge__(self, o):
12493 r"""__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12494 return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)
12496 def __le__(self, o):
12497 r"""__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12498 return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)
12501 r"""__str__(PrincipalComponentAnalysisKD self) -> std::string"""
12502 return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)
12504 def __repr__(self):
12505 r"""__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
12506 return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)
12508 def _get_as_binary(self):
12509 r"""_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
12510 return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)
12512 def _set_from_binary(self, p):
12513 r"""_set_from_binary(PrincipalComponentAnalysisKD self, PyObject * p)"""
12514 return _IMP_algebra.PrincipalComponentAnalysisKD__set_from_binary(self, p)
12516 def __getstate__(self):
12517 p = self._get_as_binary()
12518 if len(self.__dict__) > 1:
12519 d = self.__dict__.copy()
12524 def __setstate__(self, p):
12525 if not hasattr(self,
'this'):
12527 if isinstance(p, tuple):
12529 self.__dict__.update(d)
12530 return self._set_from_binary(p)
12532 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
12535 _IMP_algebra.PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)
12539 get_principal_components(IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > > const & a) -> PrincipalComponentAnalysis1D
12540 get_principal_components(IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > > const & a) -> PrincipalComponentAnalysis2D
12541 get_principal_components(IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > > const & a) -> PrincipalComponentAnalysis3D
12542 get_principal_components(IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > > const & a) -> PrincipalComponentAnalysis4D
12543 get_principal_components(IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > > const & a) -> PrincipalComponentAnalysis5D
12544 get_principal_components(IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > > const & a) -> PrincipalComponentAnalysis6D
12545 get_principal_components(IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > > const & a) -> PrincipalComponentAnalysisKD
12547 return _IMP_algebra.get_principal_components(*args)
12551 get_distance(Rotation3D r0, Rotation3D r1) -> double
12552 get_distance(Line3D s, Vector3D p) -> double
12553 get_distance(Line3D a, Line3D b) -> double
12554 get_distance(Segment3D s, Vector3D p) -> double
12555 get_distance(Segment3D a, Segment3D b) -> double
12556 get_distance(Plane3D pln, Vector3D p) -> double
12557 get_distance(Vector1D a, Vector1D b) -> double
12558 get_distance(Vector2D a, Vector2D b) -> double
12559 get_distance(Vector3D a, Vector3D b) -> double
12560 get_distance(Vector4D a, Vector4D b) -> double
12561 get_distance(Vector5D a, Vector5D b) -> double
12562 get_distance(Vector6D a, Vector6D b) -> double
12563 get_distance(VectorKD a, VectorKD b) -> double
12564 get_distance(Sphere1D a, Sphere1D b) -> double
12565 get_distance(Sphere2D a, Sphere2D b) -> double
12566 get_distance(Sphere3D a, Sphere3D b) -> double
12567 get_distance(Sphere4D a, Sphere4D b) -> double
12568 get_distance(Sphere5D a, Sphere5D b) -> double
12569 get_distance(Sphere6D a, Sphere6D b) -> double
12570 get_distance(SphereKD a, SphereKD b) -> double
12572 return _IMP_algebra.get_distance(*args)
12576 get_squared_distance(Vector1D a, Vector1D b) -> double
12577 get_squared_distance(Vector2D a, Vector2D b) -> double
12578 get_squared_distance(Vector3D a, Vector3D b) -> double
12579 get_squared_distance(Vector4D a, Vector4D b) -> double
12580 get_squared_distance(Vector5D a, Vector5D b) -> double
12581 get_squared_distance(Vector6D a, Vector6D b) -> double
12582 get_squared_distance(VectorKD a, VectorKD b) -> double
12584 return _IMP_algebra.get_squared_distance(*args)
12586 def get_basis_vector_1d(coordinate):
12587 r"""get_basis_vector_1d(unsigned int coordinate) -> Vector1D"""
12588 return _IMP_algebra.get_basis_vector_1d(coordinate)
12590 def get_basis_vector_2d(coordinate):
12591 r"""get_basis_vector_2d(unsigned int coordinate) -> Vector2D"""
12592 return _IMP_algebra.get_basis_vector_2d(coordinate)
12594 def get_basis_vector_3d(coordinate):
12595 r"""get_basis_vector_3d(unsigned int coordinate) -> Vector3D"""
12596 return _IMP_algebra.get_basis_vector_3d(coordinate)
12598 def get_basis_vector_4d(coordinate):
12599 r"""get_basis_vector_4d(unsigned int coordinate) -> Vector4D"""
12600 return _IMP_algebra.get_basis_vector_4d(coordinate)
12602 def get_basis_vector_5d(coordinate):
12603 r"""get_basis_vector_5d(unsigned int coordinate) -> Vector5D"""
12604 return _IMP_algebra.get_basis_vector_5d(coordinate)
12606 def get_basis_vector_6d(coordinate):
12607 r"""get_basis_vector_6d(unsigned int coordinate) -> Vector6D"""
12608 return _IMP_algebra.get_basis_vector_6d(coordinate)
12610 def get_zero_vector_1d():
12611 r"""get_zero_vector_1d() -> Vector1D"""
12612 return _IMP_algebra.get_zero_vector_1d()
12614 def get_zero_vector_2d():
12615 r"""get_zero_vector_2d() -> Vector2D"""
12616 return _IMP_algebra.get_zero_vector_2d()
12618 def get_zero_vector_3d():
12619 r"""get_zero_vector_3d() -> Vector3D"""
12620 return _IMP_algebra.get_zero_vector_3d()
12622 def get_zero_vector_4d():
12623 r"""get_zero_vector_4d() -> Vector4D"""
12624 return _IMP_algebra.get_zero_vector_4d()
12626 def get_zero_vector_5d():
12627 r"""get_zero_vector_5d() -> Vector5D"""
12628 return _IMP_algebra.get_zero_vector_5d()
12630 def get_zero_vector_6d():
12631 r"""get_zero_vector_6d() -> Vector6D"""
12632 return _IMP_algebra.get_zero_vector_6d()
12634 def get_ones_vector_1d(v=1):
12635 r"""get_ones_vector_1d(double v=1) -> Vector1D"""
12636 return _IMP_algebra.get_ones_vector_1d(v)
12638 def get_ones_vector_2d(v=1):
12639 r"""get_ones_vector_2d(double v=1) -> Vector2D"""
12640 return _IMP_algebra.get_ones_vector_2d(v)
12642 def get_ones_vector_3d(v=1):
12643 r"""get_ones_vector_3d(double v=1) -> Vector3D"""
12644 return _IMP_algebra.get_ones_vector_3d(v)
12646 def get_ones_vector_4d(v=1):
12647 r"""get_ones_vector_4d(double v=1) -> Vector4D"""
12648 return _IMP_algebra.get_ones_vector_4d(v)
12650 def get_ones_vector_5d(v=1):
12651 r"""get_ones_vector_5d(double v=1) -> Vector5D"""
12652 return _IMP_algebra.get_ones_vector_5d(v)
12654 def get_ones_vector_6d(v=1):
12655 r"""get_ones_vector_6d(double v=1) -> Vector6D"""
12656 return _IMP_algebra.get_ones_vector_6d(v)
12658 def get_unit_bounding_box_1d():
12659 r"""get_unit_bounding_box_1d() -> BoundingBox1D"""
12660 return _IMP_algebra.get_unit_bounding_box_1d()
12662 def get_unit_bounding_box_2d():
12663 r"""get_unit_bounding_box_2d() -> BoundingBox2D"""
12664 return _IMP_algebra.get_unit_bounding_box_2d()
12666 def get_unit_bounding_box_3d():
12667 r"""get_unit_bounding_box_3d() -> BoundingBox3D"""
12668 return _IMP_algebra.get_unit_bounding_box_3d()
12670 def get_unit_bounding_box_4d():
12671 r"""get_unit_bounding_box_4d() -> BoundingBox4D"""
12672 return _IMP_algebra.get_unit_bounding_box_4d()
12674 def get_unit_bounding_box_5d():
12675 r"""get_unit_bounding_box_5d() -> BoundingBox5D"""
12676 return _IMP_algebra.get_unit_bounding_box_5d()
12678 def get_unit_bounding_box_6d():
12679 r"""get_unit_bounding_box_6d() -> BoundingBox6D"""
12680 return _IMP_algebra.get_unit_bounding_box_6d()
12682 def get_cube_1d(radius):
12683 r"""get_cube_1d(double radius) -> BoundingBox1D"""
12684 return _IMP_algebra.get_cube_1d(radius)
12686 def get_cube_2d(radius):
12687 r"""get_cube_2d(double radius) -> BoundingBox2D"""
12688 return _IMP_algebra.get_cube_2d(radius)
12690 def get_cube_3d(radius):
12691 r"""get_cube_3d(double radius) -> BoundingBox3D"""
12692 return _IMP_algebra.get_cube_3d(radius)
12694 def get_cube_4d(radius):
12695 r"""get_cube_4d(double radius) -> BoundingBox4D"""
12696 return _IMP_algebra.get_cube_4d(radius)
12698 def get_cube_5d(radius):
12699 r"""get_cube_5d(double radius) -> BoundingBox5D"""
12700 return _IMP_algebra.get_cube_5d(radius)
12702 def get_cube_6d(radius):
12703 r"""get_cube_6d(double radius) -> BoundingBox6D"""
12704 return _IMP_algebra.get_cube_6d(radius)
12706 def get_unit_sphere_1d():
12707 r"""get_unit_sphere_1d() -> Sphere1D"""
12708 return _IMP_algebra.get_unit_sphere_1d()
12710 def get_unit_sphere_2d():
12711 r"""get_unit_sphere_2d() -> Sphere2D"""
12712 return _IMP_algebra.get_unit_sphere_2d()
12714 def get_unit_sphere_3d():
12715 r"""get_unit_sphere_3d() -> Sphere3D"""
12716 return _IMP_algebra.get_unit_sphere_3d()
12718 def get_unit_sphere_4d():
12719 r"""get_unit_sphere_4d() -> Sphere4D"""
12720 return _IMP_algebra.get_unit_sphere_4d()
12722 def get_unit_sphere_5d():
12723 r"""get_unit_sphere_5d() -> Sphere5D"""
12724 return _IMP_algebra.get_unit_sphere_5d()
12726 def get_unit_sphere_6d():
12727 r"""get_unit_sphere_6d() -> Sphere6D"""
12728 return _IMP_algebra.get_unit_sphere_6d()
12732 get_interiors_intersect(Sphere1D a, Sphere1D b) -> bool
12733 get_interiors_intersect(Sphere2D a, Sphere2D b) -> bool
12734 get_interiors_intersect(Sphere3D a, Sphere3D b) -> bool
12735 get_interiors_intersect(Sphere4D a, Sphere4D b) -> bool
12736 get_interiors_intersect(Sphere5D a, Sphere5D b) -> bool
12737 get_interiors_intersect(Sphere6D a, Sphere6D b) -> bool
12738 get_interiors_intersect(SphereKD a, SphereKD b) -> bool
12739 get_interiors_intersect(BoundingBox1D a, BoundingBox1D b) -> bool
12740 get_interiors_intersect(BoundingBox2D a, BoundingBox2D b) -> bool
12741 get_interiors_intersect(BoundingBox3D a, BoundingBox3D b) -> bool
12742 get_interiors_intersect(BoundingBox4D a, BoundingBox4D b) -> bool
12743 get_interiors_intersect(BoundingBox5D a, BoundingBox5D b) -> bool
12744 get_interiors_intersect(BoundingBox6D a, BoundingBox6D b) -> bool
12745 get_interiors_intersect(BoundingBoxKD a, BoundingBoxKD b) -> bool
12747 return _IMP_algebra.get_interiors_intersect(*args)
12751 get_random_vector_on(Sphere1D a) -> Vector1D
12752 get_random_vector_on(Sphere2D a) -> Vector2D
12753 get_random_vector_on(Sphere3D a) -> Vector3D
12754 get_random_vector_on(Sphere4D a) -> Vector4D
12755 get_random_vector_on(Sphere5D a) -> Vector5D
12756 get_random_vector_on(Sphere6D a) -> Vector6D
12757 get_random_vector_on(SphereKD a) -> VectorKD
12758 get_random_vector_on(UnitSimplex1D a) -> Vector1D
12759 get_random_vector_on(UnitSimplex2D a) -> Vector2D
12760 get_random_vector_on(UnitSimplex3D a) -> Vector3D
12761 get_random_vector_on(UnitSimplex4D a) -> Vector4D
12762 get_random_vector_on(UnitSimplex5D a) -> Vector5D
12763 get_random_vector_on(UnitSimplex6D a) -> Vector6D
12764 get_random_vector_on(UnitSimplexKD a) -> VectorKD
12765 get_random_vector_on(BoundingBox1D a) -> Vector1D
12766 get_random_vector_on(BoundingBox2D a) -> Vector2D
12767 get_random_vector_on(BoundingBox3D a) -> Vector3D
12768 get_random_vector_on(BoundingBox4D a) -> Vector4D
12769 get_random_vector_on(BoundingBox5D a) -> Vector5D
12770 get_random_vector_on(BoundingBox6D a) -> Vector6D
12771 get_random_vector_on(BoundingBoxKD a) -> VectorKD
12773 return _IMP_algebra.get_random_vector_on(*args)
12777 get_random_vector_in(Cylinder3D c) -> Vector3D
12778 get_random_vector_in(Sphere1D a) -> Vector1D
12779 get_random_vector_in(Sphere2D a) -> Vector2D
12780 get_random_vector_in(Sphere3D a) -> Vector3D
12781 get_random_vector_in(Sphere4D a) -> Vector4D
12782 get_random_vector_in(Sphere5D a) -> Vector5D
12783 get_random_vector_in(Sphere6D a) -> Vector6D
12784 get_random_vector_in(SphereKD a) -> VectorKD
12785 get_random_vector_in(BoundingBox1D a) -> Vector1D
12786 get_random_vector_in(BoundingBox2D a) -> Vector2D
12787 get_random_vector_in(BoundingBox3D a) -> Vector3D
12788 get_random_vector_in(BoundingBox4D a) -> Vector4D
12789 get_random_vector_in(BoundingBox5D a) -> Vector5D
12790 get_random_vector_in(BoundingBox6D a) -> Vector6D
12791 get_random_vector_in(BoundingBoxKD a) -> VectorKD
12793 return _IMP_algebra.get_random_vector_in(*args)
12797 get_intersection(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12798 get_intersection(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12799 get_intersection(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12800 get_intersection(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12801 get_intersection(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12802 get_intersection(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12803 get_intersection(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12805 return _IMP_algebra.get_intersection(*args)
12809 get_union(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12810 get_union(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12811 get_union(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12812 get_union(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12813 get_union(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12814 get_union(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12815 get_union(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12817 return _IMP_algebra.get_union(*args)
12819 def get_bounding_box(*args):
12821 get_bounding_box(Line3D g) -> BoundingBox3D
12822 get_bounding_box(Segment3D g) -> BoundingBox3D
12823 get_bounding_box(Plane3D g) -> BoundingBox3D
12824 get_bounding_box(Cylinder3D g) -> BoundingBox3D
12825 get_bounding_box(Ellipsoid3D g) -> BoundingBox3D
12826 get_bounding_box(SpherePatch3D g) -> BoundingBox3D
12827 get_bounding_box(Cone3D g) -> BoundingBox3D
12828 get_bounding_box(Sphere1D a) -> BoundingBox1D
12829 get_bounding_box(Sphere2D a) -> BoundingBox2D
12830 get_bounding_box(Sphere3D a) -> BoundingBox3D
12831 get_bounding_box(Sphere4D a) -> BoundingBox4D
12832 get_bounding_box(Sphere5D a) -> BoundingBox5D
12833 get_bounding_box(Sphere6D a) -> BoundingBox6D
12834 get_bounding_box(SphereKD a) -> BoundingBoxKD
12836 return _IMP_algebra.get_bounding_box(*args)
12840 get_uniform_surface_cover(Cylinder3D cyl, int number_of_points) -> IMP::algebra::Vector3Ds
12841 get_uniform_surface_cover(SpherePatch3D sph, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12842 get_uniform_surface_cover(Cone3D cone, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12843 get_uniform_surface_cover(IMP::algebra::Sphere3Ds const & _in, double points_per_square_angstrom) -> IMP::algebra::Vector3Ds
12844 get_uniform_surface_cover(Sphere1D a, unsigned int const & b) -> IMP::algebra::Vector1Ds
12845 get_uniform_surface_cover(Sphere2D a, unsigned int const & b) -> IMP::algebra::Vector2Ds
12846 get_uniform_surface_cover(Sphere3D a, unsigned int const & b) -> IMP::algebra::Vector3Ds
12847 get_uniform_surface_cover(Sphere4D a, unsigned int const & b) -> IMP::algebra::Vector4Ds
12848 get_uniform_surface_cover(Sphere5D a, unsigned int const & b) -> IMP::algebra::Vector5Ds
12849 get_uniform_surface_cover(Sphere6D a, unsigned int const & b) -> IMP::algebra::Vector6Ds
12850 get_uniform_surface_cover(SphereKD a, unsigned int const & b) -> IMP::algebra::VectorKDs
12852 return _IMP_algebra.get_uniform_surface_cover(*args)
12856 get_grid_interior_cover_by_spacing(BoundingBox1D a, double const & b) -> IMP::algebra::Vector1Ds
12857 get_grid_interior_cover_by_spacing(BoundingBox2D a, double const & b) -> IMP::algebra::Vector2Ds
12858 get_grid_interior_cover_by_spacing(BoundingBox3D a, double const & b) -> IMP::algebra::Vector3Ds
12859 get_grid_interior_cover_by_spacing(BoundingBox4D a, double const & b) -> IMP::algebra::Vector4Ds
12860 get_grid_interior_cover_by_spacing(BoundingBox5D a, double const & b) -> IMP::algebra::Vector5Ds
12861 get_grid_interior_cover_by_spacing(BoundingBox6D a, double const & b) -> IMP::algebra::Vector6Ds
12862 get_grid_interior_cover_by_spacing(BoundingBoxKD a, double const & b) -> IMP::algebra::VectorKDs
12864 return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
12868 get_projected(Line3D l, Vector3D p) -> Vector3D
12869 get_projected(Line3D l, Segment3D s) -> Segment3D
12870 get_projected(UnitSimplex1D a, Vector1D b) -> Vector1D
12871 get_projected(UnitSimplex2D a, Vector2D b) -> Vector2D
12872 get_projected(UnitSimplex3D a, Vector3D b) -> Vector3D
12873 get_projected(UnitSimplex4D a, Vector4D b) -> Vector4D
12874 get_projected(UnitSimplex5D a, Vector5D b) -> Vector5D
12875 get_projected(UnitSimplex6D a, Vector6D b) -> Vector6D
12876 get_projected(UnitSimplexKD a, VectorKD b) -> VectorKD
12878 return _IMP_algebra.get_projected(*args)
12882 get_vertices(BoundingBox1D a) -> IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > >
12883 get_vertices(BoundingBox2D a) -> IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > >
12884 get_vertices(BoundingBox3D a) -> IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > >
12885 get_vertices(BoundingBox4D a) -> IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > >
12886 get_vertices(BoundingBox5D a) -> IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > >
12887 get_vertices(BoundingBox6D a) -> IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > >
12888 get_vertices(BoundingBoxKD a) -> IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > >
12889 get_vertices(UnitSimplex1D a) -> IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > >
12890 get_vertices(UnitSimplex2D a) -> IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > >
12891 get_vertices(UnitSimplex3D a) -> IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > >
12892 get_vertices(UnitSimplex4D a) -> IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > >
12893 get_vertices(UnitSimplex5D a) -> IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > >
12894 get_vertices(UnitSimplex6D a) -> IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > >
12895 get_vertices(UnitSimplexKD a) -> IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > >
12897 return _IMP_algebra.get_vertices(*args)
12901 get_increasing_from_embedded(UnitSimplex1D a, Vector1D b) -> Vector1D
12902 get_increasing_from_embedded(UnitSimplex2D a, Vector2D b) -> Vector2D
12903 get_increasing_from_embedded(UnitSimplex3D a, Vector3D b) -> Vector3D
12904 get_increasing_from_embedded(UnitSimplex4D a, Vector4D b) -> Vector4D
12905 get_increasing_from_embedded(UnitSimplex5D a, Vector5D b) -> Vector5D
12906 get_increasing_from_embedded(UnitSimplex6D a, Vector6D b) -> Vector6D
12907 get_increasing_from_embedded(UnitSimplexKD a, VectorKD b) -> VectorKD
12909 return _IMP_algebra.get_increasing_from_embedded(*args)
12913 get_embedded_from_increasing(UnitSimplex1D a, Vector1D b) -> Vector1D
12914 get_embedded_from_increasing(UnitSimplex2D a, Vector2D b) -> Vector2D
12915 get_embedded_from_increasing(UnitSimplex3D a, Vector3D b) -> Vector3D
12916 get_embedded_from_increasing(UnitSimplex4D a, Vector4D b) -> Vector4D
12917 get_embedded_from_increasing(UnitSimplex5D a, Vector5D b) -> Vector5D
12918 get_embedded_from_increasing(UnitSimplex6D a, Vector6D b) -> Vector6D
12919 get_embedded_from_increasing(UnitSimplexKD a, VectorKD b) -> VectorKD
12921 return _IMP_algebra.get_embedded_from_increasing(*args)
12922 class _AxisAnglePair(object):
12923 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,double > class."""
12925 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12926 __repr__ = _swig_repr
12928 def __init__(self, *args):
12930 __init__(_AxisAnglePair self) -> _AxisAnglePair
12931 __init__(_AxisAnglePair self, Vector3D first, double second) -> _AxisAnglePair
12932 __init__(_AxisAnglePair self, _AxisAnglePair other) -> _AxisAnglePair
12934 _IMP_algebra._AxisAnglePair_swiginit(self, _IMP_algebra.new__AxisAnglePair(*args))
12935 first = property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
12936 second = property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set, doc=
r"""second : double""")
12939 def __repr__(self):
12940 return str((self.first, self.second))
12941 def __getitem__(self, index):
12942 if not (index % 2):
12946 def __setitem__(self, index, val):
12947 if not (index % 2):
12951 __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
12954 _IMP_algebra._AxisAnglePair_swigregister(_AxisAnglePair)
12957 r"""get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 >,std::allocator< IMP::algebra::VectorD< 3 > > > const & source, IMP::Vector< IMP::algebra::VectorD< 3 >,std::allocator< IMP::algebra::VectorD< 3 > > > const & target) -> Transformation3D"""
12958 return _IMP_algebra.get_transformation_aligning_first_to_second(source, target)
12959 class _RotatedVector3DAdjoint(object):
12960 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,IMP::algebra::VectorD< 4 > > class."""
12962 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12963 __repr__ = _swig_repr
12965 def __init__(self, *args):
12967 __init__(_RotatedVector3DAdjoint self) -> _RotatedVector3DAdjoint
12968 __init__(_RotatedVector3DAdjoint self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
12969 __init__(_RotatedVector3DAdjoint self, _RotatedVector3DAdjoint other) -> _RotatedVector3DAdjoint
12971 _IMP_algebra._RotatedVector3DAdjoint_swiginit(self, _IMP_algebra.new__RotatedVector3DAdjoint(*args))
12972 first = property(_IMP_algebra._RotatedVector3DAdjoint_first_get, _IMP_algebra._RotatedVector3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
12973 second = property(_IMP_algebra._RotatedVector3DAdjoint_second_get, _IMP_algebra._RotatedVector3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(4)>""")
12976 def __repr__(self):
12977 return str((self.first, self.second))
12978 def __getitem__(self, index):
12979 if not (index % 2):
12983 def __setitem__(self, index, val):
12984 if not (index % 2):
12988 __swig_destroy__ = _IMP_algebra.delete__RotatedVector3DAdjoint
12991 _IMP_algebra._RotatedVector3DAdjoint_swigregister(_RotatedVector3DAdjoint)
12992 class _ComposeRotation3DAdjoint(object):
12993 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 4 > > class."""
12995 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12996 __repr__ = _swig_repr
12998 def __init__(self, *args):
13000 __init__(_ComposeRotation3DAdjoint self) -> _ComposeRotation3DAdjoint
13001 __init__(_ComposeRotation3DAdjoint self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
13002 __init__(_ComposeRotation3DAdjoint self, _ComposeRotation3DAdjoint other) -> _ComposeRotation3DAdjoint
13004 _IMP_algebra._ComposeRotation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeRotation3DAdjoint(*args))
13005 first = property(_IMP_algebra._ComposeRotation3DAdjoint_first_get, _IMP_algebra._ComposeRotation3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(4)>""")
13006 second = property(_IMP_algebra._ComposeRotation3DAdjoint_second_get, _IMP_algebra._ComposeRotation3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(4)>""")
13009 def __repr__(self):
13010 return str((self.first, self.second))
13011 def __getitem__(self, index):
13012 if not (index % 2):
13016 def __setitem__(self, index, val):
13017 if not (index % 2):
13021 __swig_destroy__ = _IMP_algebra.delete__ComposeRotation3DAdjoint
13024 _IMP_algebra._ComposeRotation3DAdjoint_swigregister(_ComposeRotation3DAdjoint)
13025 class _Transformation3DAdjoint(object):
13026 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > class."""
13028 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13029 __repr__ = _swig_repr
13031 def __init__(self, *args):
13033 __init__(_Transformation3DAdjoint self) -> _Transformation3DAdjoint
13034 __init__(_Transformation3DAdjoint self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
13035 __init__(_Transformation3DAdjoint self, _Transformation3DAdjoint other) -> _Transformation3DAdjoint
13037 _IMP_algebra._Transformation3DAdjoint_swiginit(self, _IMP_algebra.new__Transformation3DAdjoint(*args))
13038 first = property(_IMP_algebra._Transformation3DAdjoint_first_get, _IMP_algebra._Transformation3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(4)>""")
13039 second = property(_IMP_algebra._Transformation3DAdjoint_second_get, _IMP_algebra._Transformation3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(3)>""")
13042 def __repr__(self):
13043 return str((self.first, self.second))
13044 def __getitem__(self, index):
13045 if not (index % 2):
13049 def __setitem__(self, index, val):
13050 if not (index % 2):
13054 __swig_destroy__ = _IMP_algebra.delete__Transformation3DAdjoint
13057 _IMP_algebra._Transformation3DAdjoint_swigregister(_Transformation3DAdjoint)
13058 class _TransformedVector3DAdjoint(object):
13059 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > > class."""
13061 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13062 __repr__ = _swig_repr
13064 def __init__(self, *args):
13066 __init__(_TransformedVector3DAdjoint self) -> _TransformedVector3DAdjoint
13067 __init__(_TransformedVector3DAdjoint self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
13068 __init__(_TransformedVector3DAdjoint self, _TransformedVector3DAdjoint other) -> _TransformedVector3DAdjoint
13070 _IMP_algebra._TransformedVector3DAdjoint_swiginit(self, _IMP_algebra.new__TransformedVector3DAdjoint(*args))
13071 first = property(_IMP_algebra._TransformedVector3DAdjoint_first_get, _IMP_algebra._TransformedVector3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
13072 second = property(_IMP_algebra._TransformedVector3DAdjoint_second_get, _IMP_algebra._TransformedVector3DAdjoint_second_set, doc=
r"""second : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13075 def __repr__(self):
13076 return str((self.first, self.second))
13077 def __getitem__(self, index):
13078 if not (index % 2):
13082 def __setitem__(self, index, val):
13083 if not (index % 2):
13087 __swig_destroy__ = _IMP_algebra.delete__TransformedVector3DAdjoint
13090 _IMP_algebra._TransformedVector3DAdjoint_swigregister(_TransformedVector3DAdjoint)
13091 class _ComposeTransformation3DAdjoint(object):
13092 r"""Proxy of C++ std::pair< std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > >,std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > > class."""
13094 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13095 __repr__ = _swig_repr
13097 def __init__(self, *args):
13099 __init__(_ComposeTransformation3DAdjoint self) -> _ComposeTransformation3DAdjoint
13100 __init__(_ComposeTransformation3DAdjoint self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
13101 __init__(_ComposeTransformation3DAdjoint self, _ComposeTransformation3DAdjoint other) -> _ComposeTransformation3DAdjoint
13103 _IMP_algebra._ComposeTransformation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeTransformation3DAdjoint(*args))
13104 first = property(_IMP_algebra._ComposeTransformation3DAdjoint_first_get, _IMP_algebra._ComposeTransformation3DAdjoint_first_set, doc=
r"""first : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13105 second = property(_IMP_algebra._ComposeTransformation3DAdjoint_second_get, _IMP_algebra._ComposeTransformation3DAdjoint_second_set, doc=
r"""second : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13108 def __repr__(self):
13109 return str((self.first, self.second))
13110 def __getitem__(self, index):
13111 if not (index % 2):
13115 def __setitem__(self, index, val):
13116 if not (index % 2):
13120 __swig_destroy__ = _IMP_algebra.delete__ComposeTransformation3DAdjoint
13123 _IMP_algebra._ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)
13126 r"""get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13127 return _IMP_algebra.get_rmsd_transforming_first(tr, v0, v1)
13130 r"""get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13131 return _IMP_algebra.get_rmsd(v0, v1)
13133 def get_weighted_rmsd_transforming_first(tr, v0, v1, weights):
13134 r"""get_weighted_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13135 return _IMP_algebra.get_weighted_rmsd_transforming_first(tr, v0, v1, weights)
13138 r"""get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13139 return _IMP_algebra.get_weighted_rmsd(v0, v1, weights)
13141 LinearFit=LinearFit2D
13142 ParabolicFit=ParabolicFit2D
13146 r"""get_module_version() -> std::string const"""
13147 return _IMP_algebra.get_module_version()
13150 r"""get_example_path(std::string fname) -> std::string"""
13151 return _IMP_algebra.get_example_path(fname)
13154 r"""get_data_path(std::string fname) -> std::string"""
13155 return _IMP_algebra.get_data_path(fname)
13157 from .
import _version_check
bool get_is_big_endian()
Returns 1 if machine is big endian else 0.
BoundingBoxD<-1 > BoundingBoxKD
Typedef for Python.
Rotation3D get_rotation_about_normalized_axis(const Vector3D &axis_norm, double angle)
double get_height(const Surface &s, const XYZR &d)
Get height of sphere above surface.
Transformation2D get_transformation_aligning_pair(const Vector2Ds &set_from, const Vector2Ds &set_to)
Grid3D< float, DenseGridStorage3D< float > > DenseFloatGrid3D
SphereD< 4 > Sphere4D
Typedef for Python.
SphereD< 3 > Sphere3D
Typedef for Python.
VectorD< D > get_random_vector_on(const BoundingBoxD< D > &bb)
Generate a random vector on a box with uniform density.
void write_pts(const Vector3Ds &vs, TextOutput out)
Write a set of 3D vectors to a file.
Grid3D< int, SparseGridStorage3D< int, UnboundedGridStorage3D > > SparseUnboundedIntGrid3D
Rotation3D get_rotation_from_x_y_axes(const Vector3D &x, const Vector3D &y)
BoundingBoxD< 3 > BoundingBox3D
Typedef for Python.
Rotation3D get_rotation_from_fixed_xyz(double xr, double yr, double zr)
Initialize a rotation in x-y-z order from three angles.
void compose_adjoint(const Rotation3D &A, const Rotation3D &B, Vector4D DC, Rotation3DAdjoint *DA, Rotation3DAdjoint *DB)
Get adjoint of inputs to compose from adjoint of output.
VectorD< 3 > get_random_vector_on_unit_sphere()
DenseGrid3D< double > get_rasterized(const Gaussian3Ds &gmm, const Floats &weights, double cell_width, const BoundingBox3D &bb)
Rasterize the Gaussians to a grid.
Vector3Ds get_random_chain(unsigned int n, double r, const Vector3D &start=Vector3D(0, 0, 0), const Sphere3Ds &obstacles=Sphere3Ds())
Generate a random chain with no collisions.
VectorD< D > get_zero_vector_kd(int Di)
Return a dynamically sized vector of zeros.
Rotation2D compose(const Rotation2D &a, const Rotation2D &b)
Compose two rotations a and b.
Sphere3D get_enclosing_sphere(const Sphere3Ds &ss)
Return a sphere containing the listed spheres.
Vector< VectorD< D > > get_uniform_surface_cover(const SphereD< D > &s, unsigned int n)
Generate a set of vectors which covers a sphere uniformly.
algebra::Rotation3Ds get_uniformly_sampled_rotations(double delta)
Generates a nondegenerate set of Euler angles with a delta resolution.
Vector< VectorD< D > > get_vertices(const BoundingBoxD< D > &bb)
Return a list of the 2^D bounding points for the bounding box.
bool get_is_little_endian()
Returns 1 if machine is little endian else 0.
Triangle3D get_largest_triangle(const Vector3Ds &points)
Return the largest triangle defined by 3 points from the input.
An exception for an invalid usage of IMP.
Make CGAL functionality available to IMP.
Gaussian3D get_gaussian_from_covariance(const Eigen::Matrix3d &covariance, const Vector3D ¢er)
Return a Gaussian centered at the origin from a covariance matrix.
IntPairs get_edges(const BoundingBoxD< 3 > &)
Return the edges of the box as indices into the vertices list.
double get_area(const Geometry &)
Compute the area of any surface object.
BoundingBoxD< 5 > BoundingBox5D
Typedef for Python.
SphereD< 2 > Sphere2D
Typedef for Python.
BoundingBoxD< D > get_union(BoundingBoxD< D > a, const BoundingBoxD< D > &b)
Return the union bounding box.
double get_squared_distance(const VectorD< D > &v1, const VectorD< D > &v2)
Compute the squared distance between two vectors.
VT get_unit_vector(VT vt)
Returns a unit vector pointing at the same direction as this vector.
Transformation3D get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri)
Return a transformation between two triangles.
double get_ball_radius_from_volume_3d(double volume)
Return the radius of a sphere with a given volume.
double get_weighted_rmsd(const Vector3DsOrXYZs0 &m1, const Vector3DsOrXYZs1 &m2, const Floats &weights)
Vector3D get_reflected(const Plane3D &pln, const Vector3D &p)
Return the point reflected about the plane.
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
Grid3D< double, DenseGridStorage3D< double > > DenseDoubleGrid3D
Atom get_atom(Residue rd, AtomType at)
Return a particle atom from the residue.
Eigen::MatrixXd get_jacobian_of_composed_wrt_first(const Rotation3D &q, const Rotation3D &p, bool wrt_unnorm=false)
Get gradient of quaternion product with respect to first quaternion.
VectorD< D > get_basis_vector_kd(int Di, unsigned int coordinate)
Return the basis vector for the given coordinate.
double get_angle(const Line3D &a, const Line3D &b)
Get angle in radians between two lines around their closest points.
VectorD< D > get_ones_vector_kd(unsigned int Di, double v=1)
Return a vector of ones (or another constant)
BoundingBoxD< 2 > BoundingBox2D
Typedef for Python.
Rotation3D get_rotation_about_axis(const Vector3D &axis, double angle)
Generate a Rotation3D object from a rotation around an axis.
Segment3D get_shortest_segment(const Segment3D &s, const Vector3D &p)
Vector3Ds read_pts(TextInput input)
Read a set of 3D vectors from a file.
BoundingBoxD< D > get_intersection(const BoundingBoxD< D > &a, const BoundingBoxD< D > &b)
Return the intersecting bounding box.
IMP::algebra::Transformation3D get_transformation_aligning_first_to_second(const Vector3DsOrXYZs0 &source, const Vector3DsOrXYZs1 &target)
Compute the rigid transform bringing the first point set to the second.
Transformation2D get_rotation_about_point(const Vector2D &point, const Rotation2D &rotation)
Generate a Transformation2D object from a rotation around a point.
double get_volume(const BoundingBoxD< D > &bb)
See BoundingBoxD.
Rotation3D get_random_rotation_3d()
Pick a rotation at random from all possible rotations.
Vector3D get_vector_product(const Vector3D &p1, const Vector3D &p2)
Return the vector product (cross product) of two vectors.
bool get_interiors_intersect(const BoundingBoxD< D > &a, const BoundingBoxD< D > &b)
Return true if they intersect.
VectorD< D > get_increasing_from_embedded(const UnitSimplexD< D > &s, const VectorD< D > &p)
Convert point on simplex from embedded to increasing coordinates.
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
Common base class for heavy weight IMP objects.
VectorD< D > get_embedded_from_increasing(const UnitSimplexD< D > &s, const VectorD< D > &p)
Convert point on simplex from increasing to embedded coordinates.
FixedXYZ get_fixed_xyz_from_rotation(const Rotation3D &r)
The inverse of rotation_from_fixed_xyz()
bool get_are_colinear(const Vector3D &p1, const Vector3D &p2, const Vector3D &p3)
Return true if the three points are co-linear.
BoundingBoxD< 4 > BoundingBox4D
Typedef for Python.
Rotation2D get_identity_rotation_2d()
Build an identity rotation in 2D.
Sphere3Ds read_spheres(TextInput input)
Read a set of 3D spheres from a file.
Vector3D get_projected(const Line3D &l, const Vector3D &p)
Project a point onto the line.
Rotation3D get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi)
Generate a rotation object from Euler Angles.
SphereD< 6 > Sphere6D
Typedef for Python.
double get_rmsd(const Vector3DsOrXYZs0 &m1, const Vector3DsOrXYZs1 &m2)
VectorD< D > get_random_vector_in(const BoundingBoxD< D > &bb)
Generate a random vector in a box with uniform density.
SphereD< 5 > Sphere5D
Typedef for Python.
BoundingBoxD<-1 > get_unit_bounding_box_kd(unsigned int d)
Box with radius one.
Version and module information for Objects.
double get_radius_of_gyration(const Vector3Ds &ps)
Return the radius of gyration of a set of points.
std::pair< Vector3D, double > get_axis_and_angle(const Rotation3D &rot)
Decompose a Rotation3D object into a rotation around an axis.
FloatPair get_surface_area_and_volume(const algebra::Sphere3Ds &ss)
Get surface area & volume of the union of the balls bounded by the spheres.
Transformation3Ds get_alignments_from_first_to_second(const PrincipalComponentAnalysisD< 3 > &pca1, const PrincipalComponentAnalysisD< 3 > &pca2)
Get all alignments of the first principal component system to the second one.
SphereD< 1 > Sphere1D
Typedef for Python.
Rotation3D get_interpolated(const Rotation3D &a, const Rotation3D &b, double f)
Interpolate between two rotations.
Rotation3D get_rotation_from_vector4d(const VectorD< 4 > &v)
Compute a rotation from an unnormalized quaternion.
BoundingBoxD<-1 > get_cube_kd(unsigned int d, double radius)
Cube with radius of length side.
Rotation3D get_rotation_taking_first_to_second(const Vector3D &v1, const Vector3D &v2)
Create a rotation from the first vector to the second one.
Rotation3Ds get_uniform_cover_rotations_3d(unsigned int num_points)
Cover the space of rotations evenly.
PrincipalComponentAnalysisD< D > get_principal_components(const Vector< VectorD< D > > &ps)
Perform principal components analysis on a set of vectors.
Rotation2D get_rotation_to_x_axis(const Vector2D &v)
Vector3D get_centroid(const Vector3Ds &ps)
Return the centroid of a set of vectors.
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
Transformation3D get_identity_transformation_3d()
Return a transformation that does not do anything.
Eigen::MatrixXd get_jacobian_of_composed_wrt_second(const Rotation3D &q, const Rotation3D &p, bool wrt_unnorm=false)
Get Jacobian of quaternion product with respect to second quaternion.
void reversed_read(void *dest, size_t size, size_t nitems, std::ifstream &f, bool reverse)
Reads from file in normal or reverse order.
Rotation3D get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)
Generate a Rotation3D object from a rotation matrix.
Transformation3D get_transformation_3d(const Transformation2D &t2d)
Build a 3D transformation from a 2D one.
double get_relative_projection_on_segment(const Segment3D &s, const algebra::Vector3D &p)
Return the 'relative' projection of a point p onto the line that contains s.
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
Eigen::Matrix3d get_covariance(const Gaussian3D &g)
Rotation3D get_identity_rotation_3d()
Return a rotation that does not do anything.
void write_spheres(const Sphere3Ds &vs, TextOutput out)
Write a set of 3D spheres to a file.
Sphere3Ds get_simplified_from_volume(Sphere3Ds in, double maximum_allowed_error_angstroms)
Get a set of balls that approximates the surface of the passed set.
void reversed_write(const void *src, size_t size, size_t nitems, std::ofstream &f, bool reverse=false)
Writes to a file in normal or reversed order.
algebra::Segment3D get_segment_connecting_first_to_second(const Line3D &a, const Line3D &b)
Get shortest possible segment from the first line to the second.
Vector< VectorD< D > > get_grid_interior_cover_by_spacing(const BoundingBoxD< D > &bb, double s)
DenseGrid3D< double > get_rasterized_fast(const Gaussian3Ds &gmm, const Floats &weights, double cell_width, const BoundingBox3D &bb, double factor=2.5)
Rasterize the Gaussians to a grid.
Vector3D get_orthogonal_vector(const Vector3D &v)
Return a vector that is perpendicular to the given vector.
double get_surface_area(const Geometry &)
Compute the surface area of any volumetric object.
double get_rmsd_transforming_first(const Transformation3D &tr, const Vector3DsOrXYZs0 &m1, const Vector3DsOrXYZs1 &m2)
Calculate the root mean square deviation between two sets of 3D points.
BoundingBoxD< 6 > BoundingBox6D
Typedef for Python.
SphereD<-1 > SphereKD
Typedef for Python.
ParticleIndexes get_indexes(const ParticlesTemp &ps)
Get the indexes from a list of particles.
DensityMap * get_segment(DensityMap *map_to_segment, int nx_start, int nx_end, int ny_start, int ny_end, int nz_start, int nz_end)
Get a segment of the map according to xyz indexes.
Vector3Ds get_grid_surface_cover(const Cylinder3D &cyl, int number_of_cycles, int number_of_points_on_cycle)
Generate a grid of 3d points on a cylinder surface.
Rotation3D get_rotation_from_fixed_zxz(double phi, double theta, double psi)
Initialize a rotation from Euler angles.
BoundingBoxD< 1 > BoundingBox1D
Typedef for Python.
double get_distance(const Line3D &s, const Vector3D &p)
Get closest distance between a line and a point.
Transformation3D get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26)
Get a local transformation.
Transformation2D get_identity_transformation_2d()
Return a transformation that does not do anything.
std::string get_module_version()
Return the version of this module, as a string.
ConnollySurfacePoints get_connolly_surface(const algebra::Sphere3Ds &spheres, double density, double probe_radius)
Rotation2D get_random_rotation_2d()
Build an identity rotation in 2D.