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)
1337 def __mul__(self, o):
1338 r"""__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1339 return _IMP_algebra._VectorBaseKD___mul__(self, o)
1341 def __iadd__(self, o):
1342 r"""__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1343 return _IMP_algebra._VectorBaseKD___iadd__(self, o)
1345 def __isub__(self, o):
1346 r"""__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1347 return _IMP_algebra._VectorBaseKD___isub__(self, o)
1349 def __itruediv__(self, *args):
1350 return _IMP_algebra._VectorBaseKD___itruediv__(self, *args)
1351 __idiv__ = __itruediv__
1355 def __imul__(self, f):
1356 r"""__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1357 return _IMP_algebra._VectorBaseKD___imul__(self, f)
1359 def show(self, *args):
1361 show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
1362 show(_VectorBaseKD self, _ostream out=std::cout)
1364 return _IMP_algebra._VectorBaseKD_show(self, *args)
1366 def get_dimension(self):
1367 r"""get_dimension(_VectorBaseKD self) -> unsigned int"""
1368 return _IMP_algebra._VectorBaseKD_get_dimension(self)
1369 __swig_destroy__ = _IMP_algebra.delete__VectorBaseKD
1372 _IMP_algebra._VectorBaseKD_swigregister(_VectorBaseKD)
1373 class _VectorBase1D(_GeometricPrimitive1D):
1374 r"""Proxy of C++ IMP::algebra::VectorBaseD< 1 > class."""
1376 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1377 __repr__ = _swig_repr
1380 r"""__init__(_VectorBase1D self) -> _VectorBase1D"""
1381 _IMP_algebra._VectorBase1D_swiginit(self, _IMP_algebra.new__VectorBase1D())
1383 def get_scalar_product(self, o):
1384 r"""get_scalar_product(_VectorBase1D self, _VectorBase1D o) -> double"""
1385 return _IMP_algebra._VectorBase1D_get_scalar_product(self, o)
1387 def get_squared_magnitude(self):
1388 r"""get_squared_magnitude(_VectorBase1D self) -> double"""
1389 return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)
1391 def get_magnitude(self):
1392 r"""get_magnitude(_VectorBase1D self) -> double"""
1393 return _IMP_algebra._VectorBase1D_get_magnitude(self)
1395 def __mul__(self, o):
1396 r"""__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
1397 return _IMP_algebra._VectorBase1D___mul__(self, o)
1399 def __iadd__(self, o):
1400 r"""__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1401 return _IMP_algebra._VectorBase1D___iadd__(self, o)
1403 def __isub__(self, o):
1404 r"""__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1405 return _IMP_algebra._VectorBase1D___isub__(self, o)
1407 def __itruediv__(self, *args):
1408 return _IMP_algebra._VectorBase1D___itruediv__(self, *args)
1409 __idiv__ = __itruediv__
1413 def __imul__(self, f):
1414 r"""__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
1415 return _IMP_algebra._VectorBase1D___imul__(self, f)
1417 def show(self, *args):
1419 show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
1420 show(_VectorBase1D self, _ostream out=std::cout)
1422 return _IMP_algebra._VectorBase1D_show(self, *args)
1424 def get_dimension(self):
1425 r"""get_dimension(_VectorBase1D self) -> unsigned int"""
1426 return _IMP_algebra._VectorBase1D_get_dimension(self)
1427 __swig_destroy__ = _IMP_algebra.delete__VectorBase1D
1430 _IMP_algebra._VectorBase1D_swigregister(_VectorBase1D)
1431 class _VectorBase2D(_GeometricPrimitive2D):
1432 r"""Proxy of C++ IMP::algebra::VectorBaseD< 2 > class."""
1434 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1435 __repr__ = _swig_repr
1438 r"""__init__(_VectorBase2D self) -> _VectorBase2D"""
1439 _IMP_algebra._VectorBase2D_swiginit(self, _IMP_algebra.new__VectorBase2D())
1441 def get_scalar_product(self, o):
1442 r"""get_scalar_product(_VectorBase2D self, _VectorBase2D o) -> double"""
1443 return _IMP_algebra._VectorBase2D_get_scalar_product(self, o)
1445 def get_squared_magnitude(self):
1446 r"""get_squared_magnitude(_VectorBase2D self) -> double"""
1447 return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)
1449 def get_magnitude(self):
1450 r"""get_magnitude(_VectorBase2D self) -> double"""
1451 return _IMP_algebra._VectorBase2D_get_magnitude(self)
1453 def __mul__(self, o):
1454 r"""__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
1455 return _IMP_algebra._VectorBase2D___mul__(self, o)
1457 def __iadd__(self, o):
1458 r"""__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1459 return _IMP_algebra._VectorBase2D___iadd__(self, o)
1461 def __isub__(self, o):
1462 r"""__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1463 return _IMP_algebra._VectorBase2D___isub__(self, o)
1465 def __itruediv__(self, *args):
1466 return _IMP_algebra._VectorBase2D___itruediv__(self, *args)
1467 __idiv__ = __itruediv__
1471 def __imul__(self, f):
1472 r"""__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
1473 return _IMP_algebra._VectorBase2D___imul__(self, f)
1475 def show(self, *args):
1477 show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
1478 show(_VectorBase2D self, _ostream out=std::cout)
1480 return _IMP_algebra._VectorBase2D_show(self, *args)
1482 def get_dimension(self):
1483 r"""get_dimension(_VectorBase2D self) -> unsigned int"""
1484 return _IMP_algebra._VectorBase2D_get_dimension(self)
1485 __swig_destroy__ = _IMP_algebra.delete__VectorBase2D
1488 _IMP_algebra._VectorBase2D_swigregister(_VectorBase2D)
1489 class _VectorBase3D(_GeometricPrimitive3D):
1490 r"""Proxy of C++ IMP::algebra::VectorBaseD< 3 > class."""
1492 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1493 __repr__ = _swig_repr
1496 r"""__init__(_VectorBase3D self) -> _VectorBase3D"""
1497 _IMP_algebra._VectorBase3D_swiginit(self, _IMP_algebra.new__VectorBase3D())
1499 def get_scalar_product(self, o):
1500 r"""get_scalar_product(_VectorBase3D self, _VectorBase3D o) -> double"""
1501 return _IMP_algebra._VectorBase3D_get_scalar_product(self, o)
1503 def get_squared_magnitude(self):
1504 r"""get_squared_magnitude(_VectorBase3D self) -> double"""
1505 return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)
1507 def get_magnitude(self):
1508 r"""get_magnitude(_VectorBase3D self) -> double"""
1509 return _IMP_algebra._VectorBase3D_get_magnitude(self)
1511 def __mul__(self, o):
1512 r"""__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
1513 return _IMP_algebra._VectorBase3D___mul__(self, o)
1515 def __iadd__(self, o):
1516 r"""__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1517 return _IMP_algebra._VectorBase3D___iadd__(self, o)
1519 def __isub__(self, o):
1520 r"""__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1521 return _IMP_algebra._VectorBase3D___isub__(self, o)
1523 def __itruediv__(self, *args):
1524 return _IMP_algebra._VectorBase3D___itruediv__(self, *args)
1525 __idiv__ = __itruediv__
1529 def __imul__(self, f):
1530 r"""__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
1531 return _IMP_algebra._VectorBase3D___imul__(self, f)
1533 def show(self, *args):
1535 show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
1536 show(_VectorBase3D self, _ostream out=std::cout)
1538 return _IMP_algebra._VectorBase3D_show(self, *args)
1540 def get_dimension(self):
1541 r"""get_dimension(_VectorBase3D self) -> unsigned int"""
1542 return _IMP_algebra._VectorBase3D_get_dimension(self)
1543 __swig_destroy__ = _IMP_algebra.delete__VectorBase3D
1546 _IMP_algebra._VectorBase3D_swigregister(_VectorBase3D)
1547 class _VectorBase4D(_GeometricPrimitive4D):
1548 r"""Proxy of C++ IMP::algebra::VectorBaseD< 4 > class."""
1550 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1551 __repr__ = _swig_repr
1554 r"""__init__(_VectorBase4D self) -> _VectorBase4D"""
1555 _IMP_algebra._VectorBase4D_swiginit(self, _IMP_algebra.new__VectorBase4D())
1557 def get_scalar_product(self, o):
1558 r"""get_scalar_product(_VectorBase4D self, _VectorBase4D o) -> double"""
1559 return _IMP_algebra._VectorBase4D_get_scalar_product(self, o)
1561 def get_squared_magnitude(self):
1562 r"""get_squared_magnitude(_VectorBase4D self) -> double"""
1563 return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)
1565 def get_magnitude(self):
1566 r"""get_magnitude(_VectorBase4D self) -> double"""
1567 return _IMP_algebra._VectorBase4D_get_magnitude(self)
1569 def __mul__(self, o):
1570 r"""__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
1571 return _IMP_algebra._VectorBase4D___mul__(self, o)
1573 def __iadd__(self, o):
1574 r"""__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1575 return _IMP_algebra._VectorBase4D___iadd__(self, o)
1577 def __isub__(self, o):
1578 r"""__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1579 return _IMP_algebra._VectorBase4D___isub__(self, o)
1581 def __itruediv__(self, *args):
1582 return _IMP_algebra._VectorBase4D___itruediv__(self, *args)
1583 __idiv__ = __itruediv__
1587 def __imul__(self, f):
1588 r"""__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
1589 return _IMP_algebra._VectorBase4D___imul__(self, f)
1591 def show(self, *args):
1593 show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
1594 show(_VectorBase4D self, _ostream out=std::cout)
1596 return _IMP_algebra._VectorBase4D_show(self, *args)
1598 def get_dimension(self):
1599 r"""get_dimension(_VectorBase4D self) -> unsigned int"""
1600 return _IMP_algebra._VectorBase4D_get_dimension(self)
1601 __swig_destroy__ = _IMP_algebra.delete__VectorBase4D
1604 _IMP_algebra._VectorBase4D_swigregister(_VectorBase4D)
1605 class _VectorBase5D(_GeometricPrimitive5D):
1606 r"""Proxy of C++ IMP::algebra::VectorBaseD< 5 > class."""
1608 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1609 __repr__ = _swig_repr
1612 r"""__init__(_VectorBase5D self) -> _VectorBase5D"""
1613 _IMP_algebra._VectorBase5D_swiginit(self, _IMP_algebra.new__VectorBase5D())
1615 def get_scalar_product(self, o):
1616 r"""get_scalar_product(_VectorBase5D self, _VectorBase5D o) -> double"""
1617 return _IMP_algebra._VectorBase5D_get_scalar_product(self, o)
1619 def get_squared_magnitude(self):
1620 r"""get_squared_magnitude(_VectorBase5D self) -> double"""
1621 return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)
1623 def get_magnitude(self):
1624 r"""get_magnitude(_VectorBase5D self) -> double"""
1625 return _IMP_algebra._VectorBase5D_get_magnitude(self)
1627 def __mul__(self, o):
1628 r"""__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
1629 return _IMP_algebra._VectorBase5D___mul__(self, o)
1631 def __iadd__(self, o):
1632 r"""__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1633 return _IMP_algebra._VectorBase5D___iadd__(self, o)
1635 def __isub__(self, o):
1636 r"""__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1637 return _IMP_algebra._VectorBase5D___isub__(self, o)
1639 def __itruediv__(self, *args):
1640 return _IMP_algebra._VectorBase5D___itruediv__(self, *args)
1641 __idiv__ = __itruediv__
1645 def __imul__(self, f):
1646 r"""__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
1647 return _IMP_algebra._VectorBase5D___imul__(self, f)
1649 def show(self, *args):
1651 show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
1652 show(_VectorBase5D self, _ostream out=std::cout)
1654 return _IMP_algebra._VectorBase5D_show(self, *args)
1656 def get_dimension(self):
1657 r"""get_dimension(_VectorBase5D self) -> unsigned int"""
1658 return _IMP_algebra._VectorBase5D_get_dimension(self)
1659 __swig_destroy__ = _IMP_algebra.delete__VectorBase5D
1662 _IMP_algebra._VectorBase5D_swigregister(_VectorBase5D)
1663 class _VectorBase6D(_GeometricPrimitive6D):
1664 r"""Proxy of C++ IMP::algebra::VectorBaseD< 6 > class."""
1666 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1667 __repr__ = _swig_repr
1670 r"""__init__(_VectorBase6D self) -> _VectorBase6D"""
1671 _IMP_algebra._VectorBase6D_swiginit(self, _IMP_algebra.new__VectorBase6D())
1673 def get_scalar_product(self, o):
1674 r"""get_scalar_product(_VectorBase6D self, _VectorBase6D o) -> double"""
1675 return _IMP_algebra._VectorBase6D_get_scalar_product(self, o)
1677 def get_squared_magnitude(self):
1678 r"""get_squared_magnitude(_VectorBase6D self) -> double"""
1679 return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)
1681 def get_magnitude(self):
1682 r"""get_magnitude(_VectorBase6D self) -> double"""
1683 return _IMP_algebra._VectorBase6D_get_magnitude(self)
1685 def __mul__(self, o):
1686 r"""__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
1687 return _IMP_algebra._VectorBase6D___mul__(self, o)
1689 def __iadd__(self, o):
1690 r"""__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1691 return _IMP_algebra._VectorBase6D___iadd__(self, o)
1693 def __isub__(self, o):
1694 r"""__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1695 return _IMP_algebra._VectorBase6D___isub__(self, o)
1697 def __itruediv__(self, *args):
1698 return _IMP_algebra._VectorBase6D___itruediv__(self, *args)
1699 __idiv__ = __itruediv__
1703 def __imul__(self, f):
1704 r"""__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
1705 return _IMP_algebra._VectorBase6D___imul__(self, f)
1707 def show(self, *args):
1709 show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
1710 show(_VectorBase6D self, _ostream out=std::cout)
1712 return _IMP_algebra._VectorBase6D_show(self, *args)
1714 def get_dimension(self):
1715 r"""get_dimension(_VectorBase6D self) -> unsigned int"""
1716 return _IMP_algebra._VectorBase6D_get_dimension(self)
1717 __swig_destroy__ = _IMP_algebra.delete__VectorBase6D
1720 _IMP_algebra._VectorBase6D_swigregister(_VectorBase6D)
1723 r"""get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
1724 return _IMP_algebra.get_basis_vector_kd(D, coordinate)
1727 r"""get_zero_vector_kd(int D) -> VectorKD"""
1728 return _IMP_algebra.get_zero_vector_kd(D)
1731 r"""get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD"""
1732 return _IMP_algebra.get_ones_vector_kd(D, v)
1735 r"""get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
1736 return _IMP_algebra.get_vector_product(p1, p2)
1739 r"""get_orthogonal_vector(Vector3D v) -> Vector3D"""
1740 return _IMP_algebra.get_orthogonal_vector(v)
1743 r"""get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
1744 return _IMP_algebra.get_centroid(ps)
1747 r"""get_radius_of_gyration(IMP::algebra::Vector3Ds const & ps) -> double"""
1748 return _IMP_algebra.get_radius_of_gyration(ps)
1749 class Rotation3D(_GeometricPrimitive3D):
1750 r"""Proxy of C++ IMP::algebra::Rotation3D class."""
1752 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1754 def __init__(self, *args):
1756 __init__(Rotation3D self, Rotation3D rot) -> Rotation3D
1757 __init__(Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
1758 __init__(Rotation3D self) -> Rotation3D
1759 __init__(Rotation3D self, double a, double b, double c, double d) -> Rotation3D
1761 _IMP_algebra.Rotation3D_swiginit(self, _IMP_algebra.new_Rotation3D(*args))
1762 __swig_destroy__ = _IMP_algebra.delete_Rotation3D
1764 def get_rotated_no_cache(self, o):
1765 r"""get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
1766 return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, o)
1768 def get_rotated_one_coordinate_no_cache(self, o, coord):
1769 r"""get_rotated_one_coordinate_no_cache(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1770 return _IMP_algebra.Rotation3D_get_rotated_one_coordinate_no_cache(self, o, coord)
1772 def get_rotated(self, o):
1773 r"""get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
1774 return _IMP_algebra.Rotation3D_get_rotated(self, o)
1776 def get_rotated_adjoint(self, v, Dw):
1777 r"""get_rotated_adjoint(Rotation3D self, Vector3D v, Vector3D Dw) -> _RotatedVector3DAdjoint"""
1778 return _IMP_algebra.Rotation3D_get_rotated_adjoint(self, v, Dw)
1780 def get_rotated_one_coordinate(self, o, coord):
1781 r"""get_rotated_one_coordinate(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1782 return _IMP_algebra.Rotation3D_get_rotated_one_coordinate(self, o, coord)
1784 def get_rotation_matrix_row(self, i):
1785 r"""get_rotation_matrix_row(Rotation3D self, int i) -> Vector3D"""
1786 return _IMP_algebra.Rotation3D_get_rotation_matrix_row(self, i)
1788 def show(self, *args):
1789 r"""show(Rotation3D self, _ostream out=std::cout)"""
1790 return _IMP_algebra.Rotation3D_show(self, *args)
1792 def get_inverse(self):
1793 r"""get_inverse(Rotation3D self) -> Rotation3D"""
1794 return _IMP_algebra.Rotation3D_get_inverse(self)
1796 def get_quaternion(self):
1797 r"""get_quaternion(Rotation3D self) -> Vector4D"""
1798 return _IMP_algebra.Rotation3D_get_quaternion(self)
1800 def __mul__(self, *args):
1802 __mul__(Rotation3D self, Vector3D v) -> Vector3D
1803 __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
1805 return _IMP_algebra.Rotation3D___mul__(self, *args)
1807 def __truediv__(self, *args):
1808 return _IMP_algebra.Rotation3D___truediv__(self, *args)
1809 __div__ = __truediv__
1813 def get_gradient_of_rotated(self, v, i, wrt_unnorm=False):
1814 r"""get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=False) -> Vector3D"""
1815 return _IMP_algebra.Rotation3D_get_gradient_of_rotated(self, v, i, wrt_unnorm)
1817 def get_jacobian_of_rotated(self, v, wrt_unnorm=False):
1818 r"""get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1819 return _IMP_algebra.Rotation3D_get_jacobian_of_rotated(self, v, wrt_unnorm)
1821 def get_is_valid(self):
1822 r"""get_is_valid(Rotation3D self) -> bool"""
1823 return _IMP_algebra.Rotation3D_get_is_valid(self)
1826 r"""__str__(Rotation3D self) -> std::string"""
1827 return _IMP_algebra.Rotation3D___str__(self)
1830 r"""__repr__(Rotation3D self) -> std::string"""
1831 return _IMP_algebra.Rotation3D___repr__(self)
1833 def _get_as_binary(self):
1834 r"""_get_as_binary(Rotation3D self) -> PyObject *"""
1835 return _IMP_algebra.Rotation3D__get_as_binary(self)
1837 def _set_from_binary(self, p):
1838 r"""_set_from_binary(Rotation3D self, PyObject * p)"""
1839 return _IMP_algebra.Rotation3D__set_from_binary(self, p)
1841 def __getstate__(self):
1842 p = self._get_as_binary()
1843 if len(self.__dict__) > 1:
1844 d = self.__dict__.copy()
1849 def __setstate__(self, p):
1850 if not hasattr(self,
'this'):
1852 if isinstance(p, tuple):
1854 self.__dict__.update(d)
1855 return self._set_from_binary(p)
1858 __truediv__ = __div__
1862 _IMP_algebra.Rotation3D_swigregister(Rotation3D)
1865 r"""get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1866 return _IMP_algebra.get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm)
1869 r"""get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1870 return _IMP_algebra.get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm)
1873 r"""get_identity_rotation_3d() -> Rotation3D"""
1874 return _IMP_algebra.get_identity_rotation_3d()
1877 r"""get_rotation_about_normalized_axis(Vector3D axis_norm, double angle) -> Rotation3D"""
1878 return _IMP_algebra.get_rotation_about_normalized_axis(axis_norm, angle)
1881 r"""get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
1882 return _IMP_algebra.get_rotation_about_axis(axis, angle)
1885 r"""get_rotation_taking_first_to_second(Vector3D v1, Vector3D v2) -> Rotation3D"""
1886 return _IMP_algebra.get_rotation_taking_first_to_second(v1, v2)
1890 get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22) -> Rotation3D
1891 get_rotation_from_matrix(Eigen::Matrix3d m) -> Rotation3D
1893 return _IMP_algebra.get_rotation_from_matrix(*args)
1897 get_random_rotation_3d() -> Rotation3D
1898 get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
1900 return _IMP_algebra.get_random_rotation_3d(*args)
1903 r"""get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
1904 return _IMP_algebra.get_uniform_cover_rotations_3d(num_points)
1907 r"""get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
1908 return _IMP_algebra.get_uniformly_sampled_rotations(delta)
1911 r"""get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
1912 return _IMP_algebra.get_rotation_from_vector4d(v)
1915 r"""get_rotation_from_fixed_xyz(double xr, double yr, double zr) -> Rotation3D"""
1916 return _IMP_algebra.get_rotation_from_fixed_xyz(xr, yr, zr)
1919 r"""get_rotation_from_fixed_zxz(double phi, double theta, double psi) -> Rotation3D"""
1920 return _IMP_algebra.get_rotation_from_fixed_zxz(phi, theta, psi)
1923 r"""get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
1924 return _IMP_algebra.get_rotation_from_fixed_zyz(Rot, Tilt, Psi)
1925 class FixedXYZ(_GeometricPrimitive3D):
1926 r"""Proxy of C++ IMP::algebra::FixedXYZ class."""
1928 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1930 def __init__(self, *args):
1932 __init__(FixedXYZ self) -> FixedXYZ
1933 __init__(FixedXYZ self, double x, double y, double z) -> FixedXYZ
1935 _IMP_algebra.FixedXYZ_swiginit(self, _IMP_algebra.new_FixedXYZ(*args))
1938 r"""get_x(FixedXYZ self) -> double"""
1939 return _IMP_algebra.FixedXYZ_get_x(self)
1942 r"""get_y(FixedXYZ self) -> double"""
1943 return _IMP_algebra.FixedXYZ_get_y(self)
1946 r"""get_z(FixedXYZ self) -> double"""
1947 return _IMP_algebra.FixedXYZ_get_z(self)
1949 def show(self, *args):
1950 r"""show(FixedXYZ self, _ostream out=std::cout)"""
1951 return _IMP_algebra.FixedXYZ_show(self, *args)
1954 r"""__str__(FixedXYZ self) -> std::string"""
1955 return _IMP_algebra.FixedXYZ___str__(self)
1958 r"""__repr__(FixedXYZ self) -> std::string"""
1959 return _IMP_algebra.FixedXYZ___repr__(self)
1961 def _get_as_binary(self):
1962 r"""_get_as_binary(FixedXYZ self) -> PyObject *"""
1963 return _IMP_algebra.FixedXYZ__get_as_binary(self)
1965 def _set_from_binary(self, p):
1966 r"""_set_from_binary(FixedXYZ self, PyObject * p)"""
1967 return _IMP_algebra.FixedXYZ__set_from_binary(self, p)
1969 def __getstate__(self):
1970 p = self._get_as_binary()
1971 if len(self.__dict__) > 1:
1972 d = self.__dict__.copy()
1977 def __setstate__(self, p):
1978 if not hasattr(self,
'this'):
1980 if isinstance(p, tuple):
1982 self.__dict__.update(d)
1983 return self._set_from_binary(p)
1985 __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
1988 _IMP_algebra.FixedXYZ_swigregister(FixedXYZ)
1991 r"""get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
1992 return _IMP_algebra.get_fixed_xyz_from_rotation(r)
1995 r"""get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
1996 return _IMP_algebra.get_interpolated(a, b, f)
1999 r"""get_rotation_from_x_y_axes(Vector3D x, Vector3D y) -> Rotation3D"""
2000 return _IMP_algebra.get_rotation_from_x_y_axes(x, y)
2003 r"""get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
2004 return _IMP_algebra.get_axis_and_angle(rot)
2007 r"""get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
2008 return _IMP_algebra.get_unit_bounding_box_kd(d)
2011 r"""get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
2012 return _IMP_algebra.get_cube_kd(d, radius)
2015 r"""get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
2016 return _IMP_algebra.get_edges(arg1)
2017 class Transformation3D(_GeometricPrimitive3D):
2018 r"""Proxy of C++ IMP::algebra::Transformation3D class."""
2020 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2022 def __init__(self, *args):
2024 __init__(Transformation3D self, Transformation3D arg2) -> Transformation3D
2025 __init__(Transformation3D self) -> Transformation3D
2026 __init__(Transformation3D self, Rotation3D r, Vector3D t=IMP::algebra::Vector3D(0, 0, 0)) -> Transformation3D
2027 __init__(Transformation3D self, Vector3D t) -> Transformation3D
2029 _IMP_algebra.Transformation3D_swiginit(self, _IMP_algebra.new_Transformation3D(*args))
2030 __swig_destroy__ = _IMP_algebra.delete_Transformation3D
2032 def get_transformed(self, o):
2033 r"""get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
2034 return _IMP_algebra.Transformation3D_get_transformed(self, o)
2036 def get_transformed_adjoint(self, v, Dw):
2037 r"""get_transformed_adjoint(Transformation3D self, Vector3D v, Vector3D Dw) -> _TransformedVector3DAdjoint"""
2038 return _IMP_algebra.Transformation3D_get_transformed_adjoint(self, v, Dw)
2040 def __mul__(self, *args):
2042 __mul__(Transformation3D self, Vector3D v) -> Vector3D
2043 __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
2045 return _IMP_algebra.Transformation3D___mul__(self, *args)
2047 def __truediv__(self, *args):
2048 return _IMP_algebra.Transformation3D___truediv__(self, *args)
2049 __div__ = __truediv__
2053 def get_rotation(self):
2054 r"""get_rotation(Transformation3D self) -> Rotation3D"""
2055 return _IMP_algebra.Transformation3D_get_rotation(self)
2057 def get_translation(self):
2058 r"""get_translation(Transformation3D self) -> Vector3D"""
2059 return _IMP_algebra.Transformation3D_get_translation(self)
2061 def show(self, *args):
2062 r"""show(Transformation3D self, _ostream out=std::cout)"""
2063 return _IMP_algebra.Transformation3D_show(self, *args)
2065 def get_inverse(self):
2066 r"""get_inverse(Transformation3D self) -> Transformation3D"""
2067 return _IMP_algebra.Transformation3D_get_inverse(self)
2069 def get_is_valid(self):
2070 r"""get_is_valid(Transformation3D self) -> bool"""
2071 return _IMP_algebra.Transformation3D_get_is_valid(self)
2074 r"""__str__(Transformation3D self) -> std::string"""
2075 return _IMP_algebra.Transformation3D___str__(self)
2078 r"""__repr__(Transformation3D self) -> std::string"""
2079 return _IMP_algebra.Transformation3D___repr__(self)
2081 def _get_as_binary(self):
2082 r"""_get_as_binary(Transformation3D self) -> PyObject *"""
2083 return _IMP_algebra.Transformation3D__get_as_binary(self)
2085 def _set_from_binary(self, p):
2086 r"""_set_from_binary(Transformation3D self, PyObject * p)"""
2087 return _IMP_algebra.Transformation3D__set_from_binary(self, p)
2089 def __getstate__(self):
2090 p = self._get_as_binary()
2091 if len(self.__dict__) > 1:
2092 d = self.__dict__.copy()
2097 def __setstate__(self, p):
2098 if not hasattr(self,
'this'):
2100 if isinstance(p, tuple):
2102 self.__dict__.update(d)
2103 return self._set_from_binary(p)
2106 __truediv__ = __div__
2110 _IMP_algebra.Transformation3D_swigregister(Transformation3D)
2113 r"""get_identity_transformation_3d() -> Transformation3D"""
2114 return _IMP_algebra.get_identity_transformation_3d()
2118 compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
2119 compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
2121 return _IMP_algebra.compose_adjoint(*args)
2124 r"""get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
2125 return _IMP_algebra.get_transformation_3d(t2d)
2128 r"""get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D"""
2129 return _IMP_algebra.get_random_local_transformation(origin, max_translation, max_angle_in_rad)
2130 class Rotation2D(_GeometricPrimitive2D):
2131 r"""Proxy of C++ IMP::algebra::Rotation2D class."""
2133 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2135 def __init__(self, *args):
2137 __init__(Rotation2D self) -> Rotation2D
2138 __init__(Rotation2D self, double angle) -> Rotation2D
2140 _IMP_algebra.Rotation2D_swiginit(self, _IMP_algebra.new_Rotation2D(*args))
2142 def get_rotated(self, *args):
2144 get_rotated(Rotation2D self, Vector2D o) -> Vector2D
2145 get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
2147 return _IMP_algebra.Rotation2D_get_rotated(self, *args)
2149 def get_inverse(self):
2150 r"""get_inverse(Rotation2D self) -> Rotation2D"""
2151 return _IMP_algebra.Rotation2D_get_inverse(self)
2153 def set_angle(self, angle):
2154 r"""set_angle(Rotation2D self, double angle)"""
2155 return _IMP_algebra.Rotation2D_set_angle(self, angle)
2158 r"""get_angle(Rotation2D self) -> double"""
2159 return _IMP_algebra.Rotation2D_get_angle(self)
2161 def show(self, *args):
2162 r"""show(Rotation2D self, _ostream out=std::cout)"""
2163 return _IMP_algebra.Rotation2D_show(self, *args)
2166 r"""__str__(Rotation2D self) -> std::string"""
2167 return _IMP_algebra.Rotation2D___str__(self)
2170 r"""__repr__(Rotation2D self) -> std::string"""
2171 return _IMP_algebra.Rotation2D___repr__(self)
2173 def _get_as_binary(self):
2174 r"""_get_as_binary(Rotation2D self) -> PyObject *"""
2175 return _IMP_algebra.Rotation2D__get_as_binary(self)
2177 def _set_from_binary(self, p):
2178 r"""_set_from_binary(Rotation2D self, PyObject * p)"""
2179 return _IMP_algebra.Rotation2D__set_from_binary(self, p)
2181 def __getstate__(self):
2182 p = self._get_as_binary()
2183 if len(self.__dict__) > 1:
2184 d = self.__dict__.copy()
2189 def __setstate__(self, p):
2190 if not hasattr(self,
'this'):
2192 if isinstance(p, tuple):
2194 self.__dict__.update(d)
2195 return self._set_from_binary(p)
2197 __swig_destroy__ = _IMP_algebra.delete_Rotation2D
2200 _IMP_algebra.Rotation2D_swigregister(Rotation2D)
2203 r"""get_identity_rotation_2d() -> Rotation2D"""
2204 return _IMP_algebra.get_identity_rotation_2d()
2207 r"""get_random_rotation_2d() -> Rotation2D"""
2208 return _IMP_algebra.get_random_rotation_2d()
2211 r"""get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
2212 return _IMP_algebra.get_rotation_to_x_axis(v)
2213 class Transformation2D(_GeometricPrimitive2D):
2214 r"""Proxy of C++ IMP::algebra::Transformation2D class."""
2216 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2218 def __init__(self, *args):
2220 __init__(Transformation2D self, Transformation2D arg2) -> Transformation2D
2221 __init__(Transformation2D self) -> Transformation2D
2222 __init__(Transformation2D self, Rotation2D r, Vector2D t=IMP::algebra::Vector2D(0.0, 0.0)) -> Transformation2D
2223 __init__(Transformation2D self, Vector2D t) -> Transformation2D
2225 _IMP_algebra.Transformation2D_swiginit(self, _IMP_algebra.new_Transformation2D(*args))
2226 __swig_destroy__ = _IMP_algebra.delete_Transformation2D
2228 def get_transformed(self, o):
2229 r"""get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
2230 return _IMP_algebra.Transformation2D_get_transformed(self, o)
2232 def __mul__(self, *args):
2234 __mul__(Transformation2D self, Vector2D v) -> Vector2D
2235 __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
2237 return _IMP_algebra.Transformation2D___mul__(self, *args)
2239 def __truediv__(self, *args):
2240 return _IMP_algebra.Transformation2D___truediv__(self, *args)
2241 __div__ = __truediv__
2245 def get_rotation(self):
2246 r"""get_rotation(Transformation2D self) -> Rotation2D"""
2247 return _IMP_algebra.Transformation2D_get_rotation(self)
2249 def set_rotation(self, angle):
2250 r"""set_rotation(Transformation2D self, double angle)"""
2251 return _IMP_algebra.Transformation2D_set_rotation(self, angle)
2253 def get_translation(self):
2254 r"""get_translation(Transformation2D self) -> Vector2D"""
2255 return _IMP_algebra.Transformation2D_get_translation(self)
2257 def set_translation(self, v):
2258 r"""set_translation(Transformation2D self, Vector2D v)"""
2259 return _IMP_algebra.Transformation2D_set_translation(self, v)
2261 def show(self, *args):
2262 r"""show(Transformation2D self, _ostream out=std::cout)"""
2263 return _IMP_algebra.Transformation2D_show(self, *args)
2265 def get_inverse(self):
2266 r"""get_inverse(Transformation2D self) -> Transformation2D"""
2267 return _IMP_algebra.Transformation2D_get_inverse(self)
2270 r"""__str__(Transformation2D self) -> std::string"""
2271 return _IMP_algebra.Transformation2D___str__(self)
2274 r"""__repr__(Transformation2D self) -> std::string"""
2275 return _IMP_algebra.Transformation2D___repr__(self)
2277 def _get_as_binary(self):
2278 r"""_get_as_binary(Transformation2D self) -> PyObject *"""
2279 return _IMP_algebra.Transformation2D__get_as_binary(self)
2281 def _set_from_binary(self, p):
2282 r"""_set_from_binary(Transformation2D self, PyObject * p)"""
2283 return _IMP_algebra.Transformation2D__set_from_binary(self, p)
2285 def __getstate__(self):
2286 p = self._get_as_binary()
2287 if len(self.__dict__) > 1:
2288 d = self.__dict__.copy()
2293 def __setstate__(self, p):
2294 if not hasattr(self,
'this'):
2296 if isinstance(p, tuple):
2298 self.__dict__.update(d)
2299 return self._set_from_binary(p)
2302 __truediv__ = __div__
2306 _IMP_algebra.Transformation2D_swigregister(Transformation2D)
2309 r"""get_identity_transformation_2d() -> Transformation2D"""
2310 return _IMP_algebra.get_identity_transformation_2d()
2314 get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
2315 get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
2317 return _IMP_algebra.get_rotation_about_point(*args)
2321 compose(Rotation3D a, Rotation3D b) -> Rotation3D
2322 compose(Transformation3D a, Transformation3D b) -> Transformation3D
2323 compose(Rotation2D a, Rotation2D b) -> Rotation2D
2324 compose(Transformation2D a, Transformation2D b) -> Transformation2D
2326 return _IMP_algebra.compose(*args)
2328 def get_unit_sphere_kd(d):
2329 r"""get_unit_sphere_kd(unsigned int d) -> SphereKD"""
2330 return _IMP_algebra.get_unit_sphere_kd(d)
2334 get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
2335 get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
2337 return _IMP_algebra.get_enclosing_sphere(*args)
2340 r"""get_ball_radius_from_volume_3d(double volume) -> double"""
2341 return _IMP_algebra.get_ball_radius_from_volume_3d(volume)
2344 r"""get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
2345 return _IMP_algebra.get_surface_area_and_volume(ss)
2348 r"""get_simplified_from_volume(IMP::algebra::Sphere3Ds _in, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
2349 return _IMP_algebra.get_simplified_from_volume(_in, maximum_allowed_error_angstroms)
2351 def get_triangle_3d(s):
2352 r"""get_triangle_3d(UnitSimplex3D s) -> Triangle3D"""
2353 return _IMP_algebra.get_triangle_3d(s)
2354 class _UnitSimplexBaseKD(_GeometricPrimitiveKD):
2355 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< -1 > class."""
2357 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2359 def __init__(self, *args, **kwargs):
2360 raise AttributeError(
"No constructor defined - class is abstract")
2361 __repr__ = _swig_repr
2363 def get_dimension(self):
2364 r"""get_dimension(_UnitSimplexBaseKD self) -> int"""
2365 return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)
2367 def get_barycenter(self):
2368 r"""get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
2369 return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)
2371 def get_contains(self, *args):
2372 r"""get_contains(_UnitSimplexBaseKD self, VectorKD p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2373 return _IMP_algebra._UnitSimplexBaseKD_get_contains(self, *args)
2374 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBaseKD
2377 _IMP_algebra._UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
2378 class _UnitSimplexBase1D(_GeometricPrimitive1D):
2379 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 1 > class."""
2381 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2383 def __init__(self, *args, **kwargs):
2384 raise AttributeError(
"No constructor defined - class is abstract")
2385 __repr__ = _swig_repr
2387 def get_dimension(self):
2388 r"""get_dimension(_UnitSimplexBase1D self) -> int"""
2389 return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)
2391 def get_barycenter(self):
2392 r"""get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
2393 return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)
2395 def get_contains(self, *args):
2396 r"""get_contains(_UnitSimplexBase1D self, Vector1D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2397 return _IMP_algebra._UnitSimplexBase1D_get_contains(self, *args)
2398 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase1D
2401 _IMP_algebra._UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
2402 class _UnitSimplexBase2D(_GeometricPrimitive2D):
2403 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 2 > class."""
2405 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2407 def __init__(self, *args, **kwargs):
2408 raise AttributeError(
"No constructor defined - class is abstract")
2409 __repr__ = _swig_repr
2411 def get_dimension(self):
2412 r"""get_dimension(_UnitSimplexBase2D self) -> int"""
2413 return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)
2415 def get_barycenter(self):
2416 r"""get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
2417 return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)
2419 def get_contains(self, *args):
2420 r"""get_contains(_UnitSimplexBase2D self, Vector2D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2421 return _IMP_algebra._UnitSimplexBase2D_get_contains(self, *args)
2422 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase2D
2425 _IMP_algebra._UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
2426 class _UnitSimplexBase3D(_GeometricPrimitive3D):
2427 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 3 > class."""
2429 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2431 def __init__(self, *args, **kwargs):
2432 raise AttributeError(
"No constructor defined - class is abstract")
2433 __repr__ = _swig_repr
2435 def get_dimension(self):
2436 r"""get_dimension(_UnitSimplexBase3D self) -> int"""
2437 return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)
2439 def get_barycenter(self):
2440 r"""get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
2441 return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)
2443 def get_contains(self, *args):
2444 r"""get_contains(_UnitSimplexBase3D self, Vector3D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2445 return _IMP_algebra._UnitSimplexBase3D_get_contains(self, *args)
2446 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase3D
2449 _IMP_algebra._UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
2450 class _UnitSimplexBase4D(_GeometricPrimitive4D):
2451 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 4 > class."""
2453 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2455 def __init__(self, *args, **kwargs):
2456 raise AttributeError(
"No constructor defined - class is abstract")
2457 __repr__ = _swig_repr
2459 def get_dimension(self):
2460 r"""get_dimension(_UnitSimplexBase4D self) -> int"""
2461 return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)
2463 def get_barycenter(self):
2464 r"""get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
2465 return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)
2467 def get_contains(self, *args):
2468 r"""get_contains(_UnitSimplexBase4D self, Vector4D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2469 return _IMP_algebra._UnitSimplexBase4D_get_contains(self, *args)
2470 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase4D
2473 _IMP_algebra._UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
2474 class _UnitSimplexBase5D(_GeometricPrimitive5D):
2475 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 5 > class."""
2477 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2479 def __init__(self, *args, **kwargs):
2480 raise AttributeError(
"No constructor defined - class is abstract")
2481 __repr__ = _swig_repr
2483 def get_dimension(self):
2484 r"""get_dimension(_UnitSimplexBase5D self) -> int"""
2485 return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)
2487 def get_barycenter(self):
2488 r"""get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
2489 return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)
2491 def get_contains(self, *args):
2492 r"""get_contains(_UnitSimplexBase5D self, Vector5D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2493 return _IMP_algebra._UnitSimplexBase5D_get_contains(self, *args)
2494 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase5D
2497 _IMP_algebra._UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
2498 class _UnitSimplexBase6D(_GeometricPrimitive6D):
2499 r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 6 > class."""
2501 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2503 def __init__(self, *args, **kwargs):
2504 raise AttributeError(
"No constructor defined - class is abstract")
2505 __repr__ = _swig_repr
2507 def get_dimension(self):
2508 r"""get_dimension(_UnitSimplexBase6D self) -> int"""
2509 return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)
2511 def get_barycenter(self):
2512 r"""get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
2513 return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)
2515 def get_contains(self, *args):
2516 r"""get_contains(_UnitSimplexBase6D self, Vector6D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2517 return _IMP_algebra._UnitSimplexBase6D_get_contains(self, *args)
2518 __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase6D
2521 _IMP_algebra._UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
2523 r"""Proxy of C++ IMP::algebra::VectorD< 1 > class."""
2525 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2528 r"""get_unit_vector(Vector1D self) -> Vector1D"""
2529 return _IMP_algebra.Vector1D_get_unit_vector(self)
2531 def __truediv__(self, *args):
2532 return _IMP_algebra.Vector1D___truediv__(self, *args)
2533 __div__ = __truediv__
2538 r"""__neg__(Vector1D self) -> Vector1D"""
2539 return _IMP_algebra.Vector1D___neg__(self)
2541 def __sub__(self, o):
2542 r"""__sub__(Vector1D self, Vector1D o) -> Vector1D"""
2543 return _IMP_algebra.Vector1D___sub__(self, o)
2545 def __add__(self, ret):
2546 r"""__add__(Vector1D self, Vector1D ret) -> Vector1D"""
2547 return _IMP_algebra.Vector1D___add__(self, ret)
2549 def __mul__(self, *args):
2551 __mul__(Vector1D self, double s) -> Vector1D
2552 __mul__(Vector1D self, Vector1D o) -> double
2554 return _IMP_algebra.Vector1D___mul__(self, *args)
2556 def __init__(self, *args):
2558 __init__(Vector1D self, IMP::Floats const & f) -> Vector1D
2559 __init__(Vector1D self) -> Vector1D
2560 __init__(Vector1D self, double x) -> Vector1D
2562 _IMP_algebra.Vector1D_swiginit(self, _IMP_algebra.new_Vector1D(*args))
2564 def __iadd__(self, *args):
2565 _IMP_algebra.Vector1D___iadd__(self, *args)
2570 def __imul__(self, *args):
2571 _IMP_algebra.Vector1D___imul__(self, *args)
2576 def __idiv__(self, *args):
2577 _IMP_algebra.Vector1D___idiv__(self, *args)
2582 def __isub__(self, *args):
2583 _IMP_algebra.Vector1D___isub__(self, *args)
2589 r"""__len__(Vector1D self) -> unsigned int"""
2590 return _IMP_algebra.Vector1D___len__(self)
2592 def __rmul__(self, f):
2593 r"""__rmul__(Vector1D self, double f) -> Vector1D"""
2594 return _IMP_algebra.Vector1D___rmul__(self, f)
2597 r"""__str__(Vector1D self) -> std::string"""
2598 return _IMP_algebra.Vector1D___str__(self)
2601 r"""__repr__(Vector1D self) -> std::string"""
2602 return _IMP_algebra.Vector1D___repr__(self)
2604 def __cmp__(self, arg2):
2605 r"""__cmp__(Vector1D self, Vector1D arg2) -> int"""
2606 return _IMP_algebra.Vector1D___cmp__(self, arg2)
2608 def __eq__(self, arg2):
2609 r"""__eq__(Vector1D self, Vector1D arg2) -> bool"""
2610 return _IMP_algebra.Vector1D___eq__(self, arg2)
2612 __truediv__ = __div__
2613 __itruediv__ = __idiv__
2616 def _get_as_binary(self):
2617 r"""_get_as_binary(Vector1D self) -> PyObject *"""
2618 return _IMP_algebra.Vector1D__get_as_binary(self)
2620 def _set_from_binary(self, p):
2621 r"""_set_from_binary(Vector1D self, PyObject * p)"""
2622 return _IMP_algebra.Vector1D__set_from_binary(self, p)
2624 def __getstate__(self):
2625 p = self._get_as_binary()
2626 if len(self.__dict__) > 1:
2627 d = self.__dict__.copy()
2632 def __setstate__(self, p):
2633 if not hasattr(self,
'this'):
2635 if isinstance(p, tuple):
2637 self.__dict__.update(d)
2638 return self._set_from_binary(p)
2641 def __getitem__(self, index):
2642 r"""__getitem__(Vector1D self, int index) -> double"""
2643 return _IMP_algebra.Vector1D___getitem__(self, index)
2645 def __setitem__(self, index, val):
2646 r"""__setitem__(Vector1D self, int index, double val)"""
2647 return _IMP_algebra.Vector1D___setitem__(self, index, val)
2648 __swig_destroy__ = _IMP_algebra.delete_Vector1D
2651 _IMP_algebra.Vector1D_swigregister(Vector1D)
2653 r"""Proxy of C++ IMP::algebra::VectorD< 2 > class."""
2655 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2658 r"""get_unit_vector(Vector2D self) -> Vector2D"""
2659 return _IMP_algebra.Vector2D_get_unit_vector(self)
2661 def __truediv__(self, *args):
2662 return _IMP_algebra.Vector2D___truediv__(self, *args)
2663 __div__ = __truediv__
2668 r"""__neg__(Vector2D self) -> Vector2D"""
2669 return _IMP_algebra.Vector2D___neg__(self)
2671 def __sub__(self, o):
2672 r"""__sub__(Vector2D self, Vector2D o) -> Vector2D"""
2673 return _IMP_algebra.Vector2D___sub__(self, o)
2675 def __add__(self, ret):
2676 r"""__add__(Vector2D self, Vector2D ret) -> Vector2D"""
2677 return _IMP_algebra.Vector2D___add__(self, ret)
2679 def __mul__(self, *args):
2681 __mul__(Vector2D self, double s) -> Vector2D
2682 __mul__(Vector2D self, Vector2D o) -> double
2684 return _IMP_algebra.Vector2D___mul__(self, *args)
2686 def __init__(self, *args):
2688 __init__(Vector2D self, IMP::Floats const & f) -> Vector2D
2689 __init__(Vector2D self) -> Vector2D
2690 __init__(Vector2D self, double x, double y) -> Vector2D
2692 _IMP_algebra.Vector2D_swiginit(self, _IMP_algebra.new_Vector2D(*args))
2694 def __iadd__(self, *args):
2695 _IMP_algebra.Vector2D___iadd__(self, *args)
2700 def __imul__(self, *args):
2701 _IMP_algebra.Vector2D___imul__(self, *args)
2706 def __idiv__(self, *args):
2707 _IMP_algebra.Vector2D___idiv__(self, *args)
2712 def __isub__(self, *args):
2713 _IMP_algebra.Vector2D___isub__(self, *args)
2719 r"""__len__(Vector2D self) -> unsigned int"""
2720 return _IMP_algebra.Vector2D___len__(self)
2722 def __rmul__(self, f):
2723 r"""__rmul__(Vector2D self, double f) -> Vector2D"""
2724 return _IMP_algebra.Vector2D___rmul__(self, f)
2727 r"""__str__(Vector2D self) -> std::string"""
2728 return _IMP_algebra.Vector2D___str__(self)
2731 r"""__repr__(Vector2D self) -> std::string"""
2732 return _IMP_algebra.Vector2D___repr__(self)
2734 def __cmp__(self, arg2):
2735 r"""__cmp__(Vector2D self, Vector2D arg2) -> int"""
2736 return _IMP_algebra.Vector2D___cmp__(self, arg2)
2738 def __eq__(self, arg2):
2739 r"""__eq__(Vector2D self, Vector2D arg2) -> bool"""
2740 return _IMP_algebra.Vector2D___eq__(self, arg2)
2742 __truediv__ = __div__
2743 __itruediv__ = __idiv__
2746 def _get_as_binary(self):
2747 r"""_get_as_binary(Vector2D self) -> PyObject *"""
2748 return _IMP_algebra.Vector2D__get_as_binary(self)
2750 def _set_from_binary(self, p):
2751 r"""_set_from_binary(Vector2D self, PyObject * p)"""
2752 return _IMP_algebra.Vector2D__set_from_binary(self, p)
2754 def __getstate__(self):
2755 p = self._get_as_binary()
2756 if len(self.__dict__) > 1:
2757 d = self.__dict__.copy()
2762 def __setstate__(self, p):
2763 if not hasattr(self,
'this'):
2765 if isinstance(p, tuple):
2767 self.__dict__.update(d)
2768 return self._set_from_binary(p)
2771 def __getitem__(self, index):
2772 r"""__getitem__(Vector2D self, int index) -> double"""
2773 return _IMP_algebra.Vector2D___getitem__(self, index)
2775 def __setitem__(self, index, val):
2776 r"""__setitem__(Vector2D self, int index, double val)"""
2777 return _IMP_algebra.Vector2D___setitem__(self, index, val)
2778 __swig_destroy__ = _IMP_algebra.delete_Vector2D
2781 _IMP_algebra.Vector2D_swigregister(Vector2D)
2783 r"""Proxy of C++ IMP::algebra::VectorD< 3 > class."""
2785 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2788 r"""get_unit_vector(Vector3D self) -> Vector3D"""
2789 return _IMP_algebra.Vector3D_get_unit_vector(self)
2791 def __truediv__(self, *args):
2792 return _IMP_algebra.Vector3D___truediv__(self, *args)
2793 __div__ = __truediv__
2798 r"""__neg__(Vector3D self) -> Vector3D"""
2799 return _IMP_algebra.Vector3D___neg__(self)
2801 def __sub__(self, o):
2802 r"""__sub__(Vector3D self, Vector3D o) -> Vector3D"""
2803 return _IMP_algebra.Vector3D___sub__(self, o)
2805 def __add__(self, ret):
2806 r"""__add__(Vector3D self, Vector3D ret) -> Vector3D"""
2807 return _IMP_algebra.Vector3D___add__(self, ret)
2809 def __mul__(self, *args):
2811 __mul__(Vector3D self, double s) -> Vector3D
2812 __mul__(Vector3D self, Vector3D o) -> double
2814 return _IMP_algebra.Vector3D___mul__(self, *args)
2816 def __init__(self, *args):
2818 __init__(Vector3D self, IMP::Floats const & f) -> Vector3D
2819 __init__(Vector3D self) -> Vector3D
2820 __init__(Vector3D self, double x, double y, double z) -> Vector3D
2822 _IMP_algebra.Vector3D_swiginit(self, _IMP_algebra.new_Vector3D(*args))
2824 def __iadd__(self, *args):
2825 _IMP_algebra.Vector3D___iadd__(self, *args)
2830 def __imul__(self, *args):
2831 _IMP_algebra.Vector3D___imul__(self, *args)
2836 def __idiv__(self, *args):
2837 _IMP_algebra.Vector3D___idiv__(self, *args)
2842 def __isub__(self, *args):
2843 _IMP_algebra.Vector3D___isub__(self, *args)
2849 r"""__len__(Vector3D self) -> unsigned int"""
2850 return _IMP_algebra.Vector3D___len__(self)
2852 def __rmul__(self, f):
2853 r"""__rmul__(Vector3D self, double f) -> Vector3D"""
2854 return _IMP_algebra.Vector3D___rmul__(self, f)
2857 r"""__str__(Vector3D self) -> std::string"""
2858 return _IMP_algebra.Vector3D___str__(self)
2861 r"""__repr__(Vector3D self) -> std::string"""
2862 return _IMP_algebra.Vector3D___repr__(self)
2864 def __cmp__(self, arg2):
2865 r"""__cmp__(Vector3D self, Vector3D arg2) -> int"""
2866 return _IMP_algebra.Vector3D___cmp__(self, arg2)
2868 def __eq__(self, arg2):
2869 r"""__eq__(Vector3D self, Vector3D arg2) -> bool"""
2870 return _IMP_algebra.Vector3D___eq__(self, arg2)
2872 __truediv__ = __div__
2873 __itruediv__ = __idiv__
2876 def _get_as_binary(self):
2877 r"""_get_as_binary(Vector3D self) -> PyObject *"""
2878 return _IMP_algebra.Vector3D__get_as_binary(self)
2880 def _set_from_binary(self, p):
2881 r"""_set_from_binary(Vector3D self, PyObject * p)"""
2882 return _IMP_algebra.Vector3D__set_from_binary(self, p)
2884 def __getstate__(self):
2885 p = self._get_as_binary()
2886 if len(self.__dict__) > 1:
2887 d = self.__dict__.copy()
2892 def __setstate__(self, p):
2893 if not hasattr(self,
'this'):
2895 if isinstance(p, tuple):
2897 self.__dict__.update(d)
2898 return self._set_from_binary(p)
2901 def __getitem__(self, index):
2902 r"""__getitem__(Vector3D self, int index) -> double"""
2903 return _IMP_algebra.Vector3D___getitem__(self, index)
2905 def __setitem__(self, index, val):
2906 r"""__setitem__(Vector3D self, int index, double val)"""
2907 return _IMP_algebra.Vector3D___setitem__(self, index, val)
2908 __swig_destroy__ = _IMP_algebra.delete_Vector3D
2911 _IMP_algebra.Vector3D_swigregister(Vector3D)
2913 r"""Proxy of C++ IMP::algebra::VectorD< 4 > class."""
2915 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2918 r"""get_unit_vector(Vector4D self) -> Vector4D"""
2919 return _IMP_algebra.Vector4D_get_unit_vector(self)
2921 def __truediv__(self, *args):
2922 return _IMP_algebra.Vector4D___truediv__(self, *args)
2923 __div__ = __truediv__
2928 r"""__neg__(Vector4D self) -> Vector4D"""
2929 return _IMP_algebra.Vector4D___neg__(self)
2931 def __sub__(self, o):
2932 r"""__sub__(Vector4D self, Vector4D o) -> Vector4D"""
2933 return _IMP_algebra.Vector4D___sub__(self, o)
2935 def __add__(self, ret):
2936 r"""__add__(Vector4D self, Vector4D ret) -> Vector4D"""
2937 return _IMP_algebra.Vector4D___add__(self, ret)
2939 def __mul__(self, *args):
2941 __mul__(Vector4D self, double s) -> Vector4D
2942 __mul__(Vector4D self, Vector4D o) -> double
2944 return _IMP_algebra.Vector4D___mul__(self, *args)
2946 def __init__(self, *args):
2948 __init__(Vector4D self, IMP::Floats const & f) -> Vector4D
2949 __init__(Vector4D self) -> Vector4D
2950 __init__(Vector4D self, double x0, double x1, double x2, double x3) -> Vector4D
2952 _IMP_algebra.Vector4D_swiginit(self, _IMP_algebra.new_Vector4D(*args))
2954 def __iadd__(self, *args):
2955 _IMP_algebra.Vector4D___iadd__(self, *args)
2960 def __imul__(self, *args):
2961 _IMP_algebra.Vector4D___imul__(self, *args)
2966 def __idiv__(self, *args):
2967 _IMP_algebra.Vector4D___idiv__(self, *args)
2972 def __isub__(self, *args):
2973 _IMP_algebra.Vector4D___isub__(self, *args)
2979 r"""__len__(Vector4D self) -> unsigned int"""
2980 return _IMP_algebra.Vector4D___len__(self)
2982 def __rmul__(self, f):
2983 r"""__rmul__(Vector4D self, double f) -> Vector4D"""
2984 return _IMP_algebra.Vector4D___rmul__(self, f)
2987 r"""__str__(Vector4D self) -> std::string"""
2988 return _IMP_algebra.Vector4D___str__(self)
2991 r"""__repr__(Vector4D self) -> std::string"""
2992 return _IMP_algebra.Vector4D___repr__(self)
2994 def __cmp__(self, arg2):
2995 r"""__cmp__(Vector4D self, Vector4D arg2) -> int"""
2996 return _IMP_algebra.Vector4D___cmp__(self, arg2)
2998 def __eq__(self, arg2):
2999 r"""__eq__(Vector4D self, Vector4D arg2) -> bool"""
3000 return _IMP_algebra.Vector4D___eq__(self, arg2)
3002 __truediv__ = __div__
3003 __itruediv__ = __idiv__
3006 def _get_as_binary(self):
3007 r"""_get_as_binary(Vector4D self) -> PyObject *"""
3008 return _IMP_algebra.Vector4D__get_as_binary(self)
3010 def _set_from_binary(self, p):
3011 r"""_set_from_binary(Vector4D self, PyObject * p)"""
3012 return _IMP_algebra.Vector4D__set_from_binary(self, p)
3014 def __getstate__(self):
3015 p = self._get_as_binary()
3016 if len(self.__dict__) > 1:
3017 d = self.__dict__.copy()
3022 def __setstate__(self, p):
3023 if not hasattr(self,
'this'):
3025 if isinstance(p, tuple):
3027 self.__dict__.update(d)
3028 return self._set_from_binary(p)
3031 def __getitem__(self, index):
3032 r"""__getitem__(Vector4D self, int index) -> double"""
3033 return _IMP_algebra.Vector4D___getitem__(self, index)
3035 def __setitem__(self, index, val):
3036 r"""__setitem__(Vector4D self, int index, double val)"""
3037 return _IMP_algebra.Vector4D___setitem__(self, index, val)
3038 __swig_destroy__ = _IMP_algebra.delete_Vector4D
3041 _IMP_algebra.Vector4D_swigregister(Vector4D)
3043 r"""Proxy of C++ IMP::algebra::VectorD< 5 > class."""
3045 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3048 r"""get_unit_vector(Vector5D self) -> Vector5D"""
3049 return _IMP_algebra.Vector5D_get_unit_vector(self)
3051 def __truediv__(self, *args):
3052 return _IMP_algebra.Vector5D___truediv__(self, *args)
3053 __div__ = __truediv__
3058 r"""__neg__(Vector5D self) -> Vector5D"""
3059 return _IMP_algebra.Vector5D___neg__(self)
3061 def __sub__(self, o):
3062 r"""__sub__(Vector5D self, Vector5D o) -> Vector5D"""
3063 return _IMP_algebra.Vector5D___sub__(self, o)
3065 def __add__(self, ret):
3066 r"""__add__(Vector5D self, Vector5D ret) -> Vector5D"""
3067 return _IMP_algebra.Vector5D___add__(self, ret)
3069 def __mul__(self, *args):
3071 __mul__(Vector5D self, double s) -> Vector5D
3072 __mul__(Vector5D self, Vector5D o) -> double
3074 return _IMP_algebra.Vector5D___mul__(self, *args)
3076 def __init__(self, *args):
3078 __init__(Vector5D self, IMP::Floats const & f) -> Vector5D
3079 __init__(Vector5D self) -> Vector5D
3080 __init__(Vector5D self, double x0, double x1, double x2, double x3, double x4) -> Vector5D
3082 _IMP_algebra.Vector5D_swiginit(self, _IMP_algebra.new_Vector5D(*args))
3084 def __iadd__(self, *args):
3085 _IMP_algebra.Vector5D___iadd__(self, *args)
3090 def __imul__(self, *args):
3091 _IMP_algebra.Vector5D___imul__(self, *args)
3096 def __idiv__(self, *args):
3097 _IMP_algebra.Vector5D___idiv__(self, *args)
3102 def __isub__(self, *args):
3103 _IMP_algebra.Vector5D___isub__(self, *args)
3109 r"""__len__(Vector5D self) -> unsigned int"""
3110 return _IMP_algebra.Vector5D___len__(self)
3112 def __rmul__(self, f):
3113 r"""__rmul__(Vector5D self, double f) -> Vector5D"""
3114 return _IMP_algebra.Vector5D___rmul__(self, f)
3117 r"""__str__(Vector5D self) -> std::string"""
3118 return _IMP_algebra.Vector5D___str__(self)
3121 r"""__repr__(Vector5D self) -> std::string"""
3122 return _IMP_algebra.Vector5D___repr__(self)
3124 def __cmp__(self, arg2):
3125 r"""__cmp__(Vector5D self, Vector5D arg2) -> int"""
3126 return _IMP_algebra.Vector5D___cmp__(self, arg2)
3128 def __eq__(self, arg2):
3129 r"""__eq__(Vector5D self, Vector5D arg2) -> bool"""
3130 return _IMP_algebra.Vector5D___eq__(self, arg2)
3132 __truediv__ = __div__
3133 __itruediv__ = __idiv__
3136 def _get_as_binary(self):
3137 r"""_get_as_binary(Vector5D self) -> PyObject *"""
3138 return _IMP_algebra.Vector5D__get_as_binary(self)
3140 def _set_from_binary(self, p):
3141 r"""_set_from_binary(Vector5D self, PyObject * p)"""
3142 return _IMP_algebra.Vector5D__set_from_binary(self, p)
3144 def __getstate__(self):
3145 p = self._get_as_binary()
3146 if len(self.__dict__) > 1:
3147 d = self.__dict__.copy()
3152 def __setstate__(self, p):
3153 if not hasattr(self,
'this'):
3155 if isinstance(p, tuple):
3157 self.__dict__.update(d)
3158 return self._set_from_binary(p)
3161 def __getitem__(self, index):
3162 r"""__getitem__(Vector5D self, int index) -> double"""
3163 return _IMP_algebra.Vector5D___getitem__(self, index)
3165 def __setitem__(self, index, val):
3166 r"""__setitem__(Vector5D self, int index, double val)"""
3167 return _IMP_algebra.Vector5D___setitem__(self, index, val)
3168 __swig_destroy__ = _IMP_algebra.delete_Vector5D
3171 _IMP_algebra.Vector5D_swigregister(Vector5D)
3173 r"""Proxy of C++ IMP::algebra::VectorD< 6 > class."""
3175 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3178 r"""get_unit_vector(Vector6D self) -> Vector6D"""
3179 return _IMP_algebra.Vector6D_get_unit_vector(self)
3181 def __truediv__(self, *args):
3182 return _IMP_algebra.Vector6D___truediv__(self, *args)
3183 __div__ = __truediv__
3188 r"""__neg__(Vector6D self) -> Vector6D"""
3189 return _IMP_algebra.Vector6D___neg__(self)
3191 def __sub__(self, o):
3192 r"""__sub__(Vector6D self, Vector6D o) -> Vector6D"""
3193 return _IMP_algebra.Vector6D___sub__(self, o)
3195 def __add__(self, ret):
3196 r"""__add__(Vector6D self, Vector6D ret) -> Vector6D"""
3197 return _IMP_algebra.Vector6D___add__(self, ret)
3199 def __mul__(self, *args):
3201 __mul__(Vector6D self, double s) -> Vector6D
3202 __mul__(Vector6D self, Vector6D o) -> double
3204 return _IMP_algebra.Vector6D___mul__(self, *args)
3206 def __init__(self, *args):
3208 __init__(Vector6D self, IMP::Floats const & f) -> Vector6D
3209 __init__(Vector6D self) -> Vector6D
3210 __init__(Vector6D self, double x0, double x1, double x2, double x3, double x4, double x5) -> Vector6D
3212 _IMP_algebra.Vector6D_swiginit(self, _IMP_algebra.new_Vector6D(*args))
3214 def __iadd__(self, *args):
3215 _IMP_algebra.Vector6D___iadd__(self, *args)
3220 def __imul__(self, *args):
3221 _IMP_algebra.Vector6D___imul__(self, *args)
3226 def __idiv__(self, *args):
3227 _IMP_algebra.Vector6D___idiv__(self, *args)
3232 def __isub__(self, *args):
3233 _IMP_algebra.Vector6D___isub__(self, *args)
3239 r"""__len__(Vector6D self) -> unsigned int"""
3240 return _IMP_algebra.Vector6D___len__(self)
3242 def __rmul__(self, f):
3243 r"""__rmul__(Vector6D self, double f) -> Vector6D"""
3244 return _IMP_algebra.Vector6D___rmul__(self, f)
3247 r"""__str__(Vector6D self) -> std::string"""
3248 return _IMP_algebra.Vector6D___str__(self)
3251 r"""__repr__(Vector6D self) -> std::string"""
3252 return _IMP_algebra.Vector6D___repr__(self)
3254 def __cmp__(self, arg2):
3255 r"""__cmp__(Vector6D self, Vector6D arg2) -> int"""
3256 return _IMP_algebra.Vector6D___cmp__(self, arg2)
3258 def __eq__(self, arg2):
3259 r"""__eq__(Vector6D self, Vector6D arg2) -> bool"""
3260 return _IMP_algebra.Vector6D___eq__(self, arg2)
3262 __truediv__ = __div__
3263 __itruediv__ = __idiv__
3266 def _get_as_binary(self):
3267 r"""_get_as_binary(Vector6D self) -> PyObject *"""
3268 return _IMP_algebra.Vector6D__get_as_binary(self)
3270 def _set_from_binary(self, p):
3271 r"""_set_from_binary(Vector6D self, PyObject * p)"""
3272 return _IMP_algebra.Vector6D__set_from_binary(self, p)
3274 def __getstate__(self):
3275 p = self._get_as_binary()
3276 if len(self.__dict__) > 1:
3277 d = self.__dict__.copy()
3282 def __setstate__(self, p):
3283 if not hasattr(self,
'this'):
3285 if isinstance(p, tuple):
3287 self.__dict__.update(d)
3288 return self._set_from_binary(p)
3291 def __getitem__(self, index):
3292 r"""__getitem__(Vector6D self, int index) -> double"""
3293 return _IMP_algebra.Vector6D___getitem__(self, index)
3295 def __setitem__(self, index, val):
3296 r"""__setitem__(Vector6D self, int index, double val)"""
3297 return _IMP_algebra.Vector6D___setitem__(self, index, val)
3298 __swig_destroy__ = _IMP_algebra.delete_Vector6D
3301 _IMP_algebra.Vector6D_swigregister(Vector6D)
3303 r"""Proxy of C++ IMP::algebra::VectorD< -1 > class."""
3305 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3308 r"""get_unit_vector(VectorKD self) -> VectorKD"""
3309 return _IMP_algebra.VectorKD_get_unit_vector(self)
3311 def __truediv__(self, *args):
3312 return _IMP_algebra.VectorKD___truediv__(self, *args)
3313 __div__ = __truediv__
3318 r"""__neg__(VectorKD self) -> VectorKD"""
3319 return _IMP_algebra.VectorKD___neg__(self)
3321 def __sub__(self, o):
3322 r"""__sub__(VectorKD self, VectorKD o) -> VectorKD"""
3323 return _IMP_algebra.VectorKD___sub__(self, o)
3325 def __add__(self, ret):
3326 r"""__add__(VectorKD self, VectorKD ret) -> VectorKD"""
3327 return _IMP_algebra.VectorKD___add__(self, ret)
3329 def __mul__(self, *args):
3331 __mul__(VectorKD self, double s) -> VectorKD
3332 __mul__(VectorKD self, VectorKD o) -> double
3334 return _IMP_algebra.VectorKD___mul__(self, *args)
3336 def __init__(self, *args):
3338 __init__(VectorKD self, IMP::Floats const & f) -> VectorKD
3339 __init__(VectorKD self) -> VectorKD
3340 __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
3342 _IMP_algebra.VectorKD_swiginit(self, _IMP_algebra.new_VectorKD(*args))
3344 def __iadd__(self, *args):
3345 _IMP_algebra.VectorKD___iadd__(self, *args)
3350 def __imul__(self, *args):
3351 _IMP_algebra.VectorKD___imul__(self, *args)
3356 def __idiv__(self, *args):
3357 _IMP_algebra.VectorKD___idiv__(self, *args)
3362 def __isub__(self, *args):
3363 _IMP_algebra.VectorKD___isub__(self, *args)
3369 r"""__len__(VectorKD self) -> unsigned int"""
3370 return _IMP_algebra.VectorKD___len__(self)
3372 def __rmul__(self, f):
3373 r"""__rmul__(VectorKD self, double f) -> VectorKD"""
3374 return _IMP_algebra.VectorKD___rmul__(self, f)
3377 r"""__str__(VectorKD self) -> std::string"""
3378 return _IMP_algebra.VectorKD___str__(self)
3381 r"""__repr__(VectorKD self) -> std::string"""
3382 return _IMP_algebra.VectorKD___repr__(self)
3384 def __cmp__(self, arg2):
3385 r"""__cmp__(VectorKD self, VectorKD arg2) -> int"""
3386 return _IMP_algebra.VectorKD___cmp__(self, arg2)
3388 def __eq__(self, arg2):
3389 r"""__eq__(VectorKD self, VectorKD arg2) -> bool"""
3390 return _IMP_algebra.VectorKD___eq__(self, arg2)
3392 __truediv__ = __div__
3393 __itruediv__ = __idiv__
3396 def _get_as_binary(self):
3397 r"""_get_as_binary(VectorKD self) -> PyObject *"""
3398 return _IMP_algebra.VectorKD__get_as_binary(self)
3400 def _set_from_binary(self, p):
3401 r"""_set_from_binary(VectorKD self, PyObject * p)"""
3402 return _IMP_algebra.VectorKD__set_from_binary(self, p)
3404 def __getstate__(self):
3405 p = self._get_as_binary()
3406 if len(self.__dict__) > 1:
3407 d = self.__dict__.copy()
3412 def __setstate__(self, p):
3413 if not hasattr(self,
'this'):
3415 if isinstance(p, tuple):
3417 self.__dict__.update(d)
3418 return self._set_from_binary(p)
3421 def __getitem__(self, index):
3422 r"""__getitem__(VectorKD self, int index) -> double"""
3423 return _IMP_algebra.VectorKD___getitem__(self, index)
3425 def __setitem__(self, index, val):
3426 r"""__setitem__(VectorKD self, int index, double val)"""
3427 return _IMP_algebra.VectorKD___setitem__(self, index, val)
3428 __swig_destroy__ = _IMP_algebra.delete_VectorKD
3431 _IMP_algebra.VectorKD_swigregister(VectorKD)
3433 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 1 > class."""
3435 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3437 def get_dimension(self):
3438 r"""get_dimension(BoundingBox1D self) -> unsigned int"""
3439 return _IMP_algebra.BoundingBox1D_get_dimension(self)
3441 def get_corner(self, i):
3442 r"""get_corner(BoundingBox1D self, unsigned int i) -> Vector1D"""
3443 return _IMP_algebra.BoundingBox1D_get_corner(self, i)
3445 def get_contains(self, *args):
3447 get_contains(BoundingBox1D self, Vector1D o) -> bool
3448 get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
3450 return _IMP_algebra.BoundingBox1D_get_contains(self, *args)
3452 def show(self, *args):
3453 r"""show(BoundingBox1D self, _ostream out=std::cout)"""
3454 return _IMP_algebra.BoundingBox1D_show(self, *args)
3457 r"""__str__(BoundingBox1D self) -> std::string"""
3458 return _IMP_algebra.BoundingBox1D___str__(self)
3461 r"""__repr__(BoundingBox1D self) -> std::string"""
3462 return _IMP_algebra.BoundingBox1D___repr__(self)
3464 def __cmp__(self, arg2):
3465 r"""__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
3466 return _IMP_algebra.BoundingBox1D___cmp__(self, arg2)
3468 def __eq__(self, arg2):
3469 r"""__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
3470 return _IMP_algebra.BoundingBox1D___eq__(self, arg2)
3472 def __init__(self, *args):
3474 __init__(BoundingBox1D self, unsigned int d) -> BoundingBox1D
3475 __init__(BoundingBox1D self, Vector1D lb, Vector1D ub) -> BoundingBox1D
3476 __init__(BoundingBox1D self, Vector1D v) -> BoundingBox1D
3477 __init__(BoundingBox1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
3478 __init__(BoundingBox1D self) -> BoundingBox1D
3480 _IMP_algebra.BoundingBox1D_swiginit(self, _IMP_algebra.new_BoundingBox1D(*args))
3482 def __getitem__(self, index):
3483 r"""__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
3484 return _IMP_algebra.BoundingBox1D___getitem__(self, index)
3486 def __iadd__(self, *args):
3487 _IMP_algebra.BoundingBox1D___iadd__(self, *args)
3493 r"""__len__(BoundingBox1D self) -> unsigned int"""
3494 return _IMP_algebra.BoundingBox1D___len__(self)
3496 def __add__(self, *args):
3498 __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
3499 __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
3500 __add__(BoundingBox1D self, double o) -> BoundingBox1D
3502 return _IMP_algebra.BoundingBox1D___add__(self, *args)
3504 def _get_as_binary(self):
3505 r"""_get_as_binary(BoundingBox1D self) -> PyObject *"""
3506 return _IMP_algebra.BoundingBox1D__get_as_binary(self)
3508 def _set_from_binary(self, p):
3509 r"""_set_from_binary(BoundingBox1D self, PyObject * p)"""
3510 return _IMP_algebra.BoundingBox1D__set_from_binary(self, p)
3512 def __getstate__(self):
3513 p = self._get_as_binary()
3514 if len(self.__dict__) > 1:
3515 d = self.__dict__.copy()
3520 def __setstate__(self, p):
3521 if not hasattr(self,
'this'):
3523 if isinstance(p, tuple):
3525 self.__dict__.update(d)
3526 return self._set_from_binary(p)
3528 __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
3531 _IMP_algebra.BoundingBox1D_swigregister(BoundingBox1D)
3533 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 2 > class."""
3535 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3537 def get_dimension(self):
3538 r"""get_dimension(BoundingBox2D self) -> unsigned int"""
3539 return _IMP_algebra.BoundingBox2D_get_dimension(self)
3541 def get_corner(self, i):
3542 r"""get_corner(BoundingBox2D self, unsigned int i) -> Vector2D"""
3543 return _IMP_algebra.BoundingBox2D_get_corner(self, i)
3545 def get_contains(self, *args):
3547 get_contains(BoundingBox2D self, Vector2D o) -> bool
3548 get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
3550 return _IMP_algebra.BoundingBox2D_get_contains(self, *args)
3552 def show(self, *args):
3553 r"""show(BoundingBox2D self, _ostream out=std::cout)"""
3554 return _IMP_algebra.BoundingBox2D_show(self, *args)
3557 r"""__str__(BoundingBox2D self) -> std::string"""
3558 return _IMP_algebra.BoundingBox2D___str__(self)
3561 r"""__repr__(BoundingBox2D self) -> std::string"""
3562 return _IMP_algebra.BoundingBox2D___repr__(self)
3564 def __cmp__(self, arg2):
3565 r"""__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
3566 return _IMP_algebra.BoundingBox2D___cmp__(self, arg2)
3568 def __eq__(self, arg2):
3569 r"""__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
3570 return _IMP_algebra.BoundingBox2D___eq__(self, arg2)
3572 def __init__(self, *args):
3574 __init__(BoundingBox2D self, unsigned int d) -> BoundingBox2D
3575 __init__(BoundingBox2D self, Vector2D lb, Vector2D ub) -> BoundingBox2D
3576 __init__(BoundingBox2D self, Vector2D v) -> BoundingBox2D
3577 __init__(BoundingBox2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
3578 __init__(BoundingBox2D self) -> BoundingBox2D
3580 _IMP_algebra.BoundingBox2D_swiginit(self, _IMP_algebra.new_BoundingBox2D(*args))
3582 def __getitem__(self, index):
3583 r"""__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
3584 return _IMP_algebra.BoundingBox2D___getitem__(self, index)
3586 def __iadd__(self, *args):
3587 _IMP_algebra.BoundingBox2D___iadd__(self, *args)
3593 r"""__len__(BoundingBox2D self) -> unsigned int"""
3594 return _IMP_algebra.BoundingBox2D___len__(self)
3596 def __add__(self, *args):
3598 __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
3599 __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
3600 __add__(BoundingBox2D self, double o) -> BoundingBox2D
3602 return _IMP_algebra.BoundingBox2D___add__(self, *args)
3604 def _get_as_binary(self):
3605 r"""_get_as_binary(BoundingBox2D self) -> PyObject *"""
3606 return _IMP_algebra.BoundingBox2D__get_as_binary(self)
3608 def _set_from_binary(self, p):
3609 r"""_set_from_binary(BoundingBox2D self, PyObject * p)"""
3610 return _IMP_algebra.BoundingBox2D__set_from_binary(self, p)
3612 def __getstate__(self):
3613 p = self._get_as_binary()
3614 if len(self.__dict__) > 1:
3615 d = self.__dict__.copy()
3620 def __setstate__(self, p):
3621 if not hasattr(self,
'this'):
3623 if isinstance(p, tuple):
3625 self.__dict__.update(d)
3626 return self._set_from_binary(p)
3628 __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
3631 _IMP_algebra.BoundingBox2D_swigregister(BoundingBox2D)
3633 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 3 > class."""
3635 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3637 def get_dimension(self):
3638 r"""get_dimension(BoundingBox3D self) -> unsigned int"""
3639 return _IMP_algebra.BoundingBox3D_get_dimension(self)
3641 def get_corner(self, i):
3642 r"""get_corner(BoundingBox3D self, unsigned int i) -> Vector3D"""
3643 return _IMP_algebra.BoundingBox3D_get_corner(self, i)
3645 def get_contains(self, *args):
3647 get_contains(BoundingBox3D self, Vector3D o) -> bool
3648 get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
3650 return _IMP_algebra.BoundingBox3D_get_contains(self, *args)
3652 def show(self, *args):
3653 r"""show(BoundingBox3D self, _ostream out=std::cout)"""
3654 return _IMP_algebra.BoundingBox3D_show(self, *args)
3657 r"""__str__(BoundingBox3D self) -> std::string"""
3658 return _IMP_algebra.BoundingBox3D___str__(self)
3661 r"""__repr__(BoundingBox3D self) -> std::string"""
3662 return _IMP_algebra.BoundingBox3D___repr__(self)
3664 def __cmp__(self, arg2):
3665 r"""__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
3666 return _IMP_algebra.BoundingBox3D___cmp__(self, arg2)
3668 def __eq__(self, arg2):
3669 r"""__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
3670 return _IMP_algebra.BoundingBox3D___eq__(self, arg2)
3672 def __init__(self, *args):
3674 __init__(BoundingBox3D self, unsigned int d) -> BoundingBox3D
3675 __init__(BoundingBox3D self, Vector3D lb, Vector3D ub) -> BoundingBox3D
3676 __init__(BoundingBox3D self, Vector3D v) -> BoundingBox3D
3677 __init__(BoundingBox3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
3678 __init__(BoundingBox3D self) -> BoundingBox3D
3680 _IMP_algebra.BoundingBox3D_swiginit(self, _IMP_algebra.new_BoundingBox3D(*args))
3682 def __getitem__(self, index):
3683 r"""__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
3684 return _IMP_algebra.BoundingBox3D___getitem__(self, index)
3686 def __iadd__(self, *args):
3687 _IMP_algebra.BoundingBox3D___iadd__(self, *args)
3693 r"""__len__(BoundingBox3D self) -> unsigned int"""
3694 return _IMP_algebra.BoundingBox3D___len__(self)
3696 def __add__(self, *args):
3698 __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
3699 __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
3700 __add__(BoundingBox3D self, double o) -> BoundingBox3D
3702 return _IMP_algebra.BoundingBox3D___add__(self, *args)
3704 def _get_as_binary(self):
3705 r"""_get_as_binary(BoundingBox3D self) -> PyObject *"""
3706 return _IMP_algebra.BoundingBox3D__get_as_binary(self)
3708 def _set_from_binary(self, p):
3709 r"""_set_from_binary(BoundingBox3D self, PyObject * p)"""
3710 return _IMP_algebra.BoundingBox3D__set_from_binary(self, p)
3712 def __getstate__(self):
3713 p = self._get_as_binary()
3714 if len(self.__dict__) > 1:
3715 d = self.__dict__.copy()
3720 def __setstate__(self, p):
3721 if not hasattr(self,
'this'):
3723 if isinstance(p, tuple):
3725 self.__dict__.update(d)
3726 return self._set_from_binary(p)
3728 __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
3731 _IMP_algebra.BoundingBox3D_swigregister(BoundingBox3D)
3733 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 4 > class."""
3735 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3737 def get_dimension(self):
3738 r"""get_dimension(BoundingBox4D self) -> unsigned int"""
3739 return _IMP_algebra.BoundingBox4D_get_dimension(self)
3741 def get_corner(self, i):
3742 r"""get_corner(BoundingBox4D self, unsigned int i) -> Vector4D"""
3743 return _IMP_algebra.BoundingBox4D_get_corner(self, i)
3745 def get_contains(self, *args):
3747 get_contains(BoundingBox4D self, Vector4D o) -> bool
3748 get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
3750 return _IMP_algebra.BoundingBox4D_get_contains(self, *args)
3752 def show(self, *args):
3753 r"""show(BoundingBox4D self, _ostream out=std::cout)"""
3754 return _IMP_algebra.BoundingBox4D_show(self, *args)
3757 r"""__str__(BoundingBox4D self) -> std::string"""
3758 return _IMP_algebra.BoundingBox4D___str__(self)
3761 r"""__repr__(BoundingBox4D self) -> std::string"""
3762 return _IMP_algebra.BoundingBox4D___repr__(self)
3764 def __cmp__(self, arg2):
3765 r"""__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
3766 return _IMP_algebra.BoundingBox4D___cmp__(self, arg2)
3768 def __eq__(self, arg2):
3769 r"""__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
3770 return _IMP_algebra.BoundingBox4D___eq__(self, arg2)
3772 def __init__(self, *args):
3774 __init__(BoundingBox4D self, unsigned int d) -> BoundingBox4D
3775 __init__(BoundingBox4D self, Vector4D lb, Vector4D ub) -> BoundingBox4D
3776 __init__(BoundingBox4D self, Vector4D v) -> BoundingBox4D
3777 __init__(BoundingBox4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
3778 __init__(BoundingBox4D self) -> BoundingBox4D
3780 _IMP_algebra.BoundingBox4D_swiginit(self, _IMP_algebra.new_BoundingBox4D(*args))
3782 def __getitem__(self, index):
3783 r"""__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
3784 return _IMP_algebra.BoundingBox4D___getitem__(self, index)
3786 def __iadd__(self, *args):
3787 _IMP_algebra.BoundingBox4D___iadd__(self, *args)
3793 r"""__len__(BoundingBox4D self) -> unsigned int"""
3794 return _IMP_algebra.BoundingBox4D___len__(self)
3796 def __add__(self, *args):
3798 __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
3799 __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
3800 __add__(BoundingBox4D self, double o) -> BoundingBox4D
3802 return _IMP_algebra.BoundingBox4D___add__(self, *args)
3804 def _get_as_binary(self):
3805 r"""_get_as_binary(BoundingBox4D self) -> PyObject *"""
3806 return _IMP_algebra.BoundingBox4D__get_as_binary(self)
3808 def _set_from_binary(self, p):
3809 r"""_set_from_binary(BoundingBox4D self, PyObject * p)"""
3810 return _IMP_algebra.BoundingBox4D__set_from_binary(self, p)
3812 def __getstate__(self):
3813 p = self._get_as_binary()
3814 if len(self.__dict__) > 1:
3815 d = self.__dict__.copy()
3820 def __setstate__(self, p):
3821 if not hasattr(self,
'this'):
3823 if isinstance(p, tuple):
3825 self.__dict__.update(d)
3826 return self._set_from_binary(p)
3828 __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
3831 _IMP_algebra.BoundingBox4D_swigregister(BoundingBox4D)
3833 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 5 > class."""
3835 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3837 def get_dimension(self):
3838 r"""get_dimension(BoundingBox5D self) -> unsigned int"""
3839 return _IMP_algebra.BoundingBox5D_get_dimension(self)
3841 def get_corner(self, i):
3842 r"""get_corner(BoundingBox5D self, unsigned int i) -> Vector5D"""
3843 return _IMP_algebra.BoundingBox5D_get_corner(self, i)
3845 def get_contains(self, *args):
3847 get_contains(BoundingBox5D self, Vector5D o) -> bool
3848 get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
3850 return _IMP_algebra.BoundingBox5D_get_contains(self, *args)
3852 def show(self, *args):
3853 r"""show(BoundingBox5D self, _ostream out=std::cout)"""
3854 return _IMP_algebra.BoundingBox5D_show(self, *args)
3857 r"""__str__(BoundingBox5D self) -> std::string"""
3858 return _IMP_algebra.BoundingBox5D___str__(self)
3861 r"""__repr__(BoundingBox5D self) -> std::string"""
3862 return _IMP_algebra.BoundingBox5D___repr__(self)
3864 def __cmp__(self, arg2):
3865 r"""__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
3866 return _IMP_algebra.BoundingBox5D___cmp__(self, arg2)
3868 def __eq__(self, arg2):
3869 r"""__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
3870 return _IMP_algebra.BoundingBox5D___eq__(self, arg2)
3872 def __init__(self, *args):
3874 __init__(BoundingBox5D self, unsigned int d) -> BoundingBox5D
3875 __init__(BoundingBox5D self, Vector5D lb, Vector5D ub) -> BoundingBox5D
3876 __init__(BoundingBox5D self, Vector5D v) -> BoundingBox5D
3877 __init__(BoundingBox5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
3878 __init__(BoundingBox5D self) -> BoundingBox5D
3880 _IMP_algebra.BoundingBox5D_swiginit(self, _IMP_algebra.new_BoundingBox5D(*args))
3882 def __getitem__(self, index):
3883 r"""__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
3884 return _IMP_algebra.BoundingBox5D___getitem__(self, index)
3886 def __iadd__(self, *args):
3887 _IMP_algebra.BoundingBox5D___iadd__(self, *args)
3893 r"""__len__(BoundingBox5D self) -> unsigned int"""
3894 return _IMP_algebra.BoundingBox5D___len__(self)
3896 def __add__(self, *args):
3898 __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
3899 __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
3900 __add__(BoundingBox5D self, double o) -> BoundingBox5D
3902 return _IMP_algebra.BoundingBox5D___add__(self, *args)
3904 def _get_as_binary(self):
3905 r"""_get_as_binary(BoundingBox5D self) -> PyObject *"""
3906 return _IMP_algebra.BoundingBox5D__get_as_binary(self)
3908 def _set_from_binary(self, p):
3909 r"""_set_from_binary(BoundingBox5D self, PyObject * p)"""
3910 return _IMP_algebra.BoundingBox5D__set_from_binary(self, p)
3912 def __getstate__(self):
3913 p = self._get_as_binary()
3914 if len(self.__dict__) > 1:
3915 d = self.__dict__.copy()
3920 def __setstate__(self, p):
3921 if not hasattr(self,
'this'):
3923 if isinstance(p, tuple):
3925 self.__dict__.update(d)
3926 return self._set_from_binary(p)
3928 __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D
3931 _IMP_algebra.BoundingBox5D_swigregister(BoundingBox5D)
3933 r"""Proxy of C++ IMP::algebra::BoundingBoxD< 6 > class."""
3935 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3937 def get_dimension(self):
3938 r"""get_dimension(BoundingBox6D self) -> unsigned int"""
3939 return _IMP_algebra.BoundingBox6D_get_dimension(self)
3941 def get_corner(self, i):
3942 r"""get_corner(BoundingBox6D self, unsigned int i) -> Vector6D"""
3943 return _IMP_algebra.BoundingBox6D_get_corner(self, i)
3945 def get_contains(self, *args):
3947 get_contains(BoundingBox6D self, Vector6D o) -> bool
3948 get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
3950 return _IMP_algebra.BoundingBox6D_get_contains(self, *args)
3952 def show(self, *args):
3953 r"""show(BoundingBox6D self, _ostream out=std::cout)"""
3954 return _IMP_algebra.BoundingBox6D_show(self, *args)
3957 r"""__str__(BoundingBox6D self) -> std::string"""
3958 return _IMP_algebra.BoundingBox6D___str__(self)
3961 r"""__repr__(BoundingBox6D self) -> std::string"""
3962 return _IMP_algebra.BoundingBox6D___repr__(self)
3964 def __cmp__(self, arg2):
3965 r"""__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
3966 return _IMP_algebra.BoundingBox6D___cmp__(self, arg2)
3968 def __eq__(self, arg2):
3969 r"""__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
3970 return _IMP_algebra.BoundingBox6D___eq__(self, arg2)
3972 def __init__(self, *args):
3974 __init__(BoundingBox6D self, unsigned int d) -> BoundingBox6D
3975 __init__(BoundingBox6D self, Vector6D lb, Vector6D ub) -> BoundingBox6D
3976 __init__(BoundingBox6D self, Vector6D v) -> BoundingBox6D
3977 __init__(BoundingBox6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
3978 __init__(BoundingBox6D self) -> BoundingBox6D
3980 _IMP_algebra.BoundingBox6D_swiginit(self, _IMP_algebra.new_BoundingBox6D(*args))
3982 def __getitem__(self, index):
3983 r"""__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
3984 return _IMP_algebra.BoundingBox6D___getitem__(self, index)
3986 def __iadd__(self, *args):
3987 _IMP_algebra.BoundingBox6D___iadd__(self, *args)
3993 r"""__len__(BoundingBox6D self) -> unsigned int"""
3994 return _IMP_algebra.BoundingBox6D___len__(self)
3996 def __add__(self, *args):
3998 __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
3999 __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
4000 __add__(BoundingBox6D self, double o) -> BoundingBox6D
4002 return _IMP_algebra.BoundingBox6D___add__(self, *args)
4004 def _get_as_binary(self):
4005 r"""_get_as_binary(BoundingBox6D self) -> PyObject *"""
4006 return _IMP_algebra.BoundingBox6D__get_as_binary(self)
4008 def _set_from_binary(self, p):
4009 r"""_set_from_binary(BoundingBox6D self, PyObject * p)"""
4010 return _IMP_algebra.BoundingBox6D__set_from_binary(self, p)
4012 def __getstate__(self):
4013 p = self._get_as_binary()
4014 if len(self.__dict__) > 1:
4015 d = self.__dict__.copy()
4020 def __setstate__(self, p):
4021 if not hasattr(self,
'this'):
4023 if isinstance(p, tuple):
4025 self.__dict__.update(d)
4026 return self._set_from_binary(p)
4028 __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
4031 _IMP_algebra.BoundingBox6D_swigregister(BoundingBox6D)
4033 r"""Proxy of C++ IMP::algebra::BoundingBoxD< -1 > class."""
4035 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4037 def get_dimension(self):
4038 r"""get_dimension(BoundingBoxKD self) -> unsigned int"""
4039 return _IMP_algebra.BoundingBoxKD_get_dimension(self)
4041 def get_corner(self, i):
4042 r"""get_corner(BoundingBoxKD self, unsigned int i) -> VectorKD"""
4043 return _IMP_algebra.BoundingBoxKD_get_corner(self, i)
4045 def get_contains(self, *args):
4047 get_contains(BoundingBoxKD self, VectorKD o) -> bool
4048 get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
4050 return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)
4052 def show(self, *args):
4053 r"""show(BoundingBoxKD self, _ostream out=std::cout)"""
4054 return _IMP_algebra.BoundingBoxKD_show(self, *args)
4057 r"""__str__(BoundingBoxKD self) -> std::string"""
4058 return _IMP_algebra.BoundingBoxKD___str__(self)
4061 r"""__repr__(BoundingBoxKD self) -> std::string"""
4062 return _IMP_algebra.BoundingBoxKD___repr__(self)
4064 def __cmp__(self, arg2):
4065 r"""__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
4066 return _IMP_algebra.BoundingBoxKD___cmp__(self, arg2)
4068 def __eq__(self, arg2):
4069 r"""__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
4070 return _IMP_algebra.BoundingBoxKD___eq__(self, arg2)
4072 def __init__(self, *args):
4074 __init__(BoundingBoxKD self, unsigned int d) -> BoundingBoxKD
4075 __init__(BoundingBoxKD self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
4076 __init__(BoundingBoxKD self, VectorKD v) -> BoundingBoxKD
4077 __init__(BoundingBoxKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
4078 __init__(BoundingBoxKD self) -> BoundingBoxKD
4080 _IMP_algebra.BoundingBoxKD_swiginit(self, _IMP_algebra.new_BoundingBoxKD(*args))
4082 def __getitem__(self, index):
4083 r"""__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
4084 return _IMP_algebra.BoundingBoxKD___getitem__(self, index)
4086 def __iadd__(self, *args):
4087 _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
4093 r"""__len__(BoundingBoxKD self) -> unsigned int"""
4094 return _IMP_algebra.BoundingBoxKD___len__(self)
4096 def __add__(self, *args):
4098 __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
4099 __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
4100 __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
4102 return _IMP_algebra.BoundingBoxKD___add__(self, *args)
4104 def _get_as_binary(self):
4105 r"""_get_as_binary(BoundingBoxKD self) -> PyObject *"""
4106 return _IMP_algebra.BoundingBoxKD__get_as_binary(self)
4108 def _set_from_binary(self, p):
4109 r"""_set_from_binary(BoundingBoxKD self, PyObject * p)"""
4110 return _IMP_algebra.BoundingBoxKD__set_from_binary(self, p)
4112 def __getstate__(self):
4113 p = self._get_as_binary()
4114 if len(self.__dict__) > 1:
4115 d = self.__dict__.copy()
4120 def __setstate__(self, p):
4121 if not hasattr(self,
'this'):
4123 if isinstance(p, tuple):
4125 self.__dict__.update(d)
4126 return self._set_from_binary(p)
4128 __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
4131 _IMP_algebra.BoundingBoxKD_swigregister(BoundingBoxKD)
4132 class Sphere1D(_GeometricPrimitive1D):
4133 r"""Proxy of C++ IMP::algebra::SphereD< 1 > class."""
4135 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4137 def __init__(self, *args):
4139 __init__(Sphere1D self) -> Sphere1D
4140 __init__(Sphere1D self, Vector1D center, double radius) -> Sphere1D
4142 _IMP_algebra.Sphere1D_swiginit(self, _IMP_algebra.new_Sphere1D(*args))
4144 def get_radius(self):
4145 r"""get_radius(Sphere1D self) -> double"""
4146 return _IMP_algebra.Sphere1D_get_radius(self)
4148 def get_center(self):
4149 r"""get_center(Sphere1D self) -> Vector1D"""
4150 return _IMP_algebra.Sphere1D_get_center(self)
4152 def get_contains(self, *args):
4154 get_contains(Sphere1D self, Sphere1D o) -> bool
4155 get_contains(Sphere1D self, Vector1D p) -> bool
4157 return _IMP_algebra.Sphere1D_get_contains(self, *args)
4159 def show(self, *args):
4160 r"""show(Sphere1D self, _ostream out=std::cout)"""
4161 return _IMP_algebra.Sphere1D_show(self, *args)
4163 def get_dimension(self):
4164 r"""get_dimension(Sphere1D self) -> unsigned int"""
4165 return _IMP_algebra.Sphere1D_get_dimension(self)
4168 r"""__str__(Sphere1D self) -> std::string"""
4169 return _IMP_algebra.Sphere1D___str__(self)
4172 r"""__repr__(Sphere1D self) -> std::string"""
4173 return _IMP_algebra.Sphere1D___repr__(self)
4175 def __cmp__(self, arg2):
4176 r"""__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
4177 return _IMP_algebra.Sphere1D___cmp__(self, arg2)
4179 def __eq__(self, arg2):
4180 r"""__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
4181 return _IMP_algebra.Sphere1D___eq__(self, arg2)
4183 def _get_as_binary(self):
4184 r"""_get_as_binary(Sphere1D self) -> PyObject *"""
4185 return _IMP_algebra.Sphere1D__get_as_binary(self)
4187 def _set_from_binary(self, p):
4188 r"""_set_from_binary(Sphere1D self, PyObject * p)"""
4189 return _IMP_algebra.Sphere1D__set_from_binary(self, p)
4191 def __getstate__(self):
4192 p = self._get_as_binary()
4193 if len(self.__dict__) > 1:
4194 d = self.__dict__.copy()
4199 def __setstate__(self, p):
4200 if not hasattr(self,
'this'):
4202 if isinstance(p, tuple):
4204 self.__dict__.update(d)
4205 return self._set_from_binary(p)
4207 __swig_destroy__ = _IMP_algebra.delete_Sphere1D
4210 _IMP_algebra.Sphere1D_swigregister(Sphere1D)
4211 class Sphere2D(_GeometricPrimitive2D):
4212 r"""Proxy of C++ IMP::algebra::SphereD< 2 > class."""
4214 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4216 def __init__(self, *args):
4218 __init__(Sphere2D self) -> Sphere2D
4219 __init__(Sphere2D self, Vector2D center, double radius) -> Sphere2D
4221 _IMP_algebra.Sphere2D_swiginit(self, _IMP_algebra.new_Sphere2D(*args))
4223 def get_radius(self):
4224 r"""get_radius(Sphere2D self) -> double"""
4225 return _IMP_algebra.Sphere2D_get_radius(self)
4227 def get_center(self):
4228 r"""get_center(Sphere2D self) -> Vector2D"""
4229 return _IMP_algebra.Sphere2D_get_center(self)
4231 def get_contains(self, *args):
4233 get_contains(Sphere2D self, Sphere2D o) -> bool
4234 get_contains(Sphere2D self, Vector2D p) -> bool
4236 return _IMP_algebra.Sphere2D_get_contains(self, *args)
4238 def show(self, *args):
4239 r"""show(Sphere2D self, _ostream out=std::cout)"""
4240 return _IMP_algebra.Sphere2D_show(self, *args)
4242 def get_dimension(self):
4243 r"""get_dimension(Sphere2D self) -> unsigned int"""
4244 return _IMP_algebra.Sphere2D_get_dimension(self)
4247 r"""__str__(Sphere2D self) -> std::string"""
4248 return _IMP_algebra.Sphere2D___str__(self)
4251 r"""__repr__(Sphere2D self) -> std::string"""
4252 return _IMP_algebra.Sphere2D___repr__(self)
4254 def __cmp__(self, arg2):
4255 r"""__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
4256 return _IMP_algebra.Sphere2D___cmp__(self, arg2)
4258 def __eq__(self, arg2):
4259 r"""__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
4260 return _IMP_algebra.Sphere2D___eq__(self, arg2)
4262 def _get_as_binary(self):
4263 r"""_get_as_binary(Sphere2D self) -> PyObject *"""
4264 return _IMP_algebra.Sphere2D__get_as_binary(self)
4266 def _set_from_binary(self, p):
4267 r"""_set_from_binary(Sphere2D self, PyObject * p)"""
4268 return _IMP_algebra.Sphere2D__set_from_binary(self, p)
4270 def __getstate__(self):
4271 p = self._get_as_binary()
4272 if len(self.__dict__) > 1:
4273 d = self.__dict__.copy()
4278 def __setstate__(self, p):
4279 if not hasattr(self,
'this'):
4281 if isinstance(p, tuple):
4283 self.__dict__.update(d)
4284 return self._set_from_binary(p)
4286 __swig_destroy__ = _IMP_algebra.delete_Sphere2D
4289 _IMP_algebra.Sphere2D_swigregister(Sphere2D)
4290 class Sphere3D(_GeometricPrimitive3D):
4291 r"""Proxy of C++ IMP::algebra::SphereD< 3 > class."""
4293 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4295 def __init__(self, *args):
4297 __init__(Sphere3D self) -> Sphere3D
4298 __init__(Sphere3D self, Vector3D center, double radius) -> Sphere3D
4300 _IMP_algebra.Sphere3D_swiginit(self, _IMP_algebra.new_Sphere3D(*args))
4302 def get_radius(self):
4303 r"""get_radius(Sphere3D self) -> double"""
4304 return _IMP_algebra.Sphere3D_get_radius(self)
4306 def get_center(self):
4307 r"""get_center(Sphere3D self) -> Vector3D"""
4308 return _IMP_algebra.Sphere3D_get_center(self)
4310 def get_contains(self, *args):
4312 get_contains(Sphere3D self, Sphere3D o) -> bool
4313 get_contains(Sphere3D self, Vector3D p) -> bool
4315 return _IMP_algebra.Sphere3D_get_contains(self, *args)
4317 def show(self, *args):
4318 r"""show(Sphere3D self, _ostream out=std::cout)"""
4319 return _IMP_algebra.Sphere3D_show(self, *args)
4321 def get_dimension(self):
4322 r"""get_dimension(Sphere3D self) -> unsigned int"""
4323 return _IMP_algebra.Sphere3D_get_dimension(self)
4326 r"""__str__(Sphere3D self) -> std::string"""
4327 return _IMP_algebra.Sphere3D___str__(self)
4330 r"""__repr__(Sphere3D self) -> std::string"""
4331 return _IMP_algebra.Sphere3D___repr__(self)
4333 def __cmp__(self, arg2):
4334 r"""__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
4335 return _IMP_algebra.Sphere3D___cmp__(self, arg2)
4337 def __eq__(self, arg2):
4338 r"""__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
4339 return _IMP_algebra.Sphere3D___eq__(self, arg2)
4341 def _get_as_binary(self):
4342 r"""_get_as_binary(Sphere3D self) -> PyObject *"""
4343 return _IMP_algebra.Sphere3D__get_as_binary(self)
4345 def _set_from_binary(self, p):
4346 r"""_set_from_binary(Sphere3D self, PyObject * p)"""
4347 return _IMP_algebra.Sphere3D__set_from_binary(self, p)
4349 def __getstate__(self):
4350 p = self._get_as_binary()
4351 if len(self.__dict__) > 1:
4352 d = self.__dict__.copy()
4357 def __setstate__(self, p):
4358 if not hasattr(self,
'this'):
4360 if isinstance(p, tuple):
4362 self.__dict__.update(d)
4363 return self._set_from_binary(p)
4365 __swig_destroy__ = _IMP_algebra.delete_Sphere3D
4368 _IMP_algebra.Sphere3D_swigregister(Sphere3D)
4369 class Sphere4D(_GeometricPrimitive4D):
4370 r"""Proxy of C++ IMP::algebra::SphereD< 4 > class."""
4372 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4374 def __init__(self, *args):
4376 __init__(Sphere4D self) -> Sphere4D
4377 __init__(Sphere4D self, Vector4D center, double radius) -> Sphere4D
4379 _IMP_algebra.Sphere4D_swiginit(self, _IMP_algebra.new_Sphere4D(*args))
4381 def get_radius(self):
4382 r"""get_radius(Sphere4D self) -> double"""
4383 return _IMP_algebra.Sphere4D_get_radius(self)
4385 def get_center(self):
4386 r"""get_center(Sphere4D self) -> Vector4D"""
4387 return _IMP_algebra.Sphere4D_get_center(self)
4389 def get_contains(self, *args):
4391 get_contains(Sphere4D self, Sphere4D o) -> bool
4392 get_contains(Sphere4D self, Vector4D p) -> bool
4394 return _IMP_algebra.Sphere4D_get_contains(self, *args)
4396 def show(self, *args):
4397 r"""show(Sphere4D self, _ostream out=std::cout)"""
4398 return _IMP_algebra.Sphere4D_show(self, *args)
4400 def get_dimension(self):
4401 r"""get_dimension(Sphere4D self) -> unsigned int"""
4402 return _IMP_algebra.Sphere4D_get_dimension(self)
4405 r"""__str__(Sphere4D self) -> std::string"""
4406 return _IMP_algebra.Sphere4D___str__(self)
4409 r"""__repr__(Sphere4D self) -> std::string"""
4410 return _IMP_algebra.Sphere4D___repr__(self)
4412 def __cmp__(self, arg2):
4413 r"""__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
4414 return _IMP_algebra.Sphere4D___cmp__(self, arg2)
4416 def __eq__(self, arg2):
4417 r"""__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
4418 return _IMP_algebra.Sphere4D___eq__(self, arg2)
4420 def _get_as_binary(self):
4421 r"""_get_as_binary(Sphere4D self) -> PyObject *"""
4422 return _IMP_algebra.Sphere4D__get_as_binary(self)
4424 def _set_from_binary(self, p):
4425 r"""_set_from_binary(Sphere4D self, PyObject * p)"""
4426 return _IMP_algebra.Sphere4D__set_from_binary(self, p)
4428 def __getstate__(self):
4429 p = self._get_as_binary()
4430 if len(self.__dict__) > 1:
4431 d = self.__dict__.copy()
4436 def __setstate__(self, p):
4437 if not hasattr(self,
'this'):
4439 if isinstance(p, tuple):
4441 self.__dict__.update(d)
4442 return self._set_from_binary(p)
4444 __swig_destroy__ = _IMP_algebra.delete_Sphere4D
4447 _IMP_algebra.Sphere4D_swigregister(Sphere4D)
4448 class Sphere5D(_GeometricPrimitive5D):
4449 r"""Proxy of C++ IMP::algebra::SphereD< 5 > class."""
4451 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4453 def __init__(self, *args):
4455 __init__(Sphere5D self) -> Sphere5D
4456 __init__(Sphere5D self, Vector5D center, double radius) -> Sphere5D
4458 _IMP_algebra.Sphere5D_swiginit(self, _IMP_algebra.new_Sphere5D(*args))
4460 def get_radius(self):
4461 r"""get_radius(Sphere5D self) -> double"""
4462 return _IMP_algebra.Sphere5D_get_radius(self)
4464 def get_center(self):
4465 r"""get_center(Sphere5D self) -> Vector5D"""
4466 return _IMP_algebra.Sphere5D_get_center(self)
4468 def get_contains(self, *args):
4470 get_contains(Sphere5D self, Sphere5D o) -> bool
4471 get_contains(Sphere5D self, Vector5D p) -> bool
4473 return _IMP_algebra.Sphere5D_get_contains(self, *args)
4475 def show(self, *args):
4476 r"""show(Sphere5D self, _ostream out=std::cout)"""
4477 return _IMP_algebra.Sphere5D_show(self, *args)
4479 def get_dimension(self):
4480 r"""get_dimension(Sphere5D self) -> unsigned int"""
4481 return _IMP_algebra.Sphere5D_get_dimension(self)
4484 r"""__str__(Sphere5D self) -> std::string"""
4485 return _IMP_algebra.Sphere5D___str__(self)
4488 r"""__repr__(Sphere5D self) -> std::string"""
4489 return _IMP_algebra.Sphere5D___repr__(self)
4491 def __cmp__(self, arg2):
4492 r"""__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
4493 return _IMP_algebra.Sphere5D___cmp__(self, arg2)
4495 def __eq__(self, arg2):
4496 r"""__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
4497 return _IMP_algebra.Sphere5D___eq__(self, arg2)
4499 def _get_as_binary(self):
4500 r"""_get_as_binary(Sphere5D self) -> PyObject *"""
4501 return _IMP_algebra.Sphere5D__get_as_binary(self)
4503 def _set_from_binary(self, p):
4504 r"""_set_from_binary(Sphere5D self, PyObject * p)"""
4505 return _IMP_algebra.Sphere5D__set_from_binary(self, p)
4507 def __getstate__(self):
4508 p = self._get_as_binary()
4509 if len(self.__dict__) > 1:
4510 d = self.__dict__.copy()
4515 def __setstate__(self, p):
4516 if not hasattr(self,
'this'):
4518 if isinstance(p, tuple):
4520 self.__dict__.update(d)
4521 return self._set_from_binary(p)
4523 __swig_destroy__ = _IMP_algebra.delete_Sphere5D
4526 _IMP_algebra.Sphere5D_swigregister(Sphere5D)
4527 class Sphere6D(_GeometricPrimitive6D):
4528 r"""Proxy of C++ IMP::algebra::SphereD< 6 > class."""
4530 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4532 def __init__(self, *args):
4534 __init__(Sphere6D self) -> Sphere6D
4535 __init__(Sphere6D self, Vector6D center, double radius) -> Sphere6D
4537 _IMP_algebra.Sphere6D_swiginit(self, _IMP_algebra.new_Sphere6D(*args))
4539 def get_radius(self):
4540 r"""get_radius(Sphere6D self) -> double"""
4541 return _IMP_algebra.Sphere6D_get_radius(self)
4543 def get_center(self):
4544 r"""get_center(Sphere6D self) -> Vector6D"""
4545 return _IMP_algebra.Sphere6D_get_center(self)
4547 def get_contains(self, *args):
4549 get_contains(Sphere6D self, Sphere6D o) -> bool
4550 get_contains(Sphere6D self, Vector6D p) -> bool
4552 return _IMP_algebra.Sphere6D_get_contains(self, *args)
4554 def show(self, *args):
4555 r"""show(Sphere6D self, _ostream out=std::cout)"""
4556 return _IMP_algebra.Sphere6D_show(self, *args)
4558 def get_dimension(self):
4559 r"""get_dimension(Sphere6D self) -> unsigned int"""
4560 return _IMP_algebra.Sphere6D_get_dimension(self)
4563 r"""__str__(Sphere6D self) -> std::string"""
4564 return _IMP_algebra.Sphere6D___str__(self)
4567 r"""__repr__(Sphere6D self) -> std::string"""
4568 return _IMP_algebra.Sphere6D___repr__(self)
4570 def __cmp__(self, arg2):
4571 r"""__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
4572 return _IMP_algebra.Sphere6D___cmp__(self, arg2)
4574 def __eq__(self, arg2):
4575 r"""__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
4576 return _IMP_algebra.Sphere6D___eq__(self, arg2)
4578 def _get_as_binary(self):
4579 r"""_get_as_binary(Sphere6D self) -> PyObject *"""
4580 return _IMP_algebra.Sphere6D__get_as_binary(self)
4582 def _set_from_binary(self, p):
4583 r"""_set_from_binary(Sphere6D self, PyObject * p)"""
4584 return _IMP_algebra.Sphere6D__set_from_binary(self, p)
4586 def __getstate__(self):
4587 p = self._get_as_binary()
4588 if len(self.__dict__) > 1:
4589 d = self.__dict__.copy()
4594 def __setstate__(self, p):
4595 if not hasattr(self,
'this'):
4597 if isinstance(p, tuple):
4599 self.__dict__.update(d)
4600 return self._set_from_binary(p)
4602 __swig_destroy__ = _IMP_algebra.delete_Sphere6D
4605 _IMP_algebra.Sphere6D_swigregister(Sphere6D)
4606 class SphereKD(_GeometricPrimitiveKD):
4607 r"""Proxy of C++ IMP::algebra::SphereD< -1 > class."""
4609 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4611 def __init__(self, *args):
4613 __init__(SphereKD self) -> SphereKD
4614 __init__(SphereKD self, VectorKD center, double radius) -> SphereKD
4616 _IMP_algebra.SphereKD_swiginit(self, _IMP_algebra.new_SphereKD(*args))
4618 def get_radius(self):
4619 r"""get_radius(SphereKD self) -> double"""
4620 return _IMP_algebra.SphereKD_get_radius(self)
4622 def get_center(self):
4623 r"""get_center(SphereKD self) -> VectorKD"""
4624 return _IMP_algebra.SphereKD_get_center(self)
4626 def get_contains(self, *args):
4628 get_contains(SphereKD self, SphereKD o) -> bool
4629 get_contains(SphereKD self, VectorKD p) -> bool
4631 return _IMP_algebra.SphereKD_get_contains(self, *args)
4633 def show(self, *args):
4634 r"""show(SphereKD self, _ostream out=std::cout)"""
4635 return _IMP_algebra.SphereKD_show(self, *args)
4637 def get_dimension(self):
4638 r"""get_dimension(SphereKD self) -> unsigned int"""
4639 return _IMP_algebra.SphereKD_get_dimension(self)
4642 r"""__str__(SphereKD self) -> std::string"""
4643 return _IMP_algebra.SphereKD___str__(self)
4646 r"""__repr__(SphereKD self) -> std::string"""
4647 return _IMP_algebra.SphereKD___repr__(self)
4649 def __cmp__(self, arg2):
4650 r"""__cmp__(SphereKD self, SphereKD arg2) -> int"""
4651 return _IMP_algebra.SphereKD___cmp__(self, arg2)
4653 def __eq__(self, arg2):
4654 r"""__eq__(SphereKD self, SphereKD arg2) -> bool"""
4655 return _IMP_algebra.SphereKD___eq__(self, arg2)
4657 def _get_as_binary(self):
4658 r"""_get_as_binary(SphereKD self) -> PyObject *"""
4659 return _IMP_algebra.SphereKD__get_as_binary(self)
4661 def _set_from_binary(self, p):
4662 r"""_set_from_binary(SphereKD self, PyObject * p)"""
4663 return _IMP_algebra.SphereKD__set_from_binary(self, p)
4665 def __getstate__(self):
4666 p = self._get_as_binary()
4667 if len(self.__dict__) > 1:
4668 d = self.__dict__.copy()
4673 def __setstate__(self, p):
4674 if not hasattr(self,
'this'):
4676 if isinstance(p, tuple):
4678 self.__dict__.update(d)
4679 return self._set_from_binary(p)
4681 __swig_destroy__ = _IMP_algebra.delete_SphereKD
4684 _IMP_algebra.SphereKD_swigregister(SphereKD)
4685 class UnitSimplex1D(_UnitSimplexBase1D):
4686 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 1 > class."""
4688 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4691 r"""__init__(UnitSimplex1D self) -> UnitSimplex1D"""
4692 _IMP_algebra.UnitSimplex1D_swiginit(self, _IMP_algebra.new_UnitSimplex1D())
4694 def show(self, *args):
4695 r"""show(UnitSimplex1D self, _ostream out=std::cout)"""
4696 return _IMP_algebra.UnitSimplex1D_show(self, *args)
4699 r"""__str__(UnitSimplex1D self) -> std::string"""
4700 return _IMP_algebra.UnitSimplex1D___str__(self)
4703 r"""__repr__(UnitSimplex1D self) -> std::string"""
4704 return _IMP_algebra.UnitSimplex1D___repr__(self)
4706 def __cmp__(self, arg2):
4707 r"""__cmp__(UnitSimplex1D self, UnitSimplex1D arg2) -> int"""
4708 return _IMP_algebra.UnitSimplex1D___cmp__(self, arg2)
4710 def __eq__(self, arg2):
4711 r"""__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
4712 return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)
4714 def _get_as_binary(self):
4715 r"""_get_as_binary(UnitSimplex1D self) -> PyObject *"""
4716 return _IMP_algebra.UnitSimplex1D__get_as_binary(self)
4718 def _set_from_binary(self, p):
4719 r"""_set_from_binary(UnitSimplex1D self, PyObject * p)"""
4720 return _IMP_algebra.UnitSimplex1D__set_from_binary(self, p)
4722 def __getstate__(self):
4723 p = self._get_as_binary()
4724 if len(self.__dict__) > 1:
4725 d = self.__dict__.copy()
4730 def __setstate__(self, p):
4731 if not hasattr(self,
'this'):
4733 if isinstance(p, tuple):
4735 self.__dict__.update(d)
4736 return self._set_from_binary(p)
4738 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D
4741 _IMP_algebra.UnitSimplex1D_swigregister(UnitSimplex1D)
4742 class UnitSimplex2D(_UnitSimplexBase2D):
4743 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 2 > class."""
4745 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4748 r"""__init__(UnitSimplex2D self) -> UnitSimplex2D"""
4749 _IMP_algebra.UnitSimplex2D_swiginit(self, _IMP_algebra.new_UnitSimplex2D())
4751 def show(self, *args):
4752 r"""show(UnitSimplex2D self, _ostream out=std::cout)"""
4753 return _IMP_algebra.UnitSimplex2D_show(self, *args)
4756 r"""__str__(UnitSimplex2D self) -> std::string"""
4757 return _IMP_algebra.UnitSimplex2D___str__(self)
4760 r"""__repr__(UnitSimplex2D self) -> std::string"""
4761 return _IMP_algebra.UnitSimplex2D___repr__(self)
4763 def __cmp__(self, arg2):
4764 r"""__cmp__(UnitSimplex2D self, UnitSimplex2D arg2) -> int"""
4765 return _IMP_algebra.UnitSimplex2D___cmp__(self, arg2)
4767 def __eq__(self, arg2):
4768 r"""__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
4769 return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)
4771 def _get_as_binary(self):
4772 r"""_get_as_binary(UnitSimplex2D self) -> PyObject *"""
4773 return _IMP_algebra.UnitSimplex2D__get_as_binary(self)
4775 def _set_from_binary(self, p):
4776 r"""_set_from_binary(UnitSimplex2D self, PyObject * p)"""
4777 return _IMP_algebra.UnitSimplex2D__set_from_binary(self, p)
4779 def __getstate__(self):
4780 p = self._get_as_binary()
4781 if len(self.__dict__) > 1:
4782 d = self.__dict__.copy()
4787 def __setstate__(self, p):
4788 if not hasattr(self,
'this'):
4790 if isinstance(p, tuple):
4792 self.__dict__.update(d)
4793 return self._set_from_binary(p)
4795 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D
4798 _IMP_algebra.UnitSimplex2D_swigregister(UnitSimplex2D)
4799 class UnitSimplex3D(_UnitSimplexBase3D):
4800 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 3 > class."""
4802 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4805 r"""__init__(UnitSimplex3D self) -> UnitSimplex3D"""
4806 _IMP_algebra.UnitSimplex3D_swiginit(self, _IMP_algebra.new_UnitSimplex3D())
4808 def show(self, *args):
4809 r"""show(UnitSimplex3D self, _ostream out=std::cout)"""
4810 return _IMP_algebra.UnitSimplex3D_show(self, *args)
4813 r"""__str__(UnitSimplex3D self) -> std::string"""
4814 return _IMP_algebra.UnitSimplex3D___str__(self)
4817 r"""__repr__(UnitSimplex3D self) -> std::string"""
4818 return _IMP_algebra.UnitSimplex3D___repr__(self)
4820 def __cmp__(self, arg2):
4821 r"""__cmp__(UnitSimplex3D self, UnitSimplex3D arg2) -> int"""
4822 return _IMP_algebra.UnitSimplex3D___cmp__(self, arg2)
4824 def __eq__(self, arg2):
4825 r"""__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
4826 return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)
4828 def _get_as_binary(self):
4829 r"""_get_as_binary(UnitSimplex3D self) -> PyObject *"""
4830 return _IMP_algebra.UnitSimplex3D__get_as_binary(self)
4832 def _set_from_binary(self, p):
4833 r"""_set_from_binary(UnitSimplex3D self, PyObject * p)"""
4834 return _IMP_algebra.UnitSimplex3D__set_from_binary(self, p)
4836 def __getstate__(self):
4837 p = self._get_as_binary()
4838 if len(self.__dict__) > 1:
4839 d = self.__dict__.copy()
4844 def __setstate__(self, p):
4845 if not hasattr(self,
'this'):
4847 if isinstance(p, tuple):
4849 self.__dict__.update(d)
4850 return self._set_from_binary(p)
4852 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D
4855 _IMP_algebra.UnitSimplex3D_swigregister(UnitSimplex3D)
4856 class UnitSimplex4D(_UnitSimplexBase4D):
4857 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 4 > class."""
4859 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4862 r"""__init__(UnitSimplex4D self) -> UnitSimplex4D"""
4863 _IMP_algebra.UnitSimplex4D_swiginit(self, _IMP_algebra.new_UnitSimplex4D())
4865 def show(self, *args):
4866 r"""show(UnitSimplex4D self, _ostream out=std::cout)"""
4867 return _IMP_algebra.UnitSimplex4D_show(self, *args)
4870 r"""__str__(UnitSimplex4D self) -> std::string"""
4871 return _IMP_algebra.UnitSimplex4D___str__(self)
4874 r"""__repr__(UnitSimplex4D self) -> std::string"""
4875 return _IMP_algebra.UnitSimplex4D___repr__(self)
4877 def __cmp__(self, arg2):
4878 r"""__cmp__(UnitSimplex4D self, UnitSimplex4D arg2) -> int"""
4879 return _IMP_algebra.UnitSimplex4D___cmp__(self, arg2)
4881 def __eq__(self, arg2):
4882 r"""__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
4883 return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)
4885 def _get_as_binary(self):
4886 r"""_get_as_binary(UnitSimplex4D self) -> PyObject *"""
4887 return _IMP_algebra.UnitSimplex4D__get_as_binary(self)
4889 def _set_from_binary(self, p):
4890 r"""_set_from_binary(UnitSimplex4D self, PyObject * p)"""
4891 return _IMP_algebra.UnitSimplex4D__set_from_binary(self, p)
4893 def __getstate__(self):
4894 p = self._get_as_binary()
4895 if len(self.__dict__) > 1:
4896 d = self.__dict__.copy()
4901 def __setstate__(self, p):
4902 if not hasattr(self,
'this'):
4904 if isinstance(p, tuple):
4906 self.__dict__.update(d)
4907 return self._set_from_binary(p)
4909 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D
4912 _IMP_algebra.UnitSimplex4D_swigregister(UnitSimplex4D)
4913 class UnitSimplex5D(_UnitSimplexBase5D):
4914 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 5 > class."""
4916 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4919 r"""__init__(UnitSimplex5D self) -> UnitSimplex5D"""
4920 _IMP_algebra.UnitSimplex5D_swiginit(self, _IMP_algebra.new_UnitSimplex5D())
4922 def show(self, *args):
4923 r"""show(UnitSimplex5D self, _ostream out=std::cout)"""
4924 return _IMP_algebra.UnitSimplex5D_show(self, *args)
4927 r"""__str__(UnitSimplex5D self) -> std::string"""
4928 return _IMP_algebra.UnitSimplex5D___str__(self)
4931 r"""__repr__(UnitSimplex5D self) -> std::string"""
4932 return _IMP_algebra.UnitSimplex5D___repr__(self)
4934 def __cmp__(self, arg2):
4935 r"""__cmp__(UnitSimplex5D self, UnitSimplex5D arg2) -> int"""
4936 return _IMP_algebra.UnitSimplex5D___cmp__(self, arg2)
4938 def __eq__(self, arg2):
4939 r"""__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
4940 return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)
4942 def _get_as_binary(self):
4943 r"""_get_as_binary(UnitSimplex5D self) -> PyObject *"""
4944 return _IMP_algebra.UnitSimplex5D__get_as_binary(self)
4946 def _set_from_binary(self, p):
4947 r"""_set_from_binary(UnitSimplex5D self, PyObject * p)"""
4948 return _IMP_algebra.UnitSimplex5D__set_from_binary(self, p)
4950 def __getstate__(self):
4951 p = self._get_as_binary()
4952 if len(self.__dict__) > 1:
4953 d = self.__dict__.copy()
4958 def __setstate__(self, p):
4959 if not hasattr(self,
'this'):
4961 if isinstance(p, tuple):
4963 self.__dict__.update(d)
4964 return self._set_from_binary(p)
4966 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D
4969 _IMP_algebra.UnitSimplex5D_swigregister(UnitSimplex5D)
4970 class UnitSimplex6D(_UnitSimplexBase6D):
4971 r"""Proxy of C++ IMP::algebra::UnitSimplexD< 6 > class."""
4973 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
4976 r"""__init__(UnitSimplex6D self) -> UnitSimplex6D"""
4977 _IMP_algebra.UnitSimplex6D_swiginit(self, _IMP_algebra.new_UnitSimplex6D())
4979 def show(self, *args):
4980 r"""show(UnitSimplex6D self, _ostream out=std::cout)"""
4981 return _IMP_algebra.UnitSimplex6D_show(self, *args)
4984 r"""__str__(UnitSimplex6D self) -> std::string"""
4985 return _IMP_algebra.UnitSimplex6D___str__(self)
4988 r"""__repr__(UnitSimplex6D self) -> std::string"""
4989 return _IMP_algebra.UnitSimplex6D___repr__(self)
4991 def __cmp__(self, arg2):
4992 r"""__cmp__(UnitSimplex6D self, UnitSimplex6D arg2) -> int"""
4993 return _IMP_algebra.UnitSimplex6D___cmp__(self, arg2)
4995 def __eq__(self, arg2):
4996 r"""__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
4997 return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)
4999 def _get_as_binary(self):
5000 r"""_get_as_binary(UnitSimplex6D self) -> PyObject *"""
5001 return _IMP_algebra.UnitSimplex6D__get_as_binary(self)
5003 def _set_from_binary(self, p):
5004 r"""_set_from_binary(UnitSimplex6D self, PyObject * p)"""
5005 return _IMP_algebra.UnitSimplex6D__set_from_binary(self, p)
5007 def __getstate__(self):
5008 p = self._get_as_binary()
5009 if len(self.__dict__) > 1:
5010 d = self.__dict__.copy()
5015 def __setstate__(self, p):
5016 if not hasattr(self,
'this'):
5018 if isinstance(p, tuple):
5020 self.__dict__.update(d)
5021 return self._set_from_binary(p)
5023 __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D
5026 _IMP_algebra.UnitSimplex6D_swigregister(UnitSimplex6D)
5027 class UnitSimplexKD(_UnitSimplexBaseKD):
5028 r"""Proxy of C++ IMP::algebra::UnitSimplexD< -1 > class."""
5030 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5031 __repr__ = _swig_repr
5033 def __init__(self, d=1):
5034 r"""__init__(UnitSimplexKD self, int d=1) -> UnitSimplexKD"""
5035 _IMP_algebra.UnitSimplexKD_swiginit(self, _IMP_algebra.new_UnitSimplexKD(d))
5037 def show(self, *args):
5038 r"""show(UnitSimplexKD self, _ostream out=std::cout)"""
5039 return _IMP_algebra.UnitSimplexKD_show(self, *args)
5041 def _get_as_binary(self):
5042 r"""_get_as_binary(UnitSimplexKD self) -> PyObject *"""
5043 return _IMP_algebra.UnitSimplexKD__get_as_binary(self)
5045 def _set_from_binary(self, p):
5046 r"""_set_from_binary(UnitSimplexKD self, PyObject * p)"""
5047 return _IMP_algebra.UnitSimplexKD__set_from_binary(self, p)
5049 def __getstate__(self):
5050 p = self._get_as_binary()
5051 if len(self.__dict__) > 1:
5052 d = self.__dict__.copy()
5057 def __setstate__(self, p):
5058 if not hasattr(self,
'this'):
5060 if isinstance(p, tuple):
5062 self.__dict__.update(d)
5063 return self._set_from_binary(p)
5065 __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD
5068 _IMP_algebra.UnitSimplexKD_swigregister(UnitSimplexKD)
5069 class ReferenceFrame3D(object):
5070 r"""Proxy of C++ IMP::algebra::ReferenceFrame3D class."""
5072 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5074 def __init__(self, *args):
5076 __init__(ReferenceFrame3D self, ReferenceFrame3D arg2) -> ReferenceFrame3D
5077 __init__(ReferenceFrame3D self) -> ReferenceFrame3D
5078 __init__(ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
5080 _IMP_algebra.ReferenceFrame3D_swiginit(self, _IMP_algebra.new_ReferenceFrame3D(*args))
5081 __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
5083 def get_transformation_to(self):
5084 r"""get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
5085 return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)
5087 def get_transformation_from(self):
5088 r"""get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
5089 return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)
5091 def get_global_coordinates(self, v):
5092 r"""get_global_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5093 return _IMP_algebra.ReferenceFrame3D_get_global_coordinates(self, v)
5095 def get_local_coordinates(self, v):
5096 r"""get_local_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5097 return _IMP_algebra.ReferenceFrame3D_get_local_coordinates(self, v)
5099 def get_global_reference_frame(self, v):
5100 r"""get_global_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5101 return _IMP_algebra.ReferenceFrame3D_get_global_reference_frame(self, v)
5103 def get_local_reference_frame(self, v):
5104 r"""get_local_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5105 return _IMP_algebra.ReferenceFrame3D_get_local_reference_frame(self, v)
5107 def show(self, *args):
5108 r"""show(ReferenceFrame3D self, _ostream out=std::cout)"""
5109 return _IMP_algebra.ReferenceFrame3D_show(self, *args)
5112 r"""__str__(ReferenceFrame3D self) -> std::string"""
5113 return _IMP_algebra.ReferenceFrame3D___str__(self)
5116 r"""__repr__(ReferenceFrame3D self) -> std::string"""
5117 return _IMP_algebra.ReferenceFrame3D___repr__(self)
5119 def _get_as_binary(self):
5120 r"""_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
5121 return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)
5123 def _set_from_binary(self, p):
5124 r"""_set_from_binary(ReferenceFrame3D self, PyObject * p)"""
5125 return _IMP_algebra.ReferenceFrame3D__set_from_binary(self, p)
5127 def __getstate__(self):
5128 p = self._get_as_binary()
5129 if len(self.__dict__) > 1:
5130 d = self.__dict__.copy()
5135 def __setstate__(self, p):
5136 if not hasattr(self,
'this'):
5138 if isinstance(p, tuple):
5140 self.__dict__.update(d)
5141 return self._set_from_binary(p)
5145 _IMP_algebra.ReferenceFrame3D_swigregister(ReferenceFrame3D)
5147 def get_transformed(*args):
5149 get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
5150 get_transformed(Line3D l, Transformation3D tr) -> Line3D
5151 get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
5153 return _IMP_algebra.get_transformed(*args)
5155 def get_transformation_from_first_to_second(a, b):
5156 r"""get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
5157 return _IMP_algebra.get_transformation_from_first_to_second(a, b)
5158 class SphericalVector3D(_GeometricPrimitive3D):
5159 r"""Proxy of C++ IMP::algebra::SphericalVector3D class."""
5161 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5163 def __init__(self, *args):
5165 __init__(SphericalVector3D self) -> SphericalVector3D
5166 __init__(SphericalVector3D self, Vector3D v) -> SphericalVector3D
5167 __init__(SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
5169 _IMP_algebra.SphericalVector3D_swiginit(self, _IMP_algebra.new_SphericalVector3D(*args))
5171 def get_cartesian_coordinates(self):
5172 r"""get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
5173 return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)
5175 def show(self, *args):
5176 r"""show(SphericalVector3D self, _ostream out=std::cout)"""
5177 return _IMP_algebra.SphericalVector3D_show(self, *args)
5180 r"""__str__(SphericalVector3D self) -> std::string"""
5181 return _IMP_algebra.SphericalVector3D___str__(self)
5184 r"""__repr__(SphericalVector3D self) -> std::string"""
5185 return _IMP_algebra.SphericalVector3D___repr__(self)
5187 def _get_as_binary(self):
5188 r"""_get_as_binary(SphericalVector3D self) -> PyObject *"""
5189 return _IMP_algebra.SphericalVector3D__get_as_binary(self)
5191 def _set_from_binary(self, p):
5192 r"""_set_from_binary(SphericalVector3D self, PyObject * p)"""
5193 return _IMP_algebra.SphericalVector3D__set_from_binary(self, p)
5195 def __getstate__(self):
5196 p = self._get_as_binary()
5197 if len(self.__dict__) > 1:
5198 d = self.__dict__.copy()
5203 def __setstate__(self, p):
5204 if not hasattr(self,
'this'):
5206 if isinstance(p, tuple):
5208 self.__dict__.update(d)
5209 return self._set_from_binary(p)
5212 def __getitem__(self, index):
5213 r"""__getitem__(SphericalVector3D self, unsigned int index) -> double"""
5214 return _IMP_algebra.SphericalVector3D___getitem__(self, index)
5216 def __setitem__(self, index, val):
5217 r"""__setitem__(SphericalVector3D self, unsigned int index, double val)"""
5218 return _IMP_algebra.SphericalVector3D___setitem__(self, index, val)
5219 __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D
5222 _IMP_algebra.SphericalVector3D_swigregister(SphericalVector3D)
5225 r"""get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
5226 return _IMP_algebra.get_alignments_from_first_to_second(pca1, pca2)
5227 class Line3D(_GeometricPrimitive3D):
5228 r"""Proxy of C++ IMP::algebra::Line3D class."""
5230 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5232 def __init__(self, *args):
5234 __init__(Line3D self) -> Line3D
5235 __init__(Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
5236 __init__(Line3D self, Segment3D s) -> Line3D
5238 _IMP_algebra.Line3D_swiginit(self, _IMP_algebra.new_Line3D(*args))
5240 def get_direction(self):
5241 r"""get_direction(Line3D self) -> Vector3D"""
5242 return _IMP_algebra.Line3D_get_direction(self)
5244 def get_point_on_line(self):
5245 r"""get_point_on_line(Line3D self) -> Vector3D"""
5246 return _IMP_algebra.Line3D_get_point_on_line(self)
5248 def get_moment(self, *args):
5250 get_moment(Line3D self) -> Vector3D
5251 get_moment(Line3D self, Vector3D v) -> Vector3D
5253 return _IMP_algebra.Line3D_get_moment(self, *args)
5255 def get_reciprocal_product(self, l):
5256 r"""get_reciprocal_product(Line3D self, Line3D l) -> double"""
5257 return _IMP_algebra.Line3D_get_reciprocal_product(self, l)
5259 def get_opposite(self):
5260 r"""get_opposite(Line3D self) -> Line3D"""
5261 return _IMP_algebra.Line3D_get_opposite(self)
5263 def get_segment_starting_at(self, v, d):
5264 r"""get_segment_starting_at(Line3D self, Vector3D v, double d) -> Segment3D"""
5265 return _IMP_algebra.Line3D_get_segment_starting_at(self, v, d)
5267 def show(self, *args):
5268 r"""show(Line3D self, _ostream out=std::cout)"""
5269 return _IMP_algebra.Line3D_show(self, *args)
5272 r"""__str__(Line3D self) -> std::string"""
5273 return _IMP_algebra.Line3D___str__(self)
5276 r"""__repr__(Line3D self) -> std::string"""
5277 return _IMP_algebra.Line3D___repr__(self)
5279 def _get_as_binary(self):
5280 r"""_get_as_binary(Line3D self) -> PyObject *"""
5281 return _IMP_algebra.Line3D__get_as_binary(self)
5283 def _set_from_binary(self, p):
5284 r"""_set_from_binary(Line3D self, PyObject * p)"""
5285 return _IMP_algebra.Line3D__set_from_binary(self, p)
5287 def __getstate__(self):
5288 p = self._get_as_binary()
5289 if len(self.__dict__) > 1:
5290 d = self.__dict__.copy()
5295 def __setstate__(self, p):
5296 if not hasattr(self,
'this'):
5298 if isinstance(p, tuple):
5300 self.__dict__.update(d)
5301 return self._set_from_binary(p)
5303 __swig_destroy__ = _IMP_algebra.delete_Line3D
5306 _IMP_algebra.Line3D_swigregister(Line3D)
5308 def get_line_3d_geometry(g):
5309 r"""get_line_3d_geometry(Line3D g) -> Line3D"""
5310 return _IMP_algebra.get_line_3d_geometry(g)
5313 r"""get_angle(Line3D a, Line3D b) -> double"""
5314 return _IMP_algebra.get_angle(a, b)
5317 r"""get_segment_connecting_first_to_second(Line3D a, Line3D b) -> Segment3D"""
5318 return _IMP_algebra.get_segment_connecting_first_to_second(a, b)
5319 class Segment3D(_GeometricPrimitive3D):
5320 r"""Proxy of C++ IMP::algebra::Segment3D class."""
5322 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5324 def __init__(self, *args):
5326 __init__(Segment3D self) -> Segment3D
5327 __init__(Segment3D self, Vector3D start, Vector3D end) -> Segment3D
5329 _IMP_algebra.Segment3D_swiginit(self, _IMP_algebra.new_Segment3D(*args))
5331 def get_point(self, i):
5334 return _IMP_algebra.Segment3D_get_point(self, i)
5338 def get_middle_point(self):
5339 r"""get_middle_point(Segment3D self) -> Vector3D"""
5340 return _IMP_algebra.Segment3D_get_middle_point(self)
5342 def get_direction(self):
5343 r"""get_direction(Segment3D self) -> Vector3D"""
5344 return _IMP_algebra.Segment3D_get_direction(self)
5346 def get_length(self):
5347 r"""get_length(Segment3D self) -> double"""
5348 return _IMP_algebra.Segment3D_get_length(self)
5350 def show(self, *args):
5351 r"""show(Segment3D self, _ostream out=std::cout)"""
5352 return _IMP_algebra.Segment3D_show(self, *args)
5355 r"""__str__(Segment3D self) -> std::string"""
5356 return _IMP_algebra.Segment3D___str__(self)
5359 r"""__repr__(Segment3D self) -> std::string"""
5360 return _IMP_algebra.Segment3D___repr__(self)
5362 def _get_as_binary(self):
5363 r"""_get_as_binary(Segment3D self) -> PyObject *"""
5364 return _IMP_algebra.Segment3D__get_as_binary(self)
5366 def _set_from_binary(self, p):
5367 r"""_set_from_binary(Segment3D self, PyObject * p)"""
5368 return _IMP_algebra.Segment3D__set_from_binary(self, p)
5370 def __getstate__(self):
5371 p = self._get_as_binary()
5372 if len(self.__dict__) > 1:
5373 d = self.__dict__.copy()
5378 def __setstate__(self, p):
5379 if not hasattr(self,
'this'):
5381 if isinstance(p, tuple):
5383 self.__dict__.update(d)
5384 return self._set_from_binary(p)
5386 __swig_destroy__ = _IMP_algebra.delete_Segment3D
5389 _IMP_algebra.Segment3D_swigregister(Segment3D)
5391 def get_segment_3d_geometry(g):
5392 r"""get_segment_3d_geometry(Segment3D g) -> Segment3D"""
5393 return _IMP_algebra.get_segment_3d_geometry(g)
5396 r"""get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
5397 return _IMP_algebra.get_relative_projection_on_segment(s, p)
5398 class Triangle3D(_GeometricPrimitive3D):
5399 r"""Proxy of C++ IMP::algebra::Triangle3D class."""
5401 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5403 def __init__(self, *args):
5405 __init__(Triangle3D self) -> Triangle3D
5406 __init__(Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
5408 _IMP_algebra.Triangle3D_swiginit(self, _IMP_algebra.new_Triangle3D(*args))
5410 def get_point(self, i):
5411 r"""get_point(Triangle3D self, unsigned int i) -> Vector3D"""
5412 return _IMP_algebra.Triangle3D_get_point(self, i)
5414 def show(self, *args):
5415 r"""show(Triangle3D self, _ostream out=std::cout)"""
5416 return _IMP_algebra.Triangle3D_show(self, *args)
5418 def get_edge_lengths(self):
5419 r"""get_edge_lengths(Triangle3D self) -> IMP::Floats"""
5420 return _IMP_algebra.Triangle3D_get_edge_lengths(self)
5423 r"""__str__(Triangle3D self) -> std::string"""
5424 return _IMP_algebra.Triangle3D___str__(self)
5427 r"""__repr__(Triangle3D self) -> std::string"""
5428 return _IMP_algebra.Triangle3D___repr__(self)
5430 def _get_as_binary(self):
5431 r"""_get_as_binary(Triangle3D self) -> PyObject *"""
5432 return _IMP_algebra.Triangle3D__get_as_binary(self)
5434 def _set_from_binary(self, p):
5435 r"""_set_from_binary(Triangle3D self, PyObject * p)"""
5436 return _IMP_algebra.Triangle3D__set_from_binary(self, p)
5438 def __getstate__(self):
5439 p = self._get_as_binary()
5440 if len(self.__dict__) > 1:
5441 d = self.__dict__.copy()
5446 def __setstate__(self, p):
5447 if not hasattr(self,
'this'):
5449 if isinstance(p, tuple):
5451 self.__dict__.update(d)
5452 return self._set_from_binary(p)
5454 __swig_destroy__ = _IMP_algebra.delete_Triangle3D
5457 _IMP_algebra.Triangle3D_swigregister(Triangle3D)
5460 r"""get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
5461 return _IMP_algebra.get_largest_triangle(points)
5464 r"""get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri) -> Transformation3D"""
5465 return _IMP_algebra.get_transformation_from_first_triangle_to_second(first_tri, second_tri)
5468 r"""get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
5469 return _IMP_algebra.get_are_colinear(p1, p2, p3)
5470 class LinearFit2D(_GeometricPrimitive2D):
5471 r"""Proxy of C++ IMP::algebra::LinearFit2D class."""
5473 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5475 def __init__(self, *args):
5477 __init__(LinearFit2D self) -> LinearFit2D
5478 __init__(LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
5480 _IMP_algebra.LinearFit2D_swiginit(self, _IMP_algebra.new_LinearFit2D(*args))
5482 def get_fit_error(self):
5483 r"""get_fit_error(LinearFit2D self) -> double"""
5484 return _IMP_algebra.LinearFit2D_get_fit_error(self)
5487 r"""get_a(LinearFit2D self) -> double"""
5488 return _IMP_algebra.LinearFit2D_get_a(self)
5491 r"""get_b(LinearFit2D self) -> double"""
5492 return _IMP_algebra.LinearFit2D_get_b(self)
5494 def show(self, *args):
5495 r"""show(LinearFit2D self, _ostream out=std::cout)"""
5496 return _IMP_algebra.LinearFit2D_show(self, *args)
5499 r"""__str__(LinearFit2D self) -> std::string"""
5500 return _IMP_algebra.LinearFit2D___str__(self)
5503 r"""__repr__(LinearFit2D self) -> std::string"""
5504 return _IMP_algebra.LinearFit2D___repr__(self)
5506 def _get_as_binary(self):
5507 r"""_get_as_binary(LinearFit2D self) -> PyObject *"""
5508 return _IMP_algebra.LinearFit2D__get_as_binary(self)
5510 def _set_from_binary(self, p):
5511 r"""_set_from_binary(LinearFit2D self, PyObject * p)"""
5512 return _IMP_algebra.LinearFit2D__set_from_binary(self, p)
5514 def __getstate__(self):
5515 p = self._get_as_binary()
5516 if len(self.__dict__) > 1:
5517 d = self.__dict__.copy()
5522 def __setstate__(self, p):
5523 if not hasattr(self,
'this'):
5525 if isinstance(p, tuple):
5527 self.__dict__.update(d)
5528 return self._set_from_binary(p)
5530 __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
5533 _IMP_algebra.LinearFit2D_swigregister(LinearFit2D)
5534 class ParabolicFit2D(_GeometricPrimitive2D):
5535 r"""Proxy of C++ IMP::algebra::ParabolicFit2D class."""
5537 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5539 def __init__(self, *args):
5541 __init__(ParabolicFit2D self) -> ParabolicFit2D
5542 __init__(ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
5544 _IMP_algebra.ParabolicFit2D_swiginit(self, _IMP_algebra.new_ParabolicFit2D(*args))
5546 def get_fit_error(self):
5547 r"""get_fit_error(ParabolicFit2D self) -> double"""
5548 return _IMP_algebra.ParabolicFit2D_get_fit_error(self)
5551 r"""get_a(ParabolicFit2D self) -> double"""
5552 return _IMP_algebra.ParabolicFit2D_get_a(self)
5555 r"""get_b(ParabolicFit2D self) -> double"""
5556 return _IMP_algebra.ParabolicFit2D_get_b(self)
5559 r"""get_c(ParabolicFit2D self) -> double"""
5560 return _IMP_algebra.ParabolicFit2D_get_c(self)
5562 def show(self, *args):
5563 r"""show(ParabolicFit2D self, _ostream out=std::cout)"""
5564 return _IMP_algebra.ParabolicFit2D_show(self, *args)
5567 r"""__str__(ParabolicFit2D self) -> std::string"""
5568 return _IMP_algebra.ParabolicFit2D___str__(self)
5571 r"""__repr__(ParabolicFit2D self) -> std::string"""
5572 return _IMP_algebra.ParabolicFit2D___repr__(self)
5574 def _get_as_binary(self):
5575 r"""_get_as_binary(ParabolicFit2D self) -> PyObject *"""
5576 return _IMP_algebra.ParabolicFit2D__get_as_binary(self)
5578 def _set_from_binary(self, p):
5579 r"""_set_from_binary(ParabolicFit2D self, PyObject * p)"""
5580 return _IMP_algebra.ParabolicFit2D__set_from_binary(self, p)
5582 def __getstate__(self):
5583 p = self._get_as_binary()
5584 if len(self.__dict__) > 1:
5585 d = self.__dict__.copy()
5590 def __setstate__(self, p):
5591 if not hasattr(self,
'this'):
5593 if isinstance(p, tuple):
5595 self.__dict__.update(d)
5596 return self._set_from_binary(p)
5598 __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
5601 _IMP_algebra.ParabolicFit2D_swigregister(ParabolicFit2D)
5602 class Plane3D(_GeometricPrimitive3D):
5603 r"""Proxy of C++ IMP::algebra::Plane3D class."""
5605 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5607 def __init__(self, *args):
5609 __init__(Plane3D self) -> Plane3D
5610 __init__(Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
5611 __init__(Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
5613 _IMP_algebra.Plane3D_swiginit(self, _IMP_algebra.new_Plane3D(*args))
5615 def get_point_on_plane(self):
5616 r"""get_point_on_plane(Plane3D self) -> Vector3D"""
5617 return _IMP_algebra.Plane3D_get_point_on_plane(self)
5619 def get_normal(self):
5620 r"""get_normal(Plane3D self) -> Vector3D"""
5621 return _IMP_algebra.Plane3D_get_normal(self)
5624 r"""get_projected(Plane3D self, Vector3D p) -> Vector3D"""
5625 return _IMP_algebra.Plane3D_get_projected(self, p)
5627 def get_is_above(self, p):
5628 r"""get_is_above(Plane3D self, Vector3D p) -> bool"""
5629 return _IMP_algebra.Plane3D_get_is_above(self, p)
5631 def get_is_below(self, p):
5632 r"""get_is_below(Plane3D self, Vector3D p) -> bool"""
5633 return _IMP_algebra.Plane3D_get_is_below(self, p)
5636 r"""get_height(Plane3D self, Vector3D p) -> double"""
5637 return _IMP_algebra.Plane3D_get_height(self, p)
5639 def show(self, *args):
5640 r"""show(Plane3D self, _ostream out=std::cout)"""
5641 return _IMP_algebra.Plane3D_show(self, *args)
5643 def get_opposite(self):
5644 r"""get_opposite(Plane3D self) -> Plane3D"""
5645 return _IMP_algebra.Plane3D_get_opposite(self)
5647 def get_distance_from_origin(self):
5648 r"""get_distance_from_origin(Plane3D self) -> double"""
5649 return _IMP_algebra.Plane3D_get_distance_from_origin(self)
5652 r"""__str__(Plane3D self) -> std::string"""
5653 return _IMP_algebra.Plane3D___str__(self)
5656 r"""__repr__(Plane3D self) -> std::string"""
5657 return _IMP_algebra.Plane3D___repr__(self)
5659 def _get_as_binary(self):
5660 r"""_get_as_binary(Plane3D self) -> PyObject *"""
5661 return _IMP_algebra.Plane3D__get_as_binary(self)
5663 def _set_from_binary(self, p):
5664 r"""_set_from_binary(Plane3D self, PyObject * p)"""
5665 return _IMP_algebra.Plane3D__set_from_binary(self, p)
5667 def __getstate__(self):
5668 p = self._get_as_binary()
5669 if len(self.__dict__) > 1:
5670 d = self.__dict__.copy()
5675 def __setstate__(self, p):
5676 if not hasattr(self,
'this'):
5678 if isinstance(p, tuple):
5680 self.__dict__.update(d)
5681 return self._set_from_binary(p)
5683 __swig_destroy__ = _IMP_algebra.delete_Plane3D
5686 _IMP_algebra.Plane3D_swigregister(Plane3D)
5689 r"""get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
5690 return _IMP_algebra.get_reflected(pln, p)
5692 def get_plane_3d_geometry(g):
5693 r"""get_plane_3d_geometry(Plane3D g) -> Plane3D"""
5694 return _IMP_algebra.get_plane_3d_geometry(g)
5695 class Reflection3D(_GeometricPrimitive3D):
5696 r"""Proxy of C++ IMP::algebra::Reflection3D class."""
5698 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5700 def __init__(self, *args):
5702 __init__(Reflection3D self) -> Reflection3D
5703 __init__(Reflection3D self, Plane3D pl) -> Reflection3D
5705 _IMP_algebra.Reflection3D_swiginit(self, _IMP_algebra.new_Reflection3D(*args))
5708 r"""get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
5709 return _IMP_algebra.Reflection3D_get_reflected(self, v)
5711 def show(self, *args):
5712 r"""show(Reflection3D self, _ostream out=std::cout)"""
5713 return _IMP_algebra.Reflection3D_show(self, *args)
5716 r"""__str__(Reflection3D self) -> std::string"""
5717 return _IMP_algebra.Reflection3D___str__(self)
5720 r"""__repr__(Reflection3D self) -> std::string"""
5721 return _IMP_algebra.Reflection3D___repr__(self)
5723 def _get_as_binary(self):
5724 r"""_get_as_binary(Reflection3D self) -> PyObject *"""
5725 return _IMP_algebra.Reflection3D__get_as_binary(self)
5727 def _set_from_binary(self, p):
5728 r"""_set_from_binary(Reflection3D self, PyObject * p)"""
5729 return _IMP_algebra.Reflection3D__set_from_binary(self, p)
5731 def __getstate__(self):
5732 p = self._get_as_binary()
5733 if len(self.__dict__) > 1:
5734 d = self.__dict__.copy()
5739 def __setstate__(self, p):
5740 if not hasattr(self,
'this'):
5742 if isinstance(p, tuple):
5744 self.__dict__.update(d)
5745 return self._set_from_binary(p)
5747 __swig_destroy__ = _IMP_algebra.delete_Reflection3D
5750 _IMP_algebra.Reflection3D_swigregister(Reflection3D)
5751 class Cylinder3D(_GeometricPrimitive3D):
5752 r"""Proxy of C++ IMP::algebra::Cylinder3D class."""
5754 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5756 def __init__(self, *args):
5758 __init__(Cylinder3D self) -> Cylinder3D
5759 __init__(Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
5761 _IMP_algebra.Cylinder3D_swiginit(self, _IMP_algebra.new_Cylinder3D(*args))
5763 def get_radius(self):
5764 r"""get_radius(Cylinder3D self) -> double"""
5765 return _IMP_algebra.Cylinder3D_get_radius(self)
5768 r"""get_segment(Cylinder3D self) -> Segment3D"""
5769 return _IMP_algebra.Cylinder3D_get_segment(self)
5771 def get_surface_point_at(self, relative_height, angle):
5772 r"""get_surface_point_at(Cylinder3D self, double relative_height, double angle) -> Vector3D"""
5773 return _IMP_algebra.Cylinder3D_get_surface_point_at(self, relative_height, angle)
5775 def get_inner_point_at(self, relative_height, relative_radius, angle):
5776 r"""get_inner_point_at(Cylinder3D self, double relative_height, double relative_radius, double angle) -> Vector3D"""
5777 return _IMP_algebra.Cylinder3D_get_inner_point_at(self, relative_height, relative_radius, angle)
5779 def show(self, *args):
5780 r"""show(Cylinder3D self, _ostream out=std::cout)"""
5781 return _IMP_algebra.Cylinder3D_show(self, *args)
5784 r"""__str__(Cylinder3D self) -> std::string"""
5785 return _IMP_algebra.Cylinder3D___str__(self)
5788 r"""__repr__(Cylinder3D self) -> std::string"""
5789 return _IMP_algebra.Cylinder3D___repr__(self)
5791 def _get_as_binary(self):
5792 r"""_get_as_binary(Cylinder3D self) -> PyObject *"""
5793 return _IMP_algebra.Cylinder3D__get_as_binary(self)
5795 def _set_from_binary(self, p):
5796 r"""_set_from_binary(Cylinder3D self, PyObject * p)"""
5797 return _IMP_algebra.Cylinder3D__set_from_binary(self, p)
5799 def __getstate__(self):
5800 p = self._get_as_binary()
5801 if len(self.__dict__) > 1:
5802 d = self.__dict__.copy()
5807 def __setstate__(self, p):
5808 if not hasattr(self,
'this'):
5810 if isinstance(p, tuple):
5812 self.__dict__.update(d)
5813 return self._set_from_binary(p)
5815 __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
5818 _IMP_algebra.Cylinder3D_swigregister(Cylinder3D)
5820 def get_cylinder_3d_geometry(g):
5821 r"""get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
5822 return _IMP_algebra.get_cylinder_3d_geometry(g)
5823 class Ellipsoid3D(_GeometricPrimitive3D):
5824 r"""Proxy of C++ IMP::algebra::Ellipsoid3D class."""
5826 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5828 def __init__(self, *args):
5830 __init__(Ellipsoid3D self) -> Ellipsoid3D
5831 __init__(Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
5832 __init__(Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
5834 _IMP_algebra.Ellipsoid3D_swiginit(self, _IMP_algebra.new_Ellipsoid3D(*args))
5836 def get_radii(self):
5837 r"""get_radii(Ellipsoid3D self) -> Vector3D"""
5838 return _IMP_algebra.Ellipsoid3D_get_radii(self)
5840 def get_reference_frame(self):
5841 r"""get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
5842 return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)
5844 def show(self, *args):
5845 r"""show(Ellipsoid3D self, _ostream out=std::cout)"""
5846 return _IMP_algebra.Ellipsoid3D_show(self, *args)
5849 r"""__str__(Ellipsoid3D self) -> std::string"""
5850 return _IMP_algebra.Ellipsoid3D___str__(self)
5853 r"""__repr__(Ellipsoid3D self) -> std::string"""
5854 return _IMP_algebra.Ellipsoid3D___repr__(self)
5856 def _get_as_binary(self):
5857 r"""_get_as_binary(Ellipsoid3D self) -> PyObject *"""
5858 return _IMP_algebra.Ellipsoid3D__get_as_binary(self)
5860 def _set_from_binary(self, p):
5861 r"""_set_from_binary(Ellipsoid3D self, PyObject * p)"""
5862 return _IMP_algebra.Ellipsoid3D__set_from_binary(self, p)
5864 def __getstate__(self):
5865 p = self._get_as_binary()
5866 if len(self.__dict__) > 1:
5867 d = self.__dict__.copy()
5872 def __setstate__(self, p):
5873 if not hasattr(self,
'this'):
5875 if isinstance(p, tuple):
5877 self.__dict__.update(d)
5878 return self._set_from_binary(p)
5880 __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
5883 _IMP_algebra.Ellipsoid3D_swigregister(Ellipsoid3D)
5885 def get_ellipsoid_3d_geometry(g):
5886 r"""get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
5887 return _IMP_algebra.get_ellipsoid_3d_geometry(g)
5888 class ConnollySurfacePoint(object):
5889 r"""Proxy of C++ IMP::algebra::ConnollySurfacePoint class."""
5891 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5893 def __init__(self, *args):
5895 __init__(ConnollySurfacePoint self) -> ConnollySurfacePoint
5896 __init__(ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
5898 _IMP_algebra.ConnollySurfacePoint_swiginit(self, _IMP_algebra.new_ConnollySurfacePoint(*args))
5901 r"""get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
5902 return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)
5904 def get_surface_point(self):
5905 r"""get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
5906 return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)
5909 r"""get_area(ConnollySurfacePoint self) -> double"""
5910 return _IMP_algebra.ConnollySurfacePoint_get_area(self)
5912 def get_normal(self):
5913 r"""get_normal(ConnollySurfacePoint self) -> Vector3D"""
5914 return _IMP_algebra.ConnollySurfacePoint_get_normal(self)
5916 def show(self, *args):
5917 r"""show(ConnollySurfacePoint self, _ostream out=std::cout)"""
5918 return _IMP_algebra.ConnollySurfacePoint_show(self, *args)
5921 r"""__str__(ConnollySurfacePoint self) -> std::string"""
5922 return _IMP_algebra.ConnollySurfacePoint___str__(self)
5925 r"""__repr__(ConnollySurfacePoint self) -> std::string"""
5926 return _IMP_algebra.ConnollySurfacePoint___repr__(self)
5928 def _get_as_binary(self):
5929 r"""_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
5930 return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)
5932 def _set_from_binary(self, p):
5933 r"""_set_from_binary(ConnollySurfacePoint self, PyObject * p)"""
5934 return _IMP_algebra.ConnollySurfacePoint__set_from_binary(self, p)
5936 def __getstate__(self):
5937 p = self._get_as_binary()
5938 if len(self.__dict__) > 1:
5939 d = self.__dict__.copy()
5944 def __setstate__(self, p):
5945 if not hasattr(self,
'this'):
5947 if isinstance(p, tuple):
5949 self.__dict__.update(d)
5950 return self._set_from_binary(p)
5952 __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
5955 _IMP_algebra.ConnollySurfacePoint_swigregister(ConnollySurfacePoint)
5958 r"""get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
5959 return _IMP_algebra.get_connolly_surface(spheres, density, probe_radius)
5960 class LogEmbedding3D(object):
5961 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 3 > class."""
5963 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
5965 def __init__(self, *args):
5967 __init__(LogEmbedding3D self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
5968 __init__(LogEmbedding3D self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
5969 __init__(LogEmbedding3D self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
5970 __init__(LogEmbedding3D self) -> LogEmbedding3D
5972 _IMP_algebra.LogEmbedding3D_swiginit(self, _IMP_algebra.new_LogEmbedding3D(*args))
5974 def set_origin(self, o):
5975 r"""set_origin(LogEmbedding3D self, Vector3D o)"""
5976 return _IMP_algebra.LogEmbedding3D_set_origin(self, o)
5978 def get_origin(self):
5979 r"""get_origin(LogEmbedding3D self) -> Vector3D"""
5980 return _IMP_algebra.LogEmbedding3D_get_origin(self)
5982 def get_dimension(self):
5983 r"""get_dimension(LogEmbedding3D self) -> unsigned int"""
5984 return _IMP_algebra.LogEmbedding3D_get_dimension(self)
5986 def set_unit_cell(self, *args):
5988 set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
5989 set_unit_cell(LogEmbedding3D self, Vector3D o)
5991 return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)
5993 def get_unit_cell(self):
5994 r"""get_unit_cell(LogEmbedding3D self) -> Vector3D"""
5995 return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)
5997 def get_extended_index(self, o):
5998 r"""get_extended_index(LogEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
5999 return _IMP_algebra.LogEmbedding3D_get_extended_index(self, o)
6002 r"""get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
6003 return _IMP_algebra.LogEmbedding3D_get_index(self, o)
6005 def get_center(self, *args):
6007 get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
6008 get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
6010 return _IMP_algebra.LogEmbedding3D_get_center(self, *args)
6012 def get_bounding_box(self, *args):
6014 get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
6015 get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
6017 return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)
6019 def show(self, *args):
6020 r"""show(LogEmbedding3D self, _ostream out=std::cout)"""
6021 return _IMP_algebra.LogEmbedding3D_show(self, *args)
6024 r"""__str__(LogEmbedding3D self) -> std::string"""
6025 return _IMP_algebra.LogEmbedding3D___str__(self)
6028 r"""__repr__(LogEmbedding3D self) -> std::string"""
6029 return _IMP_algebra.LogEmbedding3D___repr__(self)
6031 def __cmp__(self, arg2):
6032 r"""__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
6033 return _IMP_algebra.LogEmbedding3D___cmp__(self, arg2)
6035 def __eq__(self, arg2):
6036 r"""__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
6037 return _IMP_algebra.LogEmbedding3D___eq__(self, arg2)
6039 def _get_as_binary(self):
6040 r"""_get_as_binary(LogEmbedding3D self) -> PyObject *"""
6041 return _IMP_algebra.LogEmbedding3D__get_as_binary(self)
6043 def _set_from_binary(self, p):
6044 r"""_set_from_binary(LogEmbedding3D self, PyObject * p)"""
6045 return _IMP_algebra.LogEmbedding3D__set_from_binary(self, p)
6047 def __getstate__(self):
6048 p = self._get_as_binary()
6049 if len(self.__dict__) > 1:
6050 d = self.__dict__.copy()
6055 def __setstate__(self, p):
6056 if not hasattr(self,
'this'):
6058 if isinstance(p, tuple):
6060 self.__dict__.update(d)
6061 return self._set_from_binary(p)
6063 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
6066 _IMP_algebra.LogEmbedding3D_swigregister(LogEmbedding3D)
6067 class LogEmbeddingKD(object):
6068 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< -1 > class."""
6070 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6072 def __init__(self, *args):
6074 __init__(LogEmbeddingKD self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
6075 __init__(LogEmbeddingKD self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
6076 __init__(LogEmbeddingKD self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
6077 __init__(LogEmbeddingKD self) -> LogEmbeddingKD
6079 _IMP_algebra.LogEmbeddingKD_swiginit(self, _IMP_algebra.new_LogEmbeddingKD(*args))
6081 def set_origin(self, o):
6082 r"""set_origin(LogEmbeddingKD self, VectorKD o)"""
6083 return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)
6085 def get_origin(self):
6086 r"""get_origin(LogEmbeddingKD self) -> VectorKD"""
6087 return _IMP_algebra.LogEmbeddingKD_get_origin(self)
6089 def get_dimension(self):
6090 r"""get_dimension(LogEmbeddingKD self) -> unsigned int"""
6091 return _IMP_algebra.LogEmbeddingKD_get_dimension(self)
6093 def set_unit_cell(self, *args):
6095 set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
6096 set_unit_cell(LogEmbeddingKD self, VectorKD o)
6098 return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)
6100 def get_unit_cell(self):
6101 r"""get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
6102 return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)
6104 def get_extended_index(self, o):
6105 r"""get_extended_index(LogEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
6106 return _IMP_algebra.LogEmbeddingKD_get_extended_index(self, o)
6109 r"""get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
6110 return _IMP_algebra.LogEmbeddingKD_get_index(self, o)
6112 def get_center(self, *args):
6114 get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
6115 get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
6117 return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)
6119 def get_bounding_box(self, *args):
6121 get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
6122 get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
6124 return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)
6126 def show(self, *args):
6127 r"""show(LogEmbeddingKD self, _ostream out=std::cout)"""
6128 return _IMP_algebra.LogEmbeddingKD_show(self, *args)
6131 r"""__str__(LogEmbeddingKD self) -> std::string"""
6132 return _IMP_algebra.LogEmbeddingKD___str__(self)
6135 r"""__repr__(LogEmbeddingKD self) -> std::string"""
6136 return _IMP_algebra.LogEmbeddingKD___repr__(self)
6138 def __cmp__(self, arg2):
6139 r"""__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
6140 return _IMP_algebra.LogEmbeddingKD___cmp__(self, arg2)
6142 def __eq__(self, arg2):
6143 r"""__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
6144 return _IMP_algebra.LogEmbeddingKD___eq__(self, arg2)
6146 def _get_as_binary(self):
6147 r"""_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
6148 return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)
6150 def _set_from_binary(self, p):
6151 r"""_set_from_binary(LogEmbeddingKD self, PyObject * p)"""
6152 return _IMP_algebra.LogEmbeddingKD__set_from_binary(self, p)
6154 def __getstate__(self):
6155 p = self._get_as_binary()
6156 if len(self.__dict__) > 1:
6157 d = self.__dict__.copy()
6162 def __setstate__(self, p):
6163 if not hasattr(self,
'this'):
6165 if isinstance(p, tuple):
6167 self.__dict__.update(d)
6168 return self._set_from_binary(p)
6170 __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
6173 _IMP_algebra.LogEmbeddingKD_swigregister(LogEmbeddingKD)
6174 class DenseFloatLogGridKD(object):
6175 r"""Proxy of C++ IMP::algebra::DenseFloatLogGridKD class."""
6177 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6179 def __init__(self, sz, le):
6180 r"""__init__(DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
6181 _IMP_algebra.DenseFloatLogGridKD_swiginit(self, _IMP_algebra.new_DenseFloatLogGridKD(sz, le))
6183 def add_voxel(self, i, q):
6184 r"""add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
6185 return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, i, q)
6187 def __getitem__(self, *args):
6189 __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
6190 __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
6192 return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)
6194 def __setitem__(self, *args):
6196 __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
6197 __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
6199 return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)
6201 def get_bounding_box(self, *args):
6203 get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6204 get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
6206 return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)
6210 get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
6211 get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
6213 return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)
6215 def get_all_indexes(self):
6216 r"""get_all_indexes(DenseFloatLogGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
6217 return _IMP_algebra.DenseFloatLogGridKD_get_all_indexes(self)
6219 def get_extended_indexes(self, *args):
6221 get_extended_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
6222 get_extended_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
6224 return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)
6226 def get_center(self, *args):
6228 get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6229 get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
6231 return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)
6233 def get_extended_index(self, v):
6234 r"""get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6235 return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, v)
6238 r"""get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6239 return _IMP_algebra.DenseFloatLogGridKD_get_index(self, v)
6241 def get_origin(self):
6242 r"""get_origin(DenseFloatLogGridKD self) -> VectorKD"""
6243 return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)
6245 def get_dimension(self):
6246 r"""get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
6247 return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)
6249 def get_unit_cell(self):
6250 r"""get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
6251 return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)
6253 def get_has_index(self, v):
6254 r"""get_has_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> bool"""
6255 return _IMP_algebra.DenseFloatLogGridKD_get_has_index(self, v)
6258 r"""__str__(DenseFloatLogGridKD self) -> std::string"""
6259 return _IMP_algebra.DenseFloatLogGridKD___str__(self)
6262 r"""__repr__(DenseFloatLogGridKD self) -> std::string"""
6263 return _IMP_algebra.DenseFloatLogGridKD___repr__(self)
6265 def show(self, *args):
6266 r"""show(DenseFloatLogGridKD self, _ostream out=std::cout)"""
6267 return _IMP_algebra.DenseFloatLogGridKD_show(self, *args)
6268 __swig_destroy__ = _IMP_algebra.delete_DenseFloatLogGridKD
6271 _IMP_algebra.DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
6272 class DenseIntLogGrid3D(object):
6273 r"""Proxy of C++ IMP::algebra::DenseIntLogGrid3D class."""
6275 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6277 def __init__(self, sz, le):
6278 r"""__init__(DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
6279 _IMP_algebra.DenseIntLogGrid3D_swiginit(self, _IMP_algebra.new_DenseIntLogGrid3D(sz, le))
6281 def add_voxel(self, i, q):
6282 r"""add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6283 return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, i, q)
6285 def __getitem__(self, *args):
6287 __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
6288 __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
6290 return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)
6292 def __setitem__(self, *args):
6294 __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
6295 __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
6297 return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)
6299 def get_bounding_box(self, *args):
6301 get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6302 get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
6304 return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)
6308 get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6309 get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6311 return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)
6313 def get_all_indexes(self):
6314 r"""get_all_indexes(DenseIntLogGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
6315 return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)
6317 def get_extended_indexes(self, *args):
6319 get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6320 get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6322 return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)
6324 def get_center(self, *args):
6326 get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6327 get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
6329 return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)
6331 def get_extended_index(self, v):
6332 r"""get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6333 return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, v)
6336 r"""get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6337 return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)
6339 def get_origin(self):
6340 r"""get_origin(DenseIntLogGrid3D self) -> Vector3D"""
6341 return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)
6343 def get_dimension(self):
6344 r"""get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
6345 return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)
6347 def get_unit_cell(self):
6348 r"""get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
6349 return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)
6351 def get_has_index(self, v):
6352 r"""get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
6353 return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, v)
6356 r"""__str__(DenseIntLogGrid3D self) -> std::string"""
6357 return _IMP_algebra.DenseIntLogGrid3D___str__(self)
6360 r"""__repr__(DenseIntLogGrid3D self) -> std::string"""
6361 return _IMP_algebra.DenseIntLogGrid3D___repr__(self)
6363 def show(self, *args):
6364 r"""show(DenseIntLogGrid3D self, _ostream out=std::cout)"""
6365 return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)
6366 __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D
6369 _IMP_algebra.DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
6371 r"""Proxy of C++ IMP::algebra::DenseGrid3D< double > class."""
6373 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6375 def __init__(self, *args):
6377 __init__(DenseDoubleGrid3D self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
6378 __init__(DenseDoubleGrid3D self) -> DenseDoubleGrid3D
6380 _IMP_algebra.DenseDoubleGrid3D_swiginit(self, _IMP_algebra.new_DenseDoubleGrid3D(*args))
6382 def add_voxel(self, i, q):
6383 r"""add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
6384 return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, i, q)
6386 def __getitem__(self, *args):
6388 __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
6389 __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
6391 return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)
6393 def __setitem__(self, *args):
6395 __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
6396 __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
6398 return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)
6400 def get_bounding_box(self, *args):
6402 get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6403 get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
6405 return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)
6409 get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6410 get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6412 return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)
6414 def get_all_indexes(self):
6415 r"""get_all_indexes(DenseDoubleGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
6416 return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)
6418 def get_extended_indexes(self, *args):
6420 get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6421 get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6423 return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)
6425 def get_center(self, *args):
6427 get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6428 get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
6430 return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)
6432 def get_extended_index(self, v):
6433 r"""get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6434 return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, v)
6437 r"""get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6438 return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)
6440 def get_origin(self):
6441 r"""get_origin(DenseDoubleGrid3D self) -> Vector3D"""
6442 return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)
6444 def get_dimension(self):
6445 r"""get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
6446 return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)
6448 def get_unit_cell(self):
6449 r"""get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
6450 return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)
6452 def get_has_index(self, v):
6453 r"""get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
6454 return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, v)
6457 r"""__str__(DenseDoubleGrid3D self) -> std::string"""
6458 return _IMP_algebra.DenseDoubleGrid3D___str__(self)
6461 r"""__repr__(DenseDoubleGrid3D self) -> std::string"""
6462 return _IMP_algebra.DenseDoubleGrid3D___repr__(self)
6464 def show(self, *args):
6465 r"""show(DenseDoubleGrid3D self, _ostream out=std::cout)"""
6466 return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)
6467 __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D
6470 _IMP_algebra.DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
6472 r"""Proxy of C++ IMP::algebra::DenseGrid3D< float > class."""
6474 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6476 def __init__(self, *args):
6478 __init__(DenseFloatGrid3D self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
6479 __init__(DenseFloatGrid3D self) -> DenseFloatGrid3D
6481 _IMP_algebra.DenseFloatGrid3D_swiginit(self, _IMP_algebra.new_DenseFloatGrid3D(*args))
6483 def add_voxel(self, i, q):
6484 r"""add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
6485 return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, i, q)
6487 def __getitem__(self, *args):
6489 __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
6490 __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
6492 return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)
6494 def __setitem__(self, *args):
6496 __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
6497 __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
6499 return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)
6501 def get_bounding_box(self, *args):
6503 get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6504 get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
6506 return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)
6510 get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6511 get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6513 return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)
6515 def get_all_indexes(self):
6516 r"""get_all_indexes(DenseFloatGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
6517 return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)
6519 def get_extended_indexes(self, *args):
6521 get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6522 get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6524 return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)
6526 def get_center(self, *args):
6528 get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6529 get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
6531 return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)
6533 def get_extended_index(self, v):
6534 r"""get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6535 return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, v)
6538 r"""get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6539 return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)
6541 def get_origin(self):
6542 r"""get_origin(DenseFloatGrid3D self) -> Vector3D"""
6543 return _IMP_algebra.DenseFloatGrid3D_get_origin(self)
6545 def get_dimension(self):
6546 r"""get_dimension(DenseFloatGrid3D self) -> unsigned int"""
6547 return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)
6549 def get_unit_cell(self):
6550 r"""get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
6551 return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)
6553 def get_has_index(self, v):
6554 r"""get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
6555 return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, v)
6558 r"""__str__(DenseFloatGrid3D self) -> std::string"""
6559 return _IMP_algebra.DenseFloatGrid3D___str__(self)
6562 r"""__repr__(DenseFloatGrid3D self) -> std::string"""
6563 return _IMP_algebra.DenseFloatGrid3D___repr__(self)
6565 def show(self, *args):
6566 r"""show(DenseFloatGrid3D self, _ostream out=std::cout)"""
6567 return _IMP_algebra.DenseFloatGrid3D_show(self, *args)
6568 __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D
6571 _IMP_algebra.DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
6573 r"""Proxy of C++ IMP::algebra::SparseUnboundedGrid3D< int > class."""
6575 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6577 def __init__(self, *args):
6579 __init__(SparseUnboundedIntGrid3D self, double side, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6580 __init__(SparseUnboundedIntGrid3D self, Vector3D sides, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6581 __init__(SparseUnboundedIntGrid3D self) -> SparseUnboundedIntGrid3D
6583 _IMP_algebra.SparseUnboundedIntGrid3D_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGrid3D(*args))
6585 def add_voxel(self, i, q):
6586 r"""add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6587 return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, i, q)
6589 def __getitem__(self, *args):
6591 __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
6592 __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
6594 return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)
6596 def __setitem__(self, *args):
6598 __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
6599 __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
6601 return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)
6603 def get_bounding_box(self, *args):
6605 get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6606 get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
6608 return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)
6612 get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6613 get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
6615 return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)
6617 def get_all_indexes(self):
6618 r"""get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
6619 return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)
6621 def get_extended_indexes(self, *args):
6623 get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6624 get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
6626 return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)
6628 def get_center(self, *args):
6630 get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6631 get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
6633 return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)
6635 def get_extended_index(self, v):
6636 r"""get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6637 return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, v)
6640 r"""get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6641 return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)
6643 def get_origin(self):
6644 r"""get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
6645 return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)
6647 def get_dimension(self):
6648 r"""get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
6649 return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)
6651 def get_unit_cell(self):
6652 r"""get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
6653 return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)
6655 def get_has_index(self, v):
6656 r"""get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
6657 return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, v)
6660 r"""__str__(SparseUnboundedIntGrid3D self) -> std::string"""
6661 return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)
6664 r"""__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
6665 return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)
6667 def show(self, *args):
6668 r"""show(SparseUnboundedIntGrid3D self, _ostream out=std::cout)"""
6669 return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)
6670 __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D
6673 _IMP_algebra.SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
6674 class SparseUnboundedIntGridKD(object):
6675 r"""Proxy of C++ IMP::algebra::SparseUnboundedGridD< -1,int > class."""
6677 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6679 def __init__(self, *args):
6681 __init__(SparseUnboundedIntGridKD self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
6682 __init__(SparseUnboundedIntGridKD self) -> SparseUnboundedIntGridKD
6684 _IMP_algebra.SparseUnboundedIntGridKD_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGridKD(*args))
6686 def add_voxel(self, i, q):
6687 r"""add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
6688 return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, i, q)
6690 def __getitem__(self, *args):
6692 __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
6693 __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
6695 return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)
6697 def __setitem__(self, *args):
6699 __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
6700 __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
6702 return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)
6704 def get_bounding_box(self, *args):
6706 get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6707 get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
6709 return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)
6713 get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
6714 get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
6716 return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)
6718 def get_all_indexes(self):
6719 r"""get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
6720 return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)
6722 def get_extended_indexes(self, *args):
6724 get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
6725 get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
6727 return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)
6729 def get_center(self, *args):
6731 get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6732 get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
6734 return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)
6736 def get_extended_index(self, v):
6737 r"""get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6738 return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, v)
6741 r"""get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6742 return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)
6744 def get_origin(self):
6745 r"""get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
6746 return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)
6748 def get_dimension(self):
6749 r"""get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
6750 return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)
6752 def get_unit_cell(self):
6753 r"""get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
6754 return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)
6756 def get_has_index(self, v):
6757 r"""get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
6758 return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, v)
6761 r"""__str__(SparseUnboundedIntGridKD self) -> std::string"""
6762 return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)
6765 r"""__repr__(SparseUnboundedIntGridKD self) -> std::string"""
6766 return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)
6768 def show(self, *args):
6769 r"""show(SparseUnboundedIntGridKD self, _ostream out=std::cout)"""
6770 return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)
6771 __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD
6774 _IMP_algebra.SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
6775 class GridIndex1D(IMP._Value):
6776 r"""Proxy of C++ IMP::algebra::GridIndexD< 1 > class."""
6778 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6780 def __init__(self, *args):
6782 __init__(GridIndex1D self) -> GridIndex1D
6783 __init__(GridIndex1D self, int x) -> GridIndex1D
6784 __init__(GridIndex1D self, int x, int y) -> GridIndex1D
6785 __init__(GridIndex1D self, int x, int y, int z) -> GridIndex1D
6786 __init__(GridIndex1D self, int i, int j, int k, int l) -> GridIndex1D
6787 __init__(GridIndex1D self, int i, int j, int k, int l, int m) -> GridIndex1D
6788 __init__(GridIndex1D self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
6790 _IMP_algebra.GridIndex1D_swiginit(self, _IMP_algebra.new_GridIndex1D(*args))
6792 def get_dimension(self):
6793 r"""get_dimension(GridIndex1D self) -> unsigned int"""
6794 return _IMP_algebra.GridIndex1D_get_dimension(self)
6796 def __getitem__(self, i):
6797 r"""__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
6798 return _IMP_algebra.GridIndex1D___getitem__(self, i)
6800 def show(self, *args):
6801 r"""show(GridIndex1D self, _ostream out=std::cout)"""
6802 return _IMP_algebra.GridIndex1D_show(self, *args)
6805 r"""__len__(GridIndex1D self) -> unsigned int"""
6806 return _IMP_algebra.GridIndex1D___len__(self)
6808 def __cmp__(self, o):
6809 r"""__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
6810 return _IMP_algebra.GridIndex1D___cmp__(self, o)
6812 def __eq__(self, o):
6813 r"""__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
6814 return _IMP_algebra.GridIndex1D___eq__(self, o)
6816 def __ne__(self, o):
6817 r"""__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
6818 return _IMP_algebra.GridIndex1D___ne__(self, o)
6820 def __lt__(self, o):
6821 r"""__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
6822 return _IMP_algebra.GridIndex1D___lt__(self, o)
6824 def __gt__(self, o):
6825 r"""__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
6826 return _IMP_algebra.GridIndex1D___gt__(self, o)
6828 def __ge__(self, o):
6829 r"""__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
6830 return _IMP_algebra.GridIndex1D___ge__(self, o)
6832 def __le__(self, o):
6833 r"""__le__(GridIndex1D self, GridIndex1D o) -> bool"""
6834 return _IMP_algebra.GridIndex1D___le__(self, o)
6837 r"""__hash__(GridIndex1D self) -> std::size_t"""
6838 return _IMP_algebra.GridIndex1D___hash__(self)
6841 r"""__str__(GridIndex1D self) -> std::string"""
6842 return _IMP_algebra.GridIndex1D___str__(self)
6845 r"""__repr__(GridIndex1D self) -> std::string"""
6846 return _IMP_algebra.GridIndex1D___repr__(self)
6848 def _get_as_binary(self):
6849 r"""_get_as_binary(GridIndex1D self) -> PyObject *"""
6850 return _IMP_algebra.GridIndex1D__get_as_binary(self)
6852 def _set_from_binary(self, p):
6853 r"""_set_from_binary(GridIndex1D self, PyObject * p)"""
6854 return _IMP_algebra.GridIndex1D__set_from_binary(self, p)
6856 def __getstate__(self):
6857 p = self._get_as_binary()
6858 if len(self.__dict__) > 1:
6859 d = self.__dict__.copy()
6864 def __setstate__(self, p):
6865 if not hasattr(self,
'this'):
6867 if isinstance(p, tuple):
6869 self.__dict__.update(d)
6870 return self._set_from_binary(p)
6872 __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
6875 _IMP_algebra.GridIndex1D_swigregister(GridIndex1D)
6876 class GridIndex2D(IMP._Value):
6877 r"""Proxy of C++ IMP::algebra::GridIndexD< 2 > class."""
6879 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6881 def __init__(self, *args):
6883 __init__(GridIndex2D self) -> GridIndex2D
6884 __init__(GridIndex2D self, int x) -> GridIndex2D
6885 __init__(GridIndex2D self, int x, int y) -> GridIndex2D
6886 __init__(GridIndex2D self, int x, int y, int z) -> GridIndex2D
6887 __init__(GridIndex2D self, int i, int j, int k, int l) -> GridIndex2D
6888 __init__(GridIndex2D self, int i, int j, int k, int l, int m) -> GridIndex2D
6889 __init__(GridIndex2D self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
6891 _IMP_algebra.GridIndex2D_swiginit(self, _IMP_algebra.new_GridIndex2D(*args))
6893 def get_dimension(self):
6894 r"""get_dimension(GridIndex2D self) -> unsigned int"""
6895 return _IMP_algebra.GridIndex2D_get_dimension(self)
6897 def __getitem__(self, i):
6898 r"""__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
6899 return _IMP_algebra.GridIndex2D___getitem__(self, i)
6901 def show(self, *args):
6902 r"""show(GridIndex2D self, _ostream out=std::cout)"""
6903 return _IMP_algebra.GridIndex2D_show(self, *args)
6906 r"""__len__(GridIndex2D self) -> unsigned int"""
6907 return _IMP_algebra.GridIndex2D___len__(self)
6909 def __cmp__(self, o):
6910 r"""__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
6911 return _IMP_algebra.GridIndex2D___cmp__(self, o)
6913 def __eq__(self, o):
6914 r"""__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
6915 return _IMP_algebra.GridIndex2D___eq__(self, o)
6917 def __ne__(self, o):
6918 r"""__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
6919 return _IMP_algebra.GridIndex2D___ne__(self, o)
6921 def __lt__(self, o):
6922 r"""__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
6923 return _IMP_algebra.GridIndex2D___lt__(self, o)
6925 def __gt__(self, o):
6926 r"""__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
6927 return _IMP_algebra.GridIndex2D___gt__(self, o)
6929 def __ge__(self, o):
6930 r"""__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
6931 return _IMP_algebra.GridIndex2D___ge__(self, o)
6933 def __le__(self, o):
6934 r"""__le__(GridIndex2D self, GridIndex2D o) -> bool"""
6935 return _IMP_algebra.GridIndex2D___le__(self, o)
6938 r"""__hash__(GridIndex2D self) -> std::size_t"""
6939 return _IMP_algebra.GridIndex2D___hash__(self)
6942 r"""__str__(GridIndex2D self) -> std::string"""
6943 return _IMP_algebra.GridIndex2D___str__(self)
6946 r"""__repr__(GridIndex2D self) -> std::string"""
6947 return _IMP_algebra.GridIndex2D___repr__(self)
6949 def _get_as_binary(self):
6950 r"""_get_as_binary(GridIndex2D self) -> PyObject *"""
6951 return _IMP_algebra.GridIndex2D__get_as_binary(self)
6953 def _set_from_binary(self, p):
6954 r"""_set_from_binary(GridIndex2D self, PyObject * p)"""
6955 return _IMP_algebra.GridIndex2D__set_from_binary(self, p)
6957 def __getstate__(self):
6958 p = self._get_as_binary()
6959 if len(self.__dict__) > 1:
6960 d = self.__dict__.copy()
6965 def __setstate__(self, p):
6966 if not hasattr(self,
'this'):
6968 if isinstance(p, tuple):
6970 self.__dict__.update(d)
6971 return self._set_from_binary(p)
6973 __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
6976 _IMP_algebra.GridIndex2D_swigregister(GridIndex2D)
6977 class GridIndex3D(IMP._Value):
6978 r"""Proxy of C++ IMP::algebra::GridIndexD< 3 > class."""
6980 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
6982 def __init__(self, *args):
6984 __init__(GridIndex3D self) -> GridIndex3D
6985 __init__(GridIndex3D self, int x) -> GridIndex3D
6986 __init__(GridIndex3D self, int x, int y) -> GridIndex3D
6987 __init__(GridIndex3D self, int x, int y, int z) -> GridIndex3D
6988 __init__(GridIndex3D self, int i, int j, int k, int l) -> GridIndex3D
6989 __init__(GridIndex3D self, int i, int j, int k, int l, int m) -> GridIndex3D
6990 __init__(GridIndex3D self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
6992 _IMP_algebra.GridIndex3D_swiginit(self, _IMP_algebra.new_GridIndex3D(*args))
6994 def get_dimension(self):
6995 r"""get_dimension(GridIndex3D self) -> unsigned int"""
6996 return _IMP_algebra.GridIndex3D_get_dimension(self)
6998 def __getitem__(self, i):
6999 r"""__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
7000 return _IMP_algebra.GridIndex3D___getitem__(self, i)
7002 def show(self, *args):
7003 r"""show(GridIndex3D self, _ostream out=std::cout)"""
7004 return _IMP_algebra.GridIndex3D_show(self, *args)
7007 r"""__len__(GridIndex3D self) -> unsigned int"""
7008 return _IMP_algebra.GridIndex3D___len__(self)
7010 def __cmp__(self, o):
7011 r"""__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
7012 return _IMP_algebra.GridIndex3D___cmp__(self, o)
7014 def __eq__(self, o):
7015 r"""__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
7016 return _IMP_algebra.GridIndex3D___eq__(self, o)
7018 def __ne__(self, o):
7019 r"""__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
7020 return _IMP_algebra.GridIndex3D___ne__(self, o)
7022 def __lt__(self, o):
7023 r"""__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
7024 return _IMP_algebra.GridIndex3D___lt__(self, o)
7026 def __gt__(self, o):
7027 r"""__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
7028 return _IMP_algebra.GridIndex3D___gt__(self, o)
7030 def __ge__(self, o):
7031 r"""__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
7032 return _IMP_algebra.GridIndex3D___ge__(self, o)
7034 def __le__(self, o):
7035 r"""__le__(GridIndex3D self, GridIndex3D o) -> bool"""
7036 return _IMP_algebra.GridIndex3D___le__(self, o)
7039 r"""__hash__(GridIndex3D self) -> std::size_t"""
7040 return _IMP_algebra.GridIndex3D___hash__(self)
7043 r"""__str__(GridIndex3D self) -> std::string"""
7044 return _IMP_algebra.GridIndex3D___str__(self)
7047 r"""__repr__(GridIndex3D self) -> std::string"""
7048 return _IMP_algebra.GridIndex3D___repr__(self)
7050 def _get_as_binary(self):
7051 r"""_get_as_binary(GridIndex3D self) -> PyObject *"""
7052 return _IMP_algebra.GridIndex3D__get_as_binary(self)
7054 def _set_from_binary(self, p):
7055 r"""_set_from_binary(GridIndex3D self, PyObject * p)"""
7056 return _IMP_algebra.GridIndex3D__set_from_binary(self, p)
7058 def __getstate__(self):
7059 p = self._get_as_binary()
7060 if len(self.__dict__) > 1:
7061 d = self.__dict__.copy()
7066 def __setstate__(self, p):
7067 if not hasattr(self,
'this'):
7069 if isinstance(p, tuple):
7071 self.__dict__.update(d)
7072 return self._set_from_binary(p)
7074 __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
7077 _IMP_algebra.GridIndex3D_swigregister(GridIndex3D)
7078 class GridIndex4D(IMP._Value):
7079 r"""Proxy of C++ IMP::algebra::GridIndexD< 4 > class."""
7081 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7083 def __init__(self, *args):
7085 __init__(GridIndex4D self) -> GridIndex4D
7086 __init__(GridIndex4D self, int x) -> GridIndex4D
7087 __init__(GridIndex4D self, int x, int y) -> GridIndex4D
7088 __init__(GridIndex4D self, int x, int y, int z) -> GridIndex4D
7089 __init__(GridIndex4D self, int i, int j, int k, int l) -> GridIndex4D
7090 __init__(GridIndex4D self, int i, int j, int k, int l, int m) -> GridIndex4D
7091 __init__(GridIndex4D self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
7093 _IMP_algebra.GridIndex4D_swiginit(self, _IMP_algebra.new_GridIndex4D(*args))
7095 def get_dimension(self):
7096 r"""get_dimension(GridIndex4D self) -> unsigned int"""
7097 return _IMP_algebra.GridIndex4D_get_dimension(self)
7099 def __getitem__(self, i):
7100 r"""__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
7101 return _IMP_algebra.GridIndex4D___getitem__(self, i)
7103 def show(self, *args):
7104 r"""show(GridIndex4D self, _ostream out=std::cout)"""
7105 return _IMP_algebra.GridIndex4D_show(self, *args)
7108 r"""__len__(GridIndex4D self) -> unsigned int"""
7109 return _IMP_algebra.GridIndex4D___len__(self)
7111 def __cmp__(self, o):
7112 r"""__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
7113 return _IMP_algebra.GridIndex4D___cmp__(self, o)
7115 def __eq__(self, o):
7116 r"""__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
7117 return _IMP_algebra.GridIndex4D___eq__(self, o)
7119 def __ne__(self, o):
7120 r"""__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
7121 return _IMP_algebra.GridIndex4D___ne__(self, o)
7123 def __lt__(self, o):
7124 r"""__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
7125 return _IMP_algebra.GridIndex4D___lt__(self, o)
7127 def __gt__(self, o):
7128 r"""__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
7129 return _IMP_algebra.GridIndex4D___gt__(self, o)
7131 def __ge__(self, o):
7132 r"""__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
7133 return _IMP_algebra.GridIndex4D___ge__(self, o)
7135 def __le__(self, o):
7136 r"""__le__(GridIndex4D self, GridIndex4D o) -> bool"""
7137 return _IMP_algebra.GridIndex4D___le__(self, o)
7140 r"""__hash__(GridIndex4D self) -> std::size_t"""
7141 return _IMP_algebra.GridIndex4D___hash__(self)
7144 r"""__str__(GridIndex4D self) -> std::string"""
7145 return _IMP_algebra.GridIndex4D___str__(self)
7148 r"""__repr__(GridIndex4D self) -> std::string"""
7149 return _IMP_algebra.GridIndex4D___repr__(self)
7151 def _get_as_binary(self):
7152 r"""_get_as_binary(GridIndex4D self) -> PyObject *"""
7153 return _IMP_algebra.GridIndex4D__get_as_binary(self)
7155 def _set_from_binary(self, p):
7156 r"""_set_from_binary(GridIndex4D self, PyObject * p)"""
7157 return _IMP_algebra.GridIndex4D__set_from_binary(self, p)
7159 def __getstate__(self):
7160 p = self._get_as_binary()
7161 if len(self.__dict__) > 1:
7162 d = self.__dict__.copy()
7167 def __setstate__(self, p):
7168 if not hasattr(self,
'this'):
7170 if isinstance(p, tuple):
7172 self.__dict__.update(d)
7173 return self._set_from_binary(p)
7175 __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
7178 _IMP_algebra.GridIndex4D_swigregister(GridIndex4D)
7179 class GridIndex5D(IMP._Value):
7180 r"""Proxy of C++ IMP::algebra::GridIndexD< 5 > class."""
7182 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7184 def __init__(self, *args):
7186 __init__(GridIndex5D self) -> GridIndex5D
7187 __init__(GridIndex5D self, int x) -> GridIndex5D
7188 __init__(GridIndex5D self, int x, int y) -> GridIndex5D
7189 __init__(GridIndex5D self, int x, int y, int z) -> GridIndex5D
7190 __init__(GridIndex5D self, int i, int j, int k, int l) -> GridIndex5D
7191 __init__(GridIndex5D self, int i, int j, int k, int l, int m) -> GridIndex5D
7192 __init__(GridIndex5D self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
7194 _IMP_algebra.GridIndex5D_swiginit(self, _IMP_algebra.new_GridIndex5D(*args))
7196 def get_dimension(self):
7197 r"""get_dimension(GridIndex5D self) -> unsigned int"""
7198 return _IMP_algebra.GridIndex5D_get_dimension(self)
7200 def __getitem__(self, i):
7201 r"""__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
7202 return _IMP_algebra.GridIndex5D___getitem__(self, i)
7204 def show(self, *args):
7205 r"""show(GridIndex5D self, _ostream out=std::cout)"""
7206 return _IMP_algebra.GridIndex5D_show(self, *args)
7209 r"""__len__(GridIndex5D self) -> unsigned int"""
7210 return _IMP_algebra.GridIndex5D___len__(self)
7212 def __cmp__(self, o):
7213 r"""__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
7214 return _IMP_algebra.GridIndex5D___cmp__(self, o)
7216 def __eq__(self, o):
7217 r"""__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
7218 return _IMP_algebra.GridIndex5D___eq__(self, o)
7220 def __ne__(self, o):
7221 r"""__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
7222 return _IMP_algebra.GridIndex5D___ne__(self, o)
7224 def __lt__(self, o):
7225 r"""__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
7226 return _IMP_algebra.GridIndex5D___lt__(self, o)
7228 def __gt__(self, o):
7229 r"""__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
7230 return _IMP_algebra.GridIndex5D___gt__(self, o)
7232 def __ge__(self, o):
7233 r"""__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
7234 return _IMP_algebra.GridIndex5D___ge__(self, o)
7236 def __le__(self, o):
7237 r"""__le__(GridIndex5D self, GridIndex5D o) -> bool"""
7238 return _IMP_algebra.GridIndex5D___le__(self, o)
7241 r"""__hash__(GridIndex5D self) -> std::size_t"""
7242 return _IMP_algebra.GridIndex5D___hash__(self)
7245 r"""__str__(GridIndex5D self) -> std::string"""
7246 return _IMP_algebra.GridIndex5D___str__(self)
7249 r"""__repr__(GridIndex5D self) -> std::string"""
7250 return _IMP_algebra.GridIndex5D___repr__(self)
7252 def _get_as_binary(self):
7253 r"""_get_as_binary(GridIndex5D self) -> PyObject *"""
7254 return _IMP_algebra.GridIndex5D__get_as_binary(self)
7256 def _set_from_binary(self, p):
7257 r"""_set_from_binary(GridIndex5D self, PyObject * p)"""
7258 return _IMP_algebra.GridIndex5D__set_from_binary(self, p)
7260 def __getstate__(self):
7261 p = self._get_as_binary()
7262 if len(self.__dict__) > 1:
7263 d = self.__dict__.copy()
7268 def __setstate__(self, p):
7269 if not hasattr(self,
'this'):
7271 if isinstance(p, tuple):
7273 self.__dict__.update(d)
7274 return self._set_from_binary(p)
7276 __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
7279 _IMP_algebra.GridIndex5D_swigregister(GridIndex5D)
7280 class GridIndex6D(IMP._Value):
7281 r"""Proxy of C++ IMP::algebra::GridIndexD< 6 > class."""
7283 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7285 def __init__(self, *args):
7287 __init__(GridIndex6D self) -> GridIndex6D
7288 __init__(GridIndex6D self, int x) -> GridIndex6D
7289 __init__(GridIndex6D self, int x, int y) -> GridIndex6D
7290 __init__(GridIndex6D self, int x, int y, int z) -> GridIndex6D
7291 __init__(GridIndex6D self, int i, int j, int k, int l) -> GridIndex6D
7292 __init__(GridIndex6D self, int i, int j, int k, int l, int m) -> GridIndex6D
7293 __init__(GridIndex6D self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
7295 _IMP_algebra.GridIndex6D_swiginit(self, _IMP_algebra.new_GridIndex6D(*args))
7297 def get_dimension(self):
7298 r"""get_dimension(GridIndex6D self) -> unsigned int"""
7299 return _IMP_algebra.GridIndex6D_get_dimension(self)
7301 def __getitem__(self, i):
7302 r"""__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
7303 return _IMP_algebra.GridIndex6D___getitem__(self, i)
7305 def show(self, *args):
7306 r"""show(GridIndex6D self, _ostream out=std::cout)"""
7307 return _IMP_algebra.GridIndex6D_show(self, *args)
7310 r"""__len__(GridIndex6D self) -> unsigned int"""
7311 return _IMP_algebra.GridIndex6D___len__(self)
7313 def __cmp__(self, o):
7314 r"""__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
7315 return _IMP_algebra.GridIndex6D___cmp__(self, o)
7317 def __eq__(self, o):
7318 r"""__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
7319 return _IMP_algebra.GridIndex6D___eq__(self, o)
7321 def __ne__(self, o):
7322 r"""__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
7323 return _IMP_algebra.GridIndex6D___ne__(self, o)
7325 def __lt__(self, o):
7326 r"""__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
7327 return _IMP_algebra.GridIndex6D___lt__(self, o)
7329 def __gt__(self, o):
7330 r"""__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
7331 return _IMP_algebra.GridIndex6D___gt__(self, o)
7333 def __ge__(self, o):
7334 r"""__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
7335 return _IMP_algebra.GridIndex6D___ge__(self, o)
7337 def __le__(self, o):
7338 r"""__le__(GridIndex6D self, GridIndex6D o) -> bool"""
7339 return _IMP_algebra.GridIndex6D___le__(self, o)
7342 r"""__hash__(GridIndex6D self) -> std::size_t"""
7343 return _IMP_algebra.GridIndex6D___hash__(self)
7346 r"""__str__(GridIndex6D self) -> std::string"""
7347 return _IMP_algebra.GridIndex6D___str__(self)
7350 r"""__repr__(GridIndex6D self) -> std::string"""
7351 return _IMP_algebra.GridIndex6D___repr__(self)
7353 def _get_as_binary(self):
7354 r"""_get_as_binary(GridIndex6D self) -> PyObject *"""
7355 return _IMP_algebra.GridIndex6D__get_as_binary(self)
7357 def _set_from_binary(self, p):
7358 r"""_set_from_binary(GridIndex6D self, PyObject * p)"""
7359 return _IMP_algebra.GridIndex6D__set_from_binary(self, p)
7361 def __getstate__(self):
7362 p = self._get_as_binary()
7363 if len(self.__dict__) > 1:
7364 d = self.__dict__.copy()
7369 def __setstate__(self, p):
7370 if not hasattr(self,
'this'):
7372 if isinstance(p, tuple):
7374 self.__dict__.update(d)
7375 return self._set_from_binary(p)
7377 __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
7380 _IMP_algebra.GridIndex6D_swigregister(GridIndex6D)
7381 class GridIndexKD(IMP._Value):
7382 r"""Proxy of C++ IMP::algebra::GridIndexD< -1 > class."""
7384 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7386 def __init__(self, *args):
7388 __init__(GridIndexKD self) -> GridIndexKD
7389 __init__(GridIndexKD self, int x) -> GridIndexKD
7390 __init__(GridIndexKD self, int x, int y) -> GridIndexKD
7391 __init__(GridIndexKD self, int x, int y, int z) -> GridIndexKD
7392 __init__(GridIndexKD self, int i, int j, int k, int l) -> GridIndexKD
7393 __init__(GridIndexKD self, int i, int j, int k, int l, int m) -> GridIndexKD
7394 __init__(GridIndexKD self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
7396 _IMP_algebra.GridIndexKD_swiginit(self, _IMP_algebra.new_GridIndexKD(*args))
7398 def get_dimension(self):
7399 r"""get_dimension(GridIndexKD self) -> unsigned int"""
7400 return _IMP_algebra.GridIndexKD_get_dimension(self)
7402 def __getitem__(self, i):
7403 r"""__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
7404 return _IMP_algebra.GridIndexKD___getitem__(self, i)
7406 def show(self, *args):
7407 r"""show(GridIndexKD self, _ostream out=std::cout)"""
7408 return _IMP_algebra.GridIndexKD_show(self, *args)
7411 r"""__len__(GridIndexKD self) -> unsigned int"""
7412 return _IMP_algebra.GridIndexKD___len__(self)
7414 def __cmp__(self, o):
7415 r"""__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
7416 return _IMP_algebra.GridIndexKD___cmp__(self, o)
7418 def __eq__(self, o):
7419 r"""__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
7420 return _IMP_algebra.GridIndexKD___eq__(self, o)
7422 def __ne__(self, o):
7423 r"""__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
7424 return _IMP_algebra.GridIndexKD___ne__(self, o)
7426 def __lt__(self, o):
7427 r"""__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
7428 return _IMP_algebra.GridIndexKD___lt__(self, o)
7430 def __gt__(self, o):
7431 r"""__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
7432 return _IMP_algebra.GridIndexKD___gt__(self, o)
7434 def __ge__(self, o):
7435 r"""__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
7436 return _IMP_algebra.GridIndexKD___ge__(self, o)
7438 def __le__(self, o):
7439 r"""__le__(GridIndexKD self, GridIndexKD o) -> bool"""
7440 return _IMP_algebra.GridIndexKD___le__(self, o)
7443 r"""__hash__(GridIndexKD self) -> std::size_t"""
7444 return _IMP_algebra.GridIndexKD___hash__(self)
7447 r"""__str__(GridIndexKD self) -> std::string"""
7448 return _IMP_algebra.GridIndexKD___str__(self)
7451 r"""__repr__(GridIndexKD self) -> std::string"""
7452 return _IMP_algebra.GridIndexKD___repr__(self)
7454 def _get_as_binary(self):
7455 r"""_get_as_binary(GridIndexKD self) -> PyObject *"""
7456 return _IMP_algebra.GridIndexKD__get_as_binary(self)
7458 def _set_from_binary(self, p):
7459 r"""_set_from_binary(GridIndexKD self, PyObject * p)"""
7460 return _IMP_algebra.GridIndexKD__set_from_binary(self, p)
7462 def __getstate__(self):
7463 p = self._get_as_binary()
7464 if len(self.__dict__) > 1:
7465 d = self.__dict__.copy()
7470 def __setstate__(self, p):
7471 if not hasattr(self,
'this'):
7473 if isinstance(p, tuple):
7475 self.__dict__.update(d)
7476 return self._set_from_binary(p)
7478 __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
7481 _IMP_algebra.GridIndexKD_swigregister(GridIndexKD)
7482 class ExtendedGridIndex1D(IMP._Value):
7483 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 1 > class."""
7485 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7487 def __init__(self, *args):
7489 __init__(ExtendedGridIndex1D self, IMP::Ints vals) -> ExtendedGridIndex1D
7490 __init__(ExtendedGridIndex1D self, int x) -> ExtendedGridIndex1D
7491 __init__(ExtendedGridIndex1D self, int x, int y) -> ExtendedGridIndex1D
7492 __init__(ExtendedGridIndex1D self, int x, int y, int z) -> ExtendedGridIndex1D
7493 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l) -> ExtendedGridIndex1D
7494 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
7495 __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
7496 __init__(ExtendedGridIndex1D self) -> ExtendedGridIndex1D
7498 _IMP_algebra.ExtendedGridIndex1D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex1D(*args))
7500 def get_dimension(self):
7501 r"""get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
7502 return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)
7504 def __cmp__(self, o):
7505 r"""__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
7506 return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, o)
7508 def __eq__(self, o):
7509 r"""__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7510 return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)
7512 def __ne__(self, o):
7513 r"""__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7514 return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)
7516 def __lt__(self, o):
7517 r"""__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7518 return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)
7520 def __gt__(self, o):
7521 r"""__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7522 return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)
7524 def __ge__(self, o):
7525 r"""__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7526 return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)
7528 def __le__(self, o):
7529 r"""__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7530 return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)
7532 def __setitem__(self, i, v):
7533 r"""__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
7534 return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, i, v)
7536 def __getitem__(self, i):
7537 r"""__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
7538 return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)
7540 def show(self, *args):
7541 r"""show(ExtendedGridIndex1D self, _ostream out=std::cout)"""
7542 return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)
7545 r"""__len__(ExtendedGridIndex1D self) -> unsigned int"""
7546 return _IMP_algebra.ExtendedGridIndex1D___len__(self)
7549 r"""__hash__(ExtendedGridIndex1D self) -> std::size_t"""
7550 return _IMP_algebra.ExtendedGridIndex1D___hash__(self)
7552 def get_uniform_offset(self, ii):
7553 r"""get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
7554 return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, ii)
7556 def get_offset(self, i, j, k):
7557 r"""get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
7558 return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, i, j, k)
7561 r"""__str__(ExtendedGridIndex1D self) -> std::string"""
7562 return _IMP_algebra.ExtendedGridIndex1D___str__(self)
7565 r"""__repr__(ExtendedGridIndex1D self) -> std::string"""
7566 return _IMP_algebra.ExtendedGridIndex1D___repr__(self)
7568 def _get_as_binary(self):
7569 r"""_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
7570 return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)
7572 def _set_from_binary(self, p):
7573 r"""_set_from_binary(ExtendedGridIndex1D self, PyObject * p)"""
7574 return _IMP_algebra.ExtendedGridIndex1D__set_from_binary(self, p)
7576 def __getstate__(self):
7577 p = self._get_as_binary()
7578 if len(self.__dict__) > 1:
7579 d = self.__dict__.copy()
7584 def __setstate__(self, p):
7585 if not hasattr(self,
'this'):
7587 if isinstance(p, tuple):
7589 self.__dict__.update(d)
7590 return self._set_from_binary(p)
7592 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
7595 _IMP_algebra.ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
7596 class ExtendedGridIndex2D(IMP._Value):
7597 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 2 > class."""
7599 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7601 def __init__(self, *args):
7603 __init__(ExtendedGridIndex2D self, IMP::Ints vals) -> ExtendedGridIndex2D
7604 __init__(ExtendedGridIndex2D self, int x) -> ExtendedGridIndex2D
7605 __init__(ExtendedGridIndex2D self, int x, int y) -> ExtendedGridIndex2D
7606 __init__(ExtendedGridIndex2D self, int x, int y, int z) -> ExtendedGridIndex2D
7607 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l) -> ExtendedGridIndex2D
7608 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
7609 __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
7610 __init__(ExtendedGridIndex2D self) -> ExtendedGridIndex2D
7612 _IMP_algebra.ExtendedGridIndex2D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex2D(*args))
7614 def get_dimension(self):
7615 r"""get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
7616 return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)
7618 def __cmp__(self, o):
7619 r"""__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
7620 return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, o)
7622 def __eq__(self, o):
7623 r"""__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7624 return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)
7626 def __ne__(self, o):
7627 r"""__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7628 return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)
7630 def __lt__(self, o):
7631 r"""__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7632 return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)
7634 def __gt__(self, o):
7635 r"""__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7636 return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)
7638 def __ge__(self, o):
7639 r"""__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7640 return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)
7642 def __le__(self, o):
7643 r"""__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7644 return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)
7646 def __setitem__(self, i, v):
7647 r"""__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
7648 return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, i, v)
7650 def __getitem__(self, i):
7651 r"""__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
7652 return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)
7654 def show(self, *args):
7655 r"""show(ExtendedGridIndex2D self, _ostream out=std::cout)"""
7656 return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)
7659 r"""__len__(ExtendedGridIndex2D self) -> unsigned int"""
7660 return _IMP_algebra.ExtendedGridIndex2D___len__(self)
7663 r"""__hash__(ExtendedGridIndex2D self) -> std::size_t"""
7664 return _IMP_algebra.ExtendedGridIndex2D___hash__(self)
7666 def get_uniform_offset(self, ii):
7667 r"""get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
7668 return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, ii)
7670 def get_offset(self, i, j, k):
7671 r"""get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
7672 return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, i, j, k)
7675 r"""__str__(ExtendedGridIndex2D self) -> std::string"""
7676 return _IMP_algebra.ExtendedGridIndex2D___str__(self)
7679 r"""__repr__(ExtendedGridIndex2D self) -> std::string"""
7680 return _IMP_algebra.ExtendedGridIndex2D___repr__(self)
7682 def _get_as_binary(self):
7683 r"""_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
7684 return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)
7686 def _set_from_binary(self, p):
7687 r"""_set_from_binary(ExtendedGridIndex2D self, PyObject * p)"""
7688 return _IMP_algebra.ExtendedGridIndex2D__set_from_binary(self, p)
7690 def __getstate__(self):
7691 p = self._get_as_binary()
7692 if len(self.__dict__) > 1:
7693 d = self.__dict__.copy()
7698 def __setstate__(self, p):
7699 if not hasattr(self,
'this'):
7701 if isinstance(p, tuple):
7703 self.__dict__.update(d)
7704 return self._set_from_binary(p)
7706 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
7709 _IMP_algebra.ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
7710 class ExtendedGridIndex3D(IMP._Value):
7711 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 3 > class."""
7713 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7715 def __init__(self, *args):
7717 __init__(ExtendedGridIndex3D self, IMP::Ints vals) -> ExtendedGridIndex3D
7718 __init__(ExtendedGridIndex3D self, int x) -> ExtendedGridIndex3D
7719 __init__(ExtendedGridIndex3D self, int x, int y) -> ExtendedGridIndex3D
7720 __init__(ExtendedGridIndex3D self, int x, int y, int z) -> ExtendedGridIndex3D
7721 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l) -> ExtendedGridIndex3D
7722 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
7723 __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
7724 __init__(ExtendedGridIndex3D self) -> ExtendedGridIndex3D
7726 _IMP_algebra.ExtendedGridIndex3D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex3D(*args))
7728 def get_dimension(self):
7729 r"""get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
7730 return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)
7732 def __cmp__(self, o):
7733 r"""__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
7734 return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, o)
7736 def __eq__(self, o):
7737 r"""__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7738 return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)
7740 def __ne__(self, o):
7741 r"""__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7742 return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)
7744 def __lt__(self, o):
7745 r"""__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7746 return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)
7748 def __gt__(self, o):
7749 r"""__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7750 return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)
7752 def __ge__(self, o):
7753 r"""__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7754 return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)
7756 def __le__(self, o):
7757 r"""__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7758 return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)
7760 def __setitem__(self, i, v):
7761 r"""__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
7762 return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, i, v)
7764 def __getitem__(self, i):
7765 r"""__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
7766 return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)
7768 def show(self, *args):
7769 r"""show(ExtendedGridIndex3D self, _ostream out=std::cout)"""
7770 return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)
7773 r"""__len__(ExtendedGridIndex3D self) -> unsigned int"""
7774 return _IMP_algebra.ExtendedGridIndex3D___len__(self)
7777 r"""__hash__(ExtendedGridIndex3D self) -> std::size_t"""
7778 return _IMP_algebra.ExtendedGridIndex3D___hash__(self)
7780 def get_uniform_offset(self, ii):
7781 r"""get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
7782 return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, ii)
7784 def get_offset(self, i, j, k):
7785 r"""get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
7786 return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, i, j, k)
7789 r"""__str__(ExtendedGridIndex3D self) -> std::string"""
7790 return _IMP_algebra.ExtendedGridIndex3D___str__(self)
7793 r"""__repr__(ExtendedGridIndex3D self) -> std::string"""
7794 return _IMP_algebra.ExtendedGridIndex3D___repr__(self)
7796 def _get_as_binary(self):
7797 r"""_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
7798 return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)
7800 def _set_from_binary(self, p):
7801 r"""_set_from_binary(ExtendedGridIndex3D self, PyObject * p)"""
7802 return _IMP_algebra.ExtendedGridIndex3D__set_from_binary(self, p)
7804 def __getstate__(self):
7805 p = self._get_as_binary()
7806 if len(self.__dict__) > 1:
7807 d = self.__dict__.copy()
7812 def __setstate__(self, p):
7813 if not hasattr(self,
'this'):
7815 if isinstance(p, tuple):
7817 self.__dict__.update(d)
7818 return self._set_from_binary(p)
7820 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
7823 _IMP_algebra.ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
7824 class ExtendedGridIndex4D(IMP._Value):
7825 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 4 > class."""
7827 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7829 def __init__(self, *args):
7831 __init__(ExtendedGridIndex4D self, IMP::Ints vals) -> ExtendedGridIndex4D
7832 __init__(ExtendedGridIndex4D self, int x) -> ExtendedGridIndex4D
7833 __init__(ExtendedGridIndex4D self, int x, int y) -> ExtendedGridIndex4D
7834 __init__(ExtendedGridIndex4D self, int x, int y, int z) -> ExtendedGridIndex4D
7835 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l) -> ExtendedGridIndex4D
7836 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
7837 __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
7838 __init__(ExtendedGridIndex4D self) -> ExtendedGridIndex4D
7840 _IMP_algebra.ExtendedGridIndex4D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex4D(*args))
7842 def get_dimension(self):
7843 r"""get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
7844 return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)
7846 def __cmp__(self, o):
7847 r"""__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
7848 return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, o)
7850 def __eq__(self, o):
7851 r"""__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7852 return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)
7854 def __ne__(self, o):
7855 r"""__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7856 return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)
7858 def __lt__(self, o):
7859 r"""__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7860 return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)
7862 def __gt__(self, o):
7863 r"""__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7864 return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)
7866 def __ge__(self, o):
7867 r"""__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7868 return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)
7870 def __le__(self, o):
7871 r"""__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7872 return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)
7874 def __setitem__(self, i, v):
7875 r"""__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
7876 return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, i, v)
7878 def __getitem__(self, i):
7879 r"""__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
7880 return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)
7882 def show(self, *args):
7883 r"""show(ExtendedGridIndex4D self, _ostream out=std::cout)"""
7884 return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)
7887 r"""__len__(ExtendedGridIndex4D self) -> unsigned int"""
7888 return _IMP_algebra.ExtendedGridIndex4D___len__(self)
7891 r"""__hash__(ExtendedGridIndex4D self) -> std::size_t"""
7892 return _IMP_algebra.ExtendedGridIndex4D___hash__(self)
7894 def get_uniform_offset(self, ii):
7895 r"""get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
7896 return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, ii)
7898 def get_offset(self, i, j, k):
7899 r"""get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
7900 return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, i, j, k)
7903 r"""__str__(ExtendedGridIndex4D self) -> std::string"""
7904 return _IMP_algebra.ExtendedGridIndex4D___str__(self)
7907 r"""__repr__(ExtendedGridIndex4D self) -> std::string"""
7908 return _IMP_algebra.ExtendedGridIndex4D___repr__(self)
7910 def _get_as_binary(self):
7911 r"""_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
7912 return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)
7914 def _set_from_binary(self, p):
7915 r"""_set_from_binary(ExtendedGridIndex4D self, PyObject * p)"""
7916 return _IMP_algebra.ExtendedGridIndex4D__set_from_binary(self, p)
7918 def __getstate__(self):
7919 p = self._get_as_binary()
7920 if len(self.__dict__) > 1:
7921 d = self.__dict__.copy()
7926 def __setstate__(self, p):
7927 if not hasattr(self,
'this'):
7929 if isinstance(p, tuple):
7931 self.__dict__.update(d)
7932 return self._set_from_binary(p)
7934 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
7937 _IMP_algebra.ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
7938 class ExtendedGridIndex5D(IMP._Value):
7939 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 5 > class."""
7941 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
7943 def __init__(self, *args):
7945 __init__(ExtendedGridIndex5D self, IMP::Ints vals) -> ExtendedGridIndex5D
7946 __init__(ExtendedGridIndex5D self, int x) -> ExtendedGridIndex5D
7947 __init__(ExtendedGridIndex5D self, int x, int y) -> ExtendedGridIndex5D
7948 __init__(ExtendedGridIndex5D self, int x, int y, int z) -> ExtendedGridIndex5D
7949 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l) -> ExtendedGridIndex5D
7950 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
7951 __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
7952 __init__(ExtendedGridIndex5D self) -> ExtendedGridIndex5D
7954 _IMP_algebra.ExtendedGridIndex5D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex5D(*args))
7956 def get_dimension(self):
7957 r"""get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
7958 return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)
7960 def __cmp__(self, o):
7961 r"""__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
7962 return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, o)
7964 def __eq__(self, o):
7965 r"""__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7966 return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)
7968 def __ne__(self, o):
7969 r"""__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7970 return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)
7972 def __lt__(self, o):
7973 r"""__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7974 return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)
7976 def __gt__(self, o):
7977 r"""__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7978 return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)
7980 def __ge__(self, o):
7981 r"""__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7982 return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)
7984 def __le__(self, o):
7985 r"""__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7986 return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)
7988 def __setitem__(self, i, v):
7989 r"""__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
7990 return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, i, v)
7992 def __getitem__(self, i):
7993 r"""__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
7994 return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)
7996 def show(self, *args):
7997 r"""show(ExtendedGridIndex5D self, _ostream out=std::cout)"""
7998 return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)
8001 r"""__len__(ExtendedGridIndex5D self) -> unsigned int"""
8002 return _IMP_algebra.ExtendedGridIndex5D___len__(self)
8005 r"""__hash__(ExtendedGridIndex5D self) -> std::size_t"""
8006 return _IMP_algebra.ExtendedGridIndex5D___hash__(self)
8008 def get_uniform_offset(self, ii):
8009 r"""get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
8010 return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, ii)
8012 def get_offset(self, i, j, k):
8013 r"""get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
8014 return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, i, j, k)
8017 r"""__str__(ExtendedGridIndex5D self) -> std::string"""
8018 return _IMP_algebra.ExtendedGridIndex5D___str__(self)
8021 r"""__repr__(ExtendedGridIndex5D self) -> std::string"""
8022 return _IMP_algebra.ExtendedGridIndex5D___repr__(self)
8024 def _get_as_binary(self):
8025 r"""_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
8026 return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)
8028 def _set_from_binary(self, p):
8029 r"""_set_from_binary(ExtendedGridIndex5D self, PyObject * p)"""
8030 return _IMP_algebra.ExtendedGridIndex5D__set_from_binary(self, p)
8032 def __getstate__(self):
8033 p = self._get_as_binary()
8034 if len(self.__dict__) > 1:
8035 d = self.__dict__.copy()
8040 def __setstate__(self, p):
8041 if not hasattr(self,
'this'):
8043 if isinstance(p, tuple):
8045 self.__dict__.update(d)
8046 return self._set_from_binary(p)
8048 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
8051 _IMP_algebra.ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
8052 class ExtendedGridIndex6D(IMP._Value):
8053 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 6 > class."""
8055 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8057 def __init__(self, *args):
8059 __init__(ExtendedGridIndex6D self, IMP::Ints vals) -> ExtendedGridIndex6D
8060 __init__(ExtendedGridIndex6D self, int x) -> ExtendedGridIndex6D
8061 __init__(ExtendedGridIndex6D self, int x, int y) -> ExtendedGridIndex6D
8062 __init__(ExtendedGridIndex6D self, int x, int y, int z) -> ExtendedGridIndex6D
8063 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l) -> ExtendedGridIndex6D
8064 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
8065 __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
8066 __init__(ExtendedGridIndex6D self) -> ExtendedGridIndex6D
8068 _IMP_algebra.ExtendedGridIndex6D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex6D(*args))
8070 def get_dimension(self):
8071 r"""get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
8072 return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)
8074 def __cmp__(self, o):
8075 r"""__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
8076 return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, o)
8078 def __eq__(self, o):
8079 r"""__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8080 return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)
8082 def __ne__(self, o):
8083 r"""__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8084 return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)
8086 def __lt__(self, o):
8087 r"""__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8088 return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)
8090 def __gt__(self, o):
8091 r"""__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8092 return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)
8094 def __ge__(self, o):
8095 r"""__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8096 return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)
8098 def __le__(self, o):
8099 r"""__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8100 return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)
8102 def __setitem__(self, i, v):
8103 r"""__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
8104 return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, i, v)
8106 def __getitem__(self, i):
8107 r"""__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
8108 return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)
8110 def show(self, *args):
8111 r"""show(ExtendedGridIndex6D self, _ostream out=std::cout)"""
8112 return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)
8115 r"""__len__(ExtendedGridIndex6D self) -> unsigned int"""
8116 return _IMP_algebra.ExtendedGridIndex6D___len__(self)
8119 r"""__hash__(ExtendedGridIndex6D self) -> std::size_t"""
8120 return _IMP_algebra.ExtendedGridIndex6D___hash__(self)
8122 def get_uniform_offset(self, ii):
8123 r"""get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
8124 return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, ii)
8126 def get_offset(self, i, j, k):
8127 r"""get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
8128 return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, i, j, k)
8131 r"""__str__(ExtendedGridIndex6D self) -> std::string"""
8132 return _IMP_algebra.ExtendedGridIndex6D___str__(self)
8135 r"""__repr__(ExtendedGridIndex6D self) -> std::string"""
8136 return _IMP_algebra.ExtendedGridIndex6D___repr__(self)
8138 def _get_as_binary(self):
8139 r"""_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
8140 return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)
8142 def _set_from_binary(self, p):
8143 r"""_set_from_binary(ExtendedGridIndex6D self, PyObject * p)"""
8144 return _IMP_algebra.ExtendedGridIndex6D__set_from_binary(self, p)
8146 def __getstate__(self):
8147 p = self._get_as_binary()
8148 if len(self.__dict__) > 1:
8149 d = self.__dict__.copy()
8154 def __setstate__(self, p):
8155 if not hasattr(self,
'this'):
8157 if isinstance(p, tuple):
8159 self.__dict__.update(d)
8160 return self._set_from_binary(p)
8162 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
8165 _IMP_algebra.ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
8166 class ExtendedGridIndexKD(IMP._Value):
8167 r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< -1 > class."""
8169 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8171 def __init__(self, *args):
8173 __init__(ExtendedGridIndexKD self, IMP::Ints vals) -> ExtendedGridIndexKD
8174 __init__(ExtendedGridIndexKD self, int x) -> ExtendedGridIndexKD
8175 __init__(ExtendedGridIndexKD self, int x, int y) -> ExtendedGridIndexKD
8176 __init__(ExtendedGridIndexKD self, int x, int y, int z) -> ExtendedGridIndexKD
8177 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l) -> ExtendedGridIndexKD
8178 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
8179 __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
8180 __init__(ExtendedGridIndexKD self) -> ExtendedGridIndexKD
8182 _IMP_algebra.ExtendedGridIndexKD_swiginit(self, _IMP_algebra.new_ExtendedGridIndexKD(*args))
8184 def get_dimension(self):
8185 r"""get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
8186 return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)
8188 def __cmp__(self, o):
8189 r"""__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
8190 return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, o)
8192 def __eq__(self, o):
8193 r"""__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8194 return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)
8196 def __ne__(self, o):
8197 r"""__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8198 return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)
8200 def __lt__(self, o):
8201 r"""__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8202 return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)
8204 def __gt__(self, o):
8205 r"""__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8206 return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)
8208 def __ge__(self, o):
8209 r"""__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8210 return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)
8212 def __le__(self, o):
8213 r"""__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8214 return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)
8216 def __setitem__(self, i, v):
8217 r"""__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
8218 return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, i, v)
8220 def __getitem__(self, i):
8221 r"""__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
8222 return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)
8224 def show(self, *args):
8225 r"""show(ExtendedGridIndexKD self, _ostream out=std::cout)"""
8226 return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)
8229 r"""__len__(ExtendedGridIndexKD self) -> unsigned int"""
8230 return _IMP_algebra.ExtendedGridIndexKD___len__(self)
8233 r"""__hash__(ExtendedGridIndexKD self) -> std::size_t"""
8234 return _IMP_algebra.ExtendedGridIndexKD___hash__(self)
8236 def get_uniform_offset(self, ii):
8237 r"""get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
8238 return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, ii)
8240 def get_offset(self, i, j, k):
8241 r"""get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
8242 return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, i, j, k)
8245 r"""__str__(ExtendedGridIndexKD self) -> std::string"""
8246 return _IMP_algebra.ExtendedGridIndexKD___str__(self)
8249 r"""__repr__(ExtendedGridIndexKD self) -> std::string"""
8250 return _IMP_algebra.ExtendedGridIndexKD___repr__(self)
8252 def _get_as_binary(self):
8253 r"""_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
8254 return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)
8256 def _set_from_binary(self, p):
8257 r"""_set_from_binary(ExtendedGridIndexKD self, PyObject * p)"""
8258 return _IMP_algebra.ExtendedGridIndexKD__set_from_binary(self, p)
8260 def __getstate__(self):
8261 p = self._get_as_binary()
8262 if len(self.__dict__) > 1:
8263 d = self.__dict__.copy()
8268 def __setstate__(self, p):
8269 if not hasattr(self,
'this'):
8271 if isinstance(p, tuple):
8273 self.__dict__.update(d)
8274 return self._set_from_binary(p)
8276 __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
8279 _IMP_algebra.ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
8280 class BoundedGridRange1D(object):
8281 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 1 > class."""
8283 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8286 def get_is_bounded():
8287 r"""get_is_bounded() -> bool"""
8288 return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
8290 def __init__(self, *args):
8292 __init__(BoundedGridRange1D self) -> BoundedGridRange1D
8293 __init__(BoundedGridRange1D self, IMP::Ints const & counts) -> BoundedGridRange1D
8295 _IMP_algebra.BoundedGridRange1D_swiginit(self, _IMP_algebra.new_BoundedGridRange1D(*args))
8297 def get_number_of_voxels(self, *args):
8299 get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
8300 get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
8302 return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)
8304 def get_end_index(self):
8305 r"""get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8306 return _IMP_algebra.BoundedGridRange1D_get_end_index(self)
8308 def show(self, *args):
8309 r"""show(BoundedGridRange1D self, _ostream out=std::cout)"""
8310 return _IMP_algebra.BoundedGridRange1D_show(self, *args)
8312 def get_all_indexes(self):
8313 r"""get_all_indexes(BoundedGridRange1D self) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8314 return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)
8317 r"""get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8318 return _IMP_algebra.BoundedGridRange1D_get_indexes(self, lb, ub)
8320 def get_extended_indexes(self, lb, ub):
8321 r"""get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
8322 return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, lb, ub)
8325 r"""get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
8326 return _IMP_algebra.BoundedGridRange1D_get_index(self, v)
8328 def get_has_index(self, v):
8329 r"""get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
8330 return _IMP_algebra.BoundedGridRange1D_get_has_index(self, v)
8332 def get_minimum_extended_index(self):
8333 r"""get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8334 return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)
8336 def get_maximum_extended_index(self):
8337 r"""get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8338 return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)
8341 r"""__str__(BoundedGridRange1D self) -> std::string"""
8342 return _IMP_algebra.BoundedGridRange1D___str__(self)
8345 r"""__repr__(BoundedGridRange1D self) -> std::string"""
8346 return _IMP_algebra.BoundedGridRange1D___repr__(self)
8348 def __cmp__(self, arg2):
8349 r"""__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
8350 return _IMP_algebra.BoundedGridRange1D___cmp__(self, arg2)
8352 def __eq__(self, arg2):
8353 r"""__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
8354 return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)
8356 def _get_as_binary(self):
8357 r"""_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
8358 return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)
8360 def _set_from_binary(self, p):
8361 r"""_set_from_binary(BoundedGridRange1D self, PyObject * p)"""
8362 return _IMP_algebra.BoundedGridRange1D__set_from_binary(self, p)
8364 def __getstate__(self):
8365 p = self._get_as_binary()
8366 if len(self.__dict__) > 1:
8367 d = self.__dict__.copy()
8372 def __setstate__(self, p):
8373 if not hasattr(self,
'this'):
8375 if isinstance(p, tuple):
8377 self.__dict__.update(d)
8378 return self._set_from_binary(p)
8380 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
8383 _IMP_algebra.BoundedGridRange1D_swigregister(BoundedGridRange1D)
8384 class BoundedGridRange2D(object):
8385 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 2 > class."""
8387 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8390 def get_is_bounded():
8391 r"""get_is_bounded() -> bool"""
8392 return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
8394 def __init__(self, *args):
8396 __init__(BoundedGridRange2D self) -> BoundedGridRange2D
8397 __init__(BoundedGridRange2D self, IMP::Ints const & counts) -> BoundedGridRange2D
8399 _IMP_algebra.BoundedGridRange2D_swiginit(self, _IMP_algebra.new_BoundedGridRange2D(*args))
8401 def get_number_of_voxels(self, *args):
8403 get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
8404 get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
8406 return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)
8408 def get_end_index(self):
8409 r"""get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8410 return _IMP_algebra.BoundedGridRange2D_get_end_index(self)
8412 def show(self, *args):
8413 r"""show(BoundedGridRange2D self, _ostream out=std::cout)"""
8414 return _IMP_algebra.BoundedGridRange2D_show(self, *args)
8416 def get_all_indexes(self):
8417 r"""get_all_indexes(BoundedGridRange2D self) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8418 return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)
8421 r"""get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8422 return _IMP_algebra.BoundedGridRange2D_get_indexes(self, lb, ub)
8424 def get_extended_indexes(self, lb, ub):
8425 r"""get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
8426 return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, lb, ub)
8429 r"""get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
8430 return _IMP_algebra.BoundedGridRange2D_get_index(self, v)
8432 def get_has_index(self, v):
8433 r"""get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
8434 return _IMP_algebra.BoundedGridRange2D_get_has_index(self, v)
8436 def get_minimum_extended_index(self):
8437 r"""get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8438 return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)
8440 def get_maximum_extended_index(self):
8441 r"""get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8442 return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)
8445 r"""__str__(BoundedGridRange2D self) -> std::string"""
8446 return _IMP_algebra.BoundedGridRange2D___str__(self)
8449 r"""__repr__(BoundedGridRange2D self) -> std::string"""
8450 return _IMP_algebra.BoundedGridRange2D___repr__(self)
8452 def __cmp__(self, arg2):
8453 r"""__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
8454 return _IMP_algebra.BoundedGridRange2D___cmp__(self, arg2)
8456 def __eq__(self, arg2):
8457 r"""__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
8458 return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)
8460 def _get_as_binary(self):
8461 r"""_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
8462 return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)
8464 def _set_from_binary(self, p):
8465 r"""_set_from_binary(BoundedGridRange2D self, PyObject * p)"""
8466 return _IMP_algebra.BoundedGridRange2D__set_from_binary(self, p)
8468 def __getstate__(self):
8469 p = self._get_as_binary()
8470 if len(self.__dict__) > 1:
8471 d = self.__dict__.copy()
8476 def __setstate__(self, p):
8477 if not hasattr(self,
'this'):
8479 if isinstance(p, tuple):
8481 self.__dict__.update(d)
8482 return self._set_from_binary(p)
8484 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
8487 _IMP_algebra.BoundedGridRange2D_swigregister(BoundedGridRange2D)
8488 class BoundedGridRange3D(object):
8489 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 3 > class."""
8491 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8494 def get_is_bounded():
8495 r"""get_is_bounded() -> bool"""
8496 return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
8498 def __init__(self, *args):
8500 __init__(BoundedGridRange3D self) -> BoundedGridRange3D
8501 __init__(BoundedGridRange3D self, IMP::Ints const & counts) -> BoundedGridRange3D
8503 _IMP_algebra.BoundedGridRange3D_swiginit(self, _IMP_algebra.new_BoundedGridRange3D(*args))
8505 def get_number_of_voxels(self, *args):
8507 get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
8508 get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
8510 return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)
8512 def get_end_index(self):
8513 r"""get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8514 return _IMP_algebra.BoundedGridRange3D_get_end_index(self)
8516 def show(self, *args):
8517 r"""show(BoundedGridRange3D self, _ostream out=std::cout)"""
8518 return _IMP_algebra.BoundedGridRange3D_show(self, *args)
8520 def get_all_indexes(self):
8521 r"""get_all_indexes(BoundedGridRange3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8522 return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)
8525 r"""get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8526 return _IMP_algebra.BoundedGridRange3D_get_indexes(self, lb, ub)
8528 def get_extended_indexes(self, lb, ub):
8529 r"""get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
8530 return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, lb, ub)
8533 r"""get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
8534 return _IMP_algebra.BoundedGridRange3D_get_index(self, v)
8536 def get_has_index(self, v):
8537 r"""get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
8538 return _IMP_algebra.BoundedGridRange3D_get_has_index(self, v)
8540 def get_minimum_extended_index(self):
8541 r"""get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8542 return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)
8544 def get_maximum_extended_index(self):
8545 r"""get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8546 return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)
8549 r"""__str__(BoundedGridRange3D self) -> std::string"""
8550 return _IMP_algebra.BoundedGridRange3D___str__(self)
8553 r"""__repr__(BoundedGridRange3D self) -> std::string"""
8554 return _IMP_algebra.BoundedGridRange3D___repr__(self)
8556 def __cmp__(self, arg2):
8557 r"""__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
8558 return _IMP_algebra.BoundedGridRange3D___cmp__(self, arg2)
8560 def __eq__(self, arg2):
8561 r"""__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
8562 return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)
8564 def _get_as_binary(self):
8565 r"""_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
8566 return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)
8568 def _set_from_binary(self, p):
8569 r"""_set_from_binary(BoundedGridRange3D self, PyObject * p)"""
8570 return _IMP_algebra.BoundedGridRange3D__set_from_binary(self, p)
8572 def __getstate__(self):
8573 p = self._get_as_binary()
8574 if len(self.__dict__) > 1:
8575 d = self.__dict__.copy()
8580 def __setstate__(self, p):
8581 if not hasattr(self,
'this'):
8583 if isinstance(p, tuple):
8585 self.__dict__.update(d)
8586 return self._set_from_binary(p)
8588 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
8591 _IMP_algebra.BoundedGridRange3D_swigregister(BoundedGridRange3D)
8592 class BoundedGridRange4D(object):
8593 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 4 > class."""
8595 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8598 def get_is_bounded():
8599 r"""get_is_bounded() -> bool"""
8600 return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
8602 def __init__(self, *args):
8604 __init__(BoundedGridRange4D self) -> BoundedGridRange4D
8605 __init__(BoundedGridRange4D self, IMP::Ints const & counts) -> BoundedGridRange4D
8607 _IMP_algebra.BoundedGridRange4D_swiginit(self, _IMP_algebra.new_BoundedGridRange4D(*args))
8609 def get_number_of_voxels(self, *args):
8611 get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
8612 get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
8614 return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)
8616 def get_end_index(self):
8617 r"""get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8618 return _IMP_algebra.BoundedGridRange4D_get_end_index(self)
8620 def show(self, *args):
8621 r"""show(BoundedGridRange4D self, _ostream out=std::cout)"""
8622 return _IMP_algebra.BoundedGridRange4D_show(self, *args)
8624 def get_all_indexes(self):
8625 r"""get_all_indexes(BoundedGridRange4D self) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8626 return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)
8629 r"""get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8630 return _IMP_algebra.BoundedGridRange4D_get_indexes(self, lb, ub)
8632 def get_extended_indexes(self, lb, ub):
8633 r"""get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
8634 return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, lb, ub)
8637 r"""get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
8638 return _IMP_algebra.BoundedGridRange4D_get_index(self, v)
8640 def get_has_index(self, v):
8641 r"""get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
8642 return _IMP_algebra.BoundedGridRange4D_get_has_index(self, v)
8644 def get_minimum_extended_index(self):
8645 r"""get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8646 return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)
8648 def get_maximum_extended_index(self):
8649 r"""get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8650 return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)
8653 r"""__str__(BoundedGridRange4D self) -> std::string"""
8654 return _IMP_algebra.BoundedGridRange4D___str__(self)
8657 r"""__repr__(BoundedGridRange4D self) -> std::string"""
8658 return _IMP_algebra.BoundedGridRange4D___repr__(self)
8660 def __cmp__(self, arg2):
8661 r"""__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
8662 return _IMP_algebra.BoundedGridRange4D___cmp__(self, arg2)
8664 def __eq__(self, arg2):
8665 r"""__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
8666 return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)
8668 def _get_as_binary(self):
8669 r"""_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
8670 return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)
8672 def _set_from_binary(self, p):
8673 r"""_set_from_binary(BoundedGridRange4D self, PyObject * p)"""
8674 return _IMP_algebra.BoundedGridRange4D__set_from_binary(self, p)
8676 def __getstate__(self):
8677 p = self._get_as_binary()
8678 if len(self.__dict__) > 1:
8679 d = self.__dict__.copy()
8684 def __setstate__(self, p):
8685 if not hasattr(self,
'this'):
8687 if isinstance(p, tuple):
8689 self.__dict__.update(d)
8690 return self._set_from_binary(p)
8692 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
8695 _IMP_algebra.BoundedGridRange4D_swigregister(BoundedGridRange4D)
8696 class BoundedGridRange5D(object):
8697 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 5 > class."""
8699 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8702 def get_is_bounded():
8703 r"""get_is_bounded() -> bool"""
8704 return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
8706 def __init__(self, *args):
8708 __init__(BoundedGridRange5D self) -> BoundedGridRange5D
8709 __init__(BoundedGridRange5D self, IMP::Ints const & counts) -> BoundedGridRange5D
8711 _IMP_algebra.BoundedGridRange5D_swiginit(self, _IMP_algebra.new_BoundedGridRange5D(*args))
8713 def get_number_of_voxels(self, *args):
8715 get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
8716 get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
8718 return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)
8720 def get_end_index(self):
8721 r"""get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8722 return _IMP_algebra.BoundedGridRange5D_get_end_index(self)
8724 def show(self, *args):
8725 r"""show(BoundedGridRange5D self, _ostream out=std::cout)"""
8726 return _IMP_algebra.BoundedGridRange5D_show(self, *args)
8728 def get_all_indexes(self):
8729 r"""get_all_indexes(BoundedGridRange5D self) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8730 return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)
8733 r"""get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8734 return _IMP_algebra.BoundedGridRange5D_get_indexes(self, lb, ub)
8736 def get_extended_indexes(self, lb, ub):
8737 r"""get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
8738 return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, lb, ub)
8741 r"""get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
8742 return _IMP_algebra.BoundedGridRange5D_get_index(self, v)
8744 def get_has_index(self, v):
8745 r"""get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
8746 return _IMP_algebra.BoundedGridRange5D_get_has_index(self, v)
8748 def get_minimum_extended_index(self):
8749 r"""get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8750 return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)
8752 def get_maximum_extended_index(self):
8753 r"""get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8754 return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)
8757 r"""__str__(BoundedGridRange5D self) -> std::string"""
8758 return _IMP_algebra.BoundedGridRange5D___str__(self)
8761 r"""__repr__(BoundedGridRange5D self) -> std::string"""
8762 return _IMP_algebra.BoundedGridRange5D___repr__(self)
8764 def __cmp__(self, arg2):
8765 r"""__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
8766 return _IMP_algebra.BoundedGridRange5D___cmp__(self, arg2)
8768 def __eq__(self, arg2):
8769 r"""__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
8770 return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)
8772 def _get_as_binary(self):
8773 r"""_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
8774 return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)
8776 def _set_from_binary(self, p):
8777 r"""_set_from_binary(BoundedGridRange5D self, PyObject * p)"""
8778 return _IMP_algebra.BoundedGridRange5D__set_from_binary(self, p)
8780 def __getstate__(self):
8781 p = self._get_as_binary()
8782 if len(self.__dict__) > 1:
8783 d = self.__dict__.copy()
8788 def __setstate__(self, p):
8789 if not hasattr(self,
'this'):
8791 if isinstance(p, tuple):
8793 self.__dict__.update(d)
8794 return self._set_from_binary(p)
8796 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
8799 _IMP_algebra.BoundedGridRange5D_swigregister(BoundedGridRange5D)
8800 class BoundedGridRange6D(object):
8801 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 6 > class."""
8803 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8806 def get_is_bounded():
8807 r"""get_is_bounded() -> bool"""
8808 return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
8810 def __init__(self, *args):
8812 __init__(BoundedGridRange6D self) -> BoundedGridRange6D
8813 __init__(BoundedGridRange6D self, IMP::Ints const & counts) -> BoundedGridRange6D
8815 _IMP_algebra.BoundedGridRange6D_swiginit(self, _IMP_algebra.new_BoundedGridRange6D(*args))
8817 def get_number_of_voxels(self, *args):
8819 get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
8820 get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
8822 return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)
8824 def get_end_index(self):
8825 r"""get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8826 return _IMP_algebra.BoundedGridRange6D_get_end_index(self)
8828 def show(self, *args):
8829 r"""show(BoundedGridRange6D self, _ostream out=std::cout)"""
8830 return _IMP_algebra.BoundedGridRange6D_show(self, *args)
8832 def get_all_indexes(self):
8833 r"""get_all_indexes(BoundedGridRange6D self) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8834 return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)
8837 r"""get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8838 return _IMP_algebra.BoundedGridRange6D_get_indexes(self, lb, ub)
8840 def get_extended_indexes(self, lb, ub):
8841 r"""get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
8842 return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, lb, ub)
8845 r"""get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
8846 return _IMP_algebra.BoundedGridRange6D_get_index(self, v)
8848 def get_has_index(self, v):
8849 r"""get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
8850 return _IMP_algebra.BoundedGridRange6D_get_has_index(self, v)
8852 def get_minimum_extended_index(self):
8853 r"""get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8854 return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)
8856 def get_maximum_extended_index(self):
8857 r"""get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8858 return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)
8861 r"""__str__(BoundedGridRange6D self) -> std::string"""
8862 return _IMP_algebra.BoundedGridRange6D___str__(self)
8865 r"""__repr__(BoundedGridRange6D self) -> std::string"""
8866 return _IMP_algebra.BoundedGridRange6D___repr__(self)
8868 def __cmp__(self, arg2):
8869 r"""__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
8870 return _IMP_algebra.BoundedGridRange6D___cmp__(self, arg2)
8872 def __eq__(self, arg2):
8873 r"""__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
8874 return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)
8876 def _get_as_binary(self):
8877 r"""_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
8878 return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)
8880 def _set_from_binary(self, p):
8881 r"""_set_from_binary(BoundedGridRange6D self, PyObject * p)"""
8882 return _IMP_algebra.BoundedGridRange6D__set_from_binary(self, p)
8884 def __getstate__(self):
8885 p = self._get_as_binary()
8886 if len(self.__dict__) > 1:
8887 d = self.__dict__.copy()
8892 def __setstate__(self, p):
8893 if not hasattr(self,
'this'):
8895 if isinstance(p, tuple):
8897 self.__dict__.update(d)
8898 return self._set_from_binary(p)
8900 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
8903 _IMP_algebra.BoundedGridRange6D_swigregister(BoundedGridRange6D)
8904 class BoundedGridRangeKD(object):
8905 r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< -1 > class."""
8907 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
8910 def get_is_bounded():
8911 r"""get_is_bounded() -> bool"""
8912 return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
8914 def __init__(self, *args):
8916 __init__(BoundedGridRangeKD self) -> BoundedGridRangeKD
8917 __init__(BoundedGridRangeKD self, IMP::Ints const & counts) -> BoundedGridRangeKD
8919 _IMP_algebra.BoundedGridRangeKD_swiginit(self, _IMP_algebra.new_BoundedGridRangeKD(*args))
8921 def get_number_of_voxels(self, *args):
8923 get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
8924 get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
8926 return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)
8928 def get_end_index(self):
8929 r"""get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8930 return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)
8932 def show(self, *args):
8933 r"""show(BoundedGridRangeKD self, _ostream out=std::cout)"""
8934 return _IMP_algebra.BoundedGridRangeKD_show(self, *args)
8936 def get_all_indexes(self):
8937 r"""get_all_indexes(BoundedGridRangeKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8938 return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)
8941 r"""get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8942 return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, lb, ub)
8944 def get_extended_indexes(self, lb, ub):
8945 r"""get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
8946 return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, lb, ub)
8949 r"""get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
8950 return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)
8952 def get_has_index(self, v):
8953 r"""get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
8954 return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, v)
8956 def get_minimum_extended_index(self):
8957 r"""get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8958 return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)
8960 def get_maximum_extended_index(self):
8961 r"""get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8962 return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)
8965 r"""__str__(BoundedGridRangeKD self) -> std::string"""
8966 return _IMP_algebra.BoundedGridRangeKD___str__(self)
8969 r"""__repr__(BoundedGridRangeKD self) -> std::string"""
8970 return _IMP_algebra.BoundedGridRangeKD___repr__(self)
8972 def __cmp__(self, arg2):
8973 r"""__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
8974 return _IMP_algebra.BoundedGridRangeKD___cmp__(self, arg2)
8976 def __eq__(self, arg2):
8977 r"""__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
8978 return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)
8980 def _get_as_binary(self):
8981 r"""_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
8982 return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)
8984 def _set_from_binary(self, p):
8985 r"""_set_from_binary(BoundedGridRangeKD self, PyObject * p)"""
8986 return _IMP_algebra.BoundedGridRangeKD__set_from_binary(self, p)
8988 def __getstate__(self):
8989 p = self._get_as_binary()
8990 if len(self.__dict__) > 1:
8991 d = self.__dict__.copy()
8996 def __setstate__(self, p):
8997 if not hasattr(self,
'this'):
8999 if isinstance(p, tuple):
9001 self.__dict__.update(d)
9002 return self._set_from_binary(p)
9004 __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
9007 _IMP_algebra.BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
9008 class UnboundedGridRange1D(object):
9009 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 1 > class."""
9011 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9013 def __init__(self, *args):
9015 __init__(UnboundedGridRange1D self) -> UnboundedGridRange1D
9016 __init__(UnboundedGridRange1D self, IMP::Ints const & arg2) -> UnboundedGridRange1D
9018 _IMP_algebra.UnboundedGridRange1D_swiginit(self, _IMP_algebra.new_UnboundedGridRange1D(*args))
9020 def set_number_of_voxels(self, arg2):
9021 r"""set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
9022 return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, arg2)
9024 def get_number_of_voxels(self, arg2):
9025 r"""get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
9026 return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, arg2)
9029 def get_is_bounded():
9030 r"""get_is_bounded() -> bool"""
9031 return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
9033 def get_has_index(self, arg2):
9034 r"""get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
9035 return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, arg2)
9037 def show(self, *args):
9038 r"""show(UnboundedGridRange1D self, _ostream out=std::cout)"""
9039 return _IMP_algebra.UnboundedGridRange1D_show(self, *args)
9041 def get_extended_indexes(self, lb, ub):
9042 r"""get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
9043 return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, lb, ub)
9046 r"""__str__(UnboundedGridRange1D self) -> std::string"""
9047 return _IMP_algebra.UnboundedGridRange1D___str__(self)
9050 r"""__repr__(UnboundedGridRange1D self) -> std::string"""
9051 return _IMP_algebra.UnboundedGridRange1D___repr__(self)
9053 def __cmp__(self, arg2):
9054 r"""__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
9055 return _IMP_algebra.UnboundedGridRange1D___cmp__(self, arg2)
9057 def __eq__(self, arg2):
9058 r"""__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
9059 return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)
9061 def _get_as_binary(self):
9062 r"""_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
9063 return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)
9065 def _set_from_binary(self, p):
9066 r"""_set_from_binary(UnboundedGridRange1D self, PyObject * p)"""
9067 return _IMP_algebra.UnboundedGridRange1D__set_from_binary(self, p)
9069 def __getstate__(self):
9070 p = self._get_as_binary()
9071 if len(self.__dict__) > 1:
9072 d = self.__dict__.copy()
9077 def __setstate__(self, p):
9078 if not hasattr(self,
'this'):
9080 if isinstance(p, tuple):
9082 self.__dict__.update(d)
9083 return self._set_from_binary(p)
9085 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
9088 _IMP_algebra.UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
9089 class UnboundedGridRange2D(object):
9090 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 2 > class."""
9092 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9094 def __init__(self, *args):
9096 __init__(UnboundedGridRange2D self) -> UnboundedGridRange2D
9097 __init__(UnboundedGridRange2D self, IMP::Ints const & arg2) -> UnboundedGridRange2D
9099 _IMP_algebra.UnboundedGridRange2D_swiginit(self, _IMP_algebra.new_UnboundedGridRange2D(*args))
9101 def set_number_of_voxels(self, arg2):
9102 r"""set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
9103 return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, arg2)
9105 def get_number_of_voxels(self, arg2):
9106 r"""get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
9107 return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, arg2)
9110 def get_is_bounded():
9111 r"""get_is_bounded() -> bool"""
9112 return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
9114 def get_has_index(self, arg2):
9115 r"""get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
9116 return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, arg2)
9118 def show(self, *args):
9119 r"""show(UnboundedGridRange2D self, _ostream out=std::cout)"""
9120 return _IMP_algebra.UnboundedGridRange2D_show(self, *args)
9122 def get_extended_indexes(self, lb, ub):
9123 r"""get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
9124 return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, lb, ub)
9127 r"""__str__(UnboundedGridRange2D self) -> std::string"""
9128 return _IMP_algebra.UnboundedGridRange2D___str__(self)
9131 r"""__repr__(UnboundedGridRange2D self) -> std::string"""
9132 return _IMP_algebra.UnboundedGridRange2D___repr__(self)
9134 def __cmp__(self, arg2):
9135 r"""__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
9136 return _IMP_algebra.UnboundedGridRange2D___cmp__(self, arg2)
9138 def __eq__(self, arg2):
9139 r"""__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
9140 return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)
9142 def _get_as_binary(self):
9143 r"""_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
9144 return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)
9146 def _set_from_binary(self, p):
9147 r"""_set_from_binary(UnboundedGridRange2D self, PyObject * p)"""
9148 return _IMP_algebra.UnboundedGridRange2D__set_from_binary(self, p)
9150 def __getstate__(self):
9151 p = self._get_as_binary()
9152 if len(self.__dict__) > 1:
9153 d = self.__dict__.copy()
9158 def __setstate__(self, p):
9159 if not hasattr(self,
'this'):
9161 if isinstance(p, tuple):
9163 self.__dict__.update(d)
9164 return self._set_from_binary(p)
9166 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
9169 _IMP_algebra.UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
9170 class UnboundedGridRange3D(object):
9171 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 3 > class."""
9173 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9175 def __init__(self, *args):
9177 __init__(UnboundedGridRange3D self) -> UnboundedGridRange3D
9178 __init__(UnboundedGridRange3D self, IMP::Ints const & arg2) -> UnboundedGridRange3D
9180 _IMP_algebra.UnboundedGridRange3D_swiginit(self, _IMP_algebra.new_UnboundedGridRange3D(*args))
9182 def set_number_of_voxels(self, arg2):
9183 r"""set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
9184 return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, arg2)
9186 def get_number_of_voxels(self, arg2):
9187 r"""get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
9188 return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, arg2)
9191 def get_is_bounded():
9192 r"""get_is_bounded() -> bool"""
9193 return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
9195 def get_has_index(self, arg2):
9196 r"""get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
9197 return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, arg2)
9199 def show(self, *args):
9200 r"""show(UnboundedGridRange3D self, _ostream out=std::cout)"""
9201 return _IMP_algebra.UnboundedGridRange3D_show(self, *args)
9203 def get_extended_indexes(self, lb, ub):
9204 r"""get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
9205 return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, lb, ub)
9208 r"""__str__(UnboundedGridRange3D self) -> std::string"""
9209 return _IMP_algebra.UnboundedGridRange3D___str__(self)
9212 r"""__repr__(UnboundedGridRange3D self) -> std::string"""
9213 return _IMP_algebra.UnboundedGridRange3D___repr__(self)
9215 def __cmp__(self, arg2):
9216 r"""__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
9217 return _IMP_algebra.UnboundedGridRange3D___cmp__(self, arg2)
9219 def __eq__(self, arg2):
9220 r"""__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
9221 return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)
9223 def _get_as_binary(self):
9224 r"""_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
9225 return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)
9227 def _set_from_binary(self, p):
9228 r"""_set_from_binary(UnboundedGridRange3D self, PyObject * p)"""
9229 return _IMP_algebra.UnboundedGridRange3D__set_from_binary(self, p)
9231 def __getstate__(self):
9232 p = self._get_as_binary()
9233 if len(self.__dict__) > 1:
9234 d = self.__dict__.copy()
9239 def __setstate__(self, p):
9240 if not hasattr(self,
'this'):
9242 if isinstance(p, tuple):
9244 self.__dict__.update(d)
9245 return self._set_from_binary(p)
9247 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
9250 _IMP_algebra.UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
9251 class UnboundedGridRange4D(object):
9252 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 4 > class."""
9254 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9256 def __init__(self, *args):
9258 __init__(UnboundedGridRange4D self) -> UnboundedGridRange4D
9259 __init__(UnboundedGridRange4D self, IMP::Ints const & arg2) -> UnboundedGridRange4D
9261 _IMP_algebra.UnboundedGridRange4D_swiginit(self, _IMP_algebra.new_UnboundedGridRange4D(*args))
9263 def set_number_of_voxels(self, arg2):
9264 r"""set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
9265 return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, arg2)
9267 def get_number_of_voxels(self, arg2):
9268 r"""get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
9269 return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, arg2)
9272 def get_is_bounded():
9273 r"""get_is_bounded() -> bool"""
9274 return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
9276 def get_has_index(self, arg2):
9277 r"""get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
9278 return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, arg2)
9280 def show(self, *args):
9281 r"""show(UnboundedGridRange4D self, _ostream out=std::cout)"""
9282 return _IMP_algebra.UnboundedGridRange4D_show(self, *args)
9284 def get_extended_indexes(self, lb, ub):
9285 r"""get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
9286 return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, lb, ub)
9289 r"""__str__(UnboundedGridRange4D self) -> std::string"""
9290 return _IMP_algebra.UnboundedGridRange4D___str__(self)
9293 r"""__repr__(UnboundedGridRange4D self) -> std::string"""
9294 return _IMP_algebra.UnboundedGridRange4D___repr__(self)
9296 def __cmp__(self, arg2):
9297 r"""__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
9298 return _IMP_algebra.UnboundedGridRange4D___cmp__(self, arg2)
9300 def __eq__(self, arg2):
9301 r"""__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
9302 return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)
9304 def _get_as_binary(self):
9305 r"""_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
9306 return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)
9308 def _set_from_binary(self, p):
9309 r"""_set_from_binary(UnboundedGridRange4D self, PyObject * p)"""
9310 return _IMP_algebra.UnboundedGridRange4D__set_from_binary(self, p)
9312 def __getstate__(self):
9313 p = self._get_as_binary()
9314 if len(self.__dict__) > 1:
9315 d = self.__dict__.copy()
9320 def __setstate__(self, p):
9321 if not hasattr(self,
'this'):
9323 if isinstance(p, tuple):
9325 self.__dict__.update(d)
9326 return self._set_from_binary(p)
9328 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
9331 _IMP_algebra.UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
9332 class UnboundedGridRange5D(object):
9333 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 5 > class."""
9335 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9337 def __init__(self, *args):
9339 __init__(UnboundedGridRange5D self) -> UnboundedGridRange5D
9340 __init__(UnboundedGridRange5D self, IMP::Ints const & arg2) -> UnboundedGridRange5D
9342 _IMP_algebra.UnboundedGridRange5D_swiginit(self, _IMP_algebra.new_UnboundedGridRange5D(*args))
9344 def set_number_of_voxels(self, arg2):
9345 r"""set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
9346 return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, arg2)
9348 def get_number_of_voxels(self, arg2):
9349 r"""get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
9350 return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, arg2)
9353 def get_is_bounded():
9354 r"""get_is_bounded() -> bool"""
9355 return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
9357 def get_has_index(self, arg2):
9358 r"""get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
9359 return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, arg2)
9361 def show(self, *args):
9362 r"""show(UnboundedGridRange5D self, _ostream out=std::cout)"""
9363 return _IMP_algebra.UnboundedGridRange5D_show(self, *args)
9365 def get_extended_indexes(self, lb, ub):
9366 r"""get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
9367 return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, lb, ub)
9370 r"""__str__(UnboundedGridRange5D self) -> std::string"""
9371 return _IMP_algebra.UnboundedGridRange5D___str__(self)
9374 r"""__repr__(UnboundedGridRange5D self) -> std::string"""
9375 return _IMP_algebra.UnboundedGridRange5D___repr__(self)
9377 def __cmp__(self, arg2):
9378 r"""__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
9379 return _IMP_algebra.UnboundedGridRange5D___cmp__(self, arg2)
9381 def __eq__(self, arg2):
9382 r"""__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
9383 return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)
9385 def _get_as_binary(self):
9386 r"""_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
9387 return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)
9389 def _set_from_binary(self, p):
9390 r"""_set_from_binary(UnboundedGridRange5D self, PyObject * p)"""
9391 return _IMP_algebra.UnboundedGridRange5D__set_from_binary(self, p)
9393 def __getstate__(self):
9394 p = self._get_as_binary()
9395 if len(self.__dict__) > 1:
9396 d = self.__dict__.copy()
9401 def __setstate__(self, p):
9402 if not hasattr(self,
'this'):
9404 if isinstance(p, tuple):
9406 self.__dict__.update(d)
9407 return self._set_from_binary(p)
9409 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
9412 _IMP_algebra.UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
9413 class UnboundedGridRange6D(object):
9414 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 6 > class."""
9416 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9418 def __init__(self, *args):
9420 __init__(UnboundedGridRange6D self) -> UnboundedGridRange6D
9421 __init__(UnboundedGridRange6D self, IMP::Ints const & arg2) -> UnboundedGridRange6D
9423 _IMP_algebra.UnboundedGridRange6D_swiginit(self, _IMP_algebra.new_UnboundedGridRange6D(*args))
9425 def set_number_of_voxels(self, arg2):
9426 r"""set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
9427 return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, arg2)
9429 def get_number_of_voxels(self, arg2):
9430 r"""get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
9431 return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, arg2)
9434 def get_is_bounded():
9435 r"""get_is_bounded() -> bool"""
9436 return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
9438 def get_has_index(self, arg2):
9439 r"""get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
9440 return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, arg2)
9442 def show(self, *args):
9443 r"""show(UnboundedGridRange6D self, _ostream out=std::cout)"""
9444 return _IMP_algebra.UnboundedGridRange6D_show(self, *args)
9446 def get_extended_indexes(self, lb, ub):
9447 r"""get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
9448 return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, lb, ub)
9451 r"""__str__(UnboundedGridRange6D self) -> std::string"""
9452 return _IMP_algebra.UnboundedGridRange6D___str__(self)
9455 r"""__repr__(UnboundedGridRange6D self) -> std::string"""
9456 return _IMP_algebra.UnboundedGridRange6D___repr__(self)
9458 def __cmp__(self, arg2):
9459 r"""__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
9460 return _IMP_algebra.UnboundedGridRange6D___cmp__(self, arg2)
9462 def __eq__(self, arg2):
9463 r"""__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
9464 return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)
9466 def _get_as_binary(self):
9467 r"""_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
9468 return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)
9470 def _set_from_binary(self, p):
9471 r"""_set_from_binary(UnboundedGridRange6D self, PyObject * p)"""
9472 return _IMP_algebra.UnboundedGridRange6D__set_from_binary(self, p)
9474 def __getstate__(self):
9475 p = self._get_as_binary()
9476 if len(self.__dict__) > 1:
9477 d = self.__dict__.copy()
9482 def __setstate__(self, p):
9483 if not hasattr(self,
'this'):
9485 if isinstance(p, tuple):
9487 self.__dict__.update(d)
9488 return self._set_from_binary(p)
9490 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
9493 _IMP_algebra.UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
9494 class UnboundedGridRangeKD(object):
9495 r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< -1 > class."""
9497 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9499 def __init__(self, *args):
9501 __init__(UnboundedGridRangeKD self) -> UnboundedGridRangeKD
9502 __init__(UnboundedGridRangeKD self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
9504 _IMP_algebra.UnboundedGridRangeKD_swiginit(self, _IMP_algebra.new_UnboundedGridRangeKD(*args))
9506 def set_number_of_voxels(self, arg2):
9507 r"""set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
9508 return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, arg2)
9510 def get_number_of_voxels(self, arg2):
9511 r"""get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
9512 return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, arg2)
9515 def get_is_bounded():
9516 r"""get_is_bounded() -> bool"""
9517 return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
9519 def get_has_index(self, arg2):
9520 r"""get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
9521 return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, arg2)
9523 def show(self, *args):
9524 r"""show(UnboundedGridRangeKD self, _ostream out=std::cout)"""
9525 return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)
9527 def get_extended_indexes(self, lb, ub):
9528 r"""get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
9529 return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, lb, ub)
9532 r"""__str__(UnboundedGridRangeKD self) -> std::string"""
9533 return _IMP_algebra.UnboundedGridRangeKD___str__(self)
9536 r"""__repr__(UnboundedGridRangeKD self) -> std::string"""
9537 return _IMP_algebra.UnboundedGridRangeKD___repr__(self)
9539 def __cmp__(self, arg2):
9540 r"""__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
9541 return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, arg2)
9543 def __eq__(self, arg2):
9544 r"""__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
9545 return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)
9547 def _get_as_binary(self):
9548 r"""_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
9549 return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)
9551 def _set_from_binary(self, p):
9552 r"""_set_from_binary(UnboundedGridRangeKD self, PyObject * p)"""
9553 return _IMP_algebra.UnboundedGridRangeKD__set_from_binary(self, p)
9555 def __getstate__(self):
9556 p = self._get_as_binary()
9557 if len(self.__dict__) > 1:
9558 d = self.__dict__.copy()
9563 def __setstate__(self, p):
9564 if not hasattr(self,
'this'):
9566 if isinstance(p, tuple):
9568 self.__dict__.update(d)
9569 return self._set_from_binary(p)
9571 __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
9574 _IMP_algebra.UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
9575 class DefaultEmbedding1D(object):
9576 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 1 > class."""
9578 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9580 def __init__(self, *args):
9582 __init__(DefaultEmbedding1D self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
9583 __init__(DefaultEmbedding1D self) -> DefaultEmbedding1D
9585 _IMP_algebra.DefaultEmbedding1D_swiginit(self, _IMP_algebra.new_DefaultEmbedding1D(*args))
9587 def set_origin(self, o):
9588 r"""set_origin(DefaultEmbedding1D self, Vector1D o)"""
9589 return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)
9591 def get_origin(self):
9592 r"""get_origin(DefaultEmbedding1D self) -> Vector1D"""
9593 return _IMP_algebra.DefaultEmbedding1D_get_origin(self)
9595 def get_dimension(self):
9596 r"""get_dimension(DefaultEmbedding1D self) -> unsigned int"""
9597 return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)
9599 def set_unit_cell(self, o):
9600 r"""set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
9601 return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, o)
9603 def get_inverse_unit_cell(self):
9604 r"""get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9605 return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)
9607 def get_unit_cell(self):
9608 r"""get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9609 return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)
9611 def get_extended_index(self, o):
9612 r"""get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
9613 return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, o)
9616 r"""get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
9617 return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)
9619 def get_center(self, *args):
9621 get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
9622 get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
9624 return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)
9626 def get_bounding_box(self, *args):
9628 get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
9629 get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
9631 return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)
9633 def show(self, *args):
9634 r"""show(DefaultEmbedding1D self, _ostream out=std::cout)"""
9635 return _IMP_algebra.DefaultEmbedding1D_show(self, *args)
9638 r"""__str__(DefaultEmbedding1D self) -> std::string"""
9639 return _IMP_algebra.DefaultEmbedding1D___str__(self)
9642 r"""__repr__(DefaultEmbedding1D self) -> std::string"""
9643 return _IMP_algebra.DefaultEmbedding1D___repr__(self)
9645 def __cmp__(self, arg2):
9646 r"""__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
9647 return _IMP_algebra.DefaultEmbedding1D___cmp__(self, arg2)
9649 def __eq__(self, arg2):
9650 r"""__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
9651 return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)
9653 def _get_as_binary(self):
9654 r"""_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
9655 return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)
9657 def _set_from_binary(self, p):
9658 r"""_set_from_binary(DefaultEmbedding1D self, PyObject * p)"""
9659 return _IMP_algebra.DefaultEmbedding1D__set_from_binary(self, p)
9661 def __getstate__(self):
9662 p = self._get_as_binary()
9663 if len(self.__dict__) > 1:
9664 d = self.__dict__.copy()
9669 def __setstate__(self, p):
9670 if not hasattr(self,
'this'):
9672 if isinstance(p, tuple):
9674 self.__dict__.update(d)
9675 return self._set_from_binary(p)
9677 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
9680 _IMP_algebra.DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
9681 class DefaultEmbedding2D(object):
9682 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 2 > class."""
9684 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9686 def __init__(self, *args):
9688 __init__(DefaultEmbedding2D self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
9689 __init__(DefaultEmbedding2D self) -> DefaultEmbedding2D
9691 _IMP_algebra.DefaultEmbedding2D_swiginit(self, _IMP_algebra.new_DefaultEmbedding2D(*args))
9693 def set_origin(self, o):
9694 r"""set_origin(DefaultEmbedding2D self, Vector2D o)"""
9695 return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)
9697 def get_origin(self):
9698 r"""get_origin(DefaultEmbedding2D self) -> Vector2D"""
9699 return _IMP_algebra.DefaultEmbedding2D_get_origin(self)
9701 def get_dimension(self):
9702 r"""get_dimension(DefaultEmbedding2D self) -> unsigned int"""
9703 return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)
9705 def set_unit_cell(self, o):
9706 r"""set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
9707 return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, o)
9709 def get_inverse_unit_cell(self):
9710 r"""get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9711 return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)
9713 def get_unit_cell(self):
9714 r"""get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9715 return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)
9717 def get_extended_index(self, o):
9718 r"""get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
9719 return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, o)
9722 r"""get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
9723 return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)
9725 def get_center(self, *args):
9727 get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
9728 get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
9730 return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)
9732 def get_bounding_box(self, *args):
9734 get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
9735 get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
9737 return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)
9739 def show(self, *args):
9740 r"""show(DefaultEmbedding2D self, _ostream out=std::cout)"""
9741 return _IMP_algebra.DefaultEmbedding2D_show(self, *args)
9744 r"""__str__(DefaultEmbedding2D self) -> std::string"""
9745 return _IMP_algebra.DefaultEmbedding2D___str__(self)
9748 r"""__repr__(DefaultEmbedding2D self) -> std::string"""
9749 return _IMP_algebra.DefaultEmbedding2D___repr__(self)
9751 def __cmp__(self, arg2):
9752 r"""__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
9753 return _IMP_algebra.DefaultEmbedding2D___cmp__(self, arg2)
9755 def __eq__(self, arg2):
9756 r"""__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
9757 return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)
9759 def _get_as_binary(self):
9760 r"""_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
9761 return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)
9763 def _set_from_binary(self, p):
9764 r"""_set_from_binary(DefaultEmbedding2D self, PyObject * p)"""
9765 return _IMP_algebra.DefaultEmbedding2D__set_from_binary(self, p)
9767 def __getstate__(self):
9768 p = self._get_as_binary()
9769 if len(self.__dict__) > 1:
9770 d = self.__dict__.copy()
9775 def __setstate__(self, p):
9776 if not hasattr(self,
'this'):
9778 if isinstance(p, tuple):
9780 self.__dict__.update(d)
9781 return self._set_from_binary(p)
9783 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
9786 _IMP_algebra.DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
9787 class DefaultEmbedding3D(object):
9788 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 3 > class."""
9790 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9792 def __init__(self, *args):
9794 __init__(DefaultEmbedding3D self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
9795 __init__(DefaultEmbedding3D self) -> DefaultEmbedding3D
9797 _IMP_algebra.DefaultEmbedding3D_swiginit(self, _IMP_algebra.new_DefaultEmbedding3D(*args))
9799 def set_origin(self, o):
9800 r"""set_origin(DefaultEmbedding3D self, Vector3D o)"""
9801 return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)
9803 def get_origin(self):
9804 r"""get_origin(DefaultEmbedding3D self) -> Vector3D"""
9805 return _IMP_algebra.DefaultEmbedding3D_get_origin(self)
9807 def get_dimension(self):
9808 r"""get_dimension(DefaultEmbedding3D self) -> unsigned int"""
9809 return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)
9811 def set_unit_cell(self, o):
9812 r"""set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
9813 return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, o)
9815 def get_inverse_unit_cell(self):
9816 r"""get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9817 return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)
9819 def get_unit_cell(self):
9820 r"""get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9821 return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)
9823 def get_extended_index(self, o):
9824 r"""get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
9825 return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, o)
9828 r"""get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
9829 return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)
9831 def get_center(self, *args):
9833 get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
9834 get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
9836 return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)
9838 def get_bounding_box(self, *args):
9840 get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
9841 get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
9843 return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)
9845 def show(self, *args):
9846 r"""show(DefaultEmbedding3D self, _ostream out=std::cout)"""
9847 return _IMP_algebra.DefaultEmbedding3D_show(self, *args)
9850 r"""__str__(DefaultEmbedding3D self) -> std::string"""
9851 return _IMP_algebra.DefaultEmbedding3D___str__(self)
9854 r"""__repr__(DefaultEmbedding3D self) -> std::string"""
9855 return _IMP_algebra.DefaultEmbedding3D___repr__(self)
9857 def __cmp__(self, arg2):
9858 r"""__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
9859 return _IMP_algebra.DefaultEmbedding3D___cmp__(self, arg2)
9861 def __eq__(self, arg2):
9862 r"""__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
9863 return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)
9865 def _get_as_binary(self):
9866 r"""_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
9867 return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)
9869 def _set_from_binary(self, p):
9870 r"""_set_from_binary(DefaultEmbedding3D self, PyObject * p)"""
9871 return _IMP_algebra.DefaultEmbedding3D__set_from_binary(self, p)
9873 def __getstate__(self):
9874 p = self._get_as_binary()
9875 if len(self.__dict__) > 1:
9876 d = self.__dict__.copy()
9881 def __setstate__(self, p):
9882 if not hasattr(self,
'this'):
9884 if isinstance(p, tuple):
9886 self.__dict__.update(d)
9887 return self._set_from_binary(p)
9889 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
9892 _IMP_algebra.DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
9893 class DefaultEmbedding4D(object):
9894 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 4 > class."""
9896 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
9898 def __init__(self, *args):
9900 __init__(DefaultEmbedding4D self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
9901 __init__(DefaultEmbedding4D self) -> DefaultEmbedding4D
9903 _IMP_algebra.DefaultEmbedding4D_swiginit(self, _IMP_algebra.new_DefaultEmbedding4D(*args))
9905 def set_origin(self, o):
9906 r"""set_origin(DefaultEmbedding4D self, Vector4D o)"""
9907 return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)
9909 def get_origin(self):
9910 r"""get_origin(DefaultEmbedding4D self) -> Vector4D"""
9911 return _IMP_algebra.DefaultEmbedding4D_get_origin(self)
9913 def get_dimension(self):
9914 r"""get_dimension(DefaultEmbedding4D self) -> unsigned int"""
9915 return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)
9917 def set_unit_cell(self, o):
9918 r"""set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
9919 return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, o)
9921 def get_inverse_unit_cell(self):
9922 r"""get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9923 return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)
9925 def get_unit_cell(self):
9926 r"""get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9927 return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)
9929 def get_extended_index(self, o):
9930 r"""get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
9931 return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, o)
9934 r"""get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
9935 return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)
9937 def get_center(self, *args):
9939 get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
9940 get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
9942 return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)
9944 def get_bounding_box(self, *args):
9946 get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
9947 get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
9949 return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)
9951 def show(self, *args):
9952 r"""show(DefaultEmbedding4D self, _ostream out=std::cout)"""
9953 return _IMP_algebra.DefaultEmbedding4D_show(self, *args)
9956 r"""__str__(DefaultEmbedding4D self) -> std::string"""
9957 return _IMP_algebra.DefaultEmbedding4D___str__(self)
9960 r"""__repr__(DefaultEmbedding4D self) -> std::string"""
9961 return _IMP_algebra.DefaultEmbedding4D___repr__(self)
9963 def __cmp__(self, arg2):
9964 r"""__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
9965 return _IMP_algebra.DefaultEmbedding4D___cmp__(self, arg2)
9967 def __eq__(self, arg2):
9968 r"""__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
9969 return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)
9971 def _get_as_binary(self):
9972 r"""_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
9973 return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)
9975 def _set_from_binary(self, p):
9976 r"""_set_from_binary(DefaultEmbedding4D self, PyObject * p)"""
9977 return _IMP_algebra.DefaultEmbedding4D__set_from_binary(self, p)
9979 def __getstate__(self):
9980 p = self._get_as_binary()
9981 if len(self.__dict__) > 1:
9982 d = self.__dict__.copy()
9987 def __setstate__(self, p):
9988 if not hasattr(self,
'this'):
9990 if isinstance(p, tuple):
9992 self.__dict__.update(d)
9993 return self._set_from_binary(p)
9995 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
9998 _IMP_algebra.DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
9999 class DefaultEmbedding5D(object):
10000 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 5 > class."""
10002 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10004 def __init__(self, *args):
10006 __init__(DefaultEmbedding5D self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
10007 __init__(DefaultEmbedding5D self) -> DefaultEmbedding5D
10009 _IMP_algebra.DefaultEmbedding5D_swiginit(self, _IMP_algebra.new_DefaultEmbedding5D(*args))
10011 def set_origin(self, o):
10012 r"""set_origin(DefaultEmbedding5D self, Vector5D o)"""
10013 return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)
10015 def get_origin(self):
10016 r"""get_origin(DefaultEmbedding5D self) -> Vector5D"""
10017 return _IMP_algebra.DefaultEmbedding5D_get_origin(self)
10019 def get_dimension(self):
10020 r"""get_dimension(DefaultEmbedding5D self) -> unsigned int"""
10021 return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)
10023 def set_unit_cell(self, o):
10024 r"""set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
10025 return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, o)
10027 def get_inverse_unit_cell(self):
10028 r"""get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10029 return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)
10031 def get_unit_cell(self):
10032 r"""get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10033 return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)
10035 def get_extended_index(self, o):
10036 r"""get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10037 return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, o)
10040 r"""get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
10041 return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)
10043 def get_center(self, *args):
10045 get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10046 get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
10048 return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)
10050 def get_bounding_box(self, *args):
10052 get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10053 get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10055 return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)
10057 def show(self, *args):
10058 r"""show(DefaultEmbedding5D self, _ostream out=std::cout)"""
10059 return _IMP_algebra.DefaultEmbedding5D_show(self, *args)
10062 r"""__str__(DefaultEmbedding5D self) -> std::string"""
10063 return _IMP_algebra.DefaultEmbedding5D___str__(self)
10065 def __repr__(self):
10066 r"""__repr__(DefaultEmbedding5D self) -> std::string"""
10067 return _IMP_algebra.DefaultEmbedding5D___repr__(self)
10069 def __cmp__(self, arg2):
10070 r"""__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
10071 return _IMP_algebra.DefaultEmbedding5D___cmp__(self, arg2)
10073 def __eq__(self, arg2):
10074 r"""__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
10075 return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)
10077 def _get_as_binary(self):
10078 r"""_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
10079 return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)
10081 def _set_from_binary(self, p):
10082 r"""_set_from_binary(DefaultEmbedding5D self, PyObject * p)"""
10083 return _IMP_algebra.DefaultEmbedding5D__set_from_binary(self, p)
10085 def __getstate__(self):
10086 p = self._get_as_binary()
10087 if len(self.__dict__) > 1:
10088 d = self.__dict__.copy()
10093 def __setstate__(self, p):
10094 if not hasattr(self,
'this'):
10096 if isinstance(p, tuple):
10098 self.__dict__.update(d)
10099 return self._set_from_binary(p)
10101 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
10104 _IMP_algebra.DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
10105 class DefaultEmbedding6D(object):
10106 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 6 > class."""
10108 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10110 def __init__(self, *args):
10112 __init__(DefaultEmbedding6D self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
10113 __init__(DefaultEmbedding6D self) -> DefaultEmbedding6D
10115 _IMP_algebra.DefaultEmbedding6D_swiginit(self, _IMP_algebra.new_DefaultEmbedding6D(*args))
10117 def set_origin(self, o):
10118 r"""set_origin(DefaultEmbedding6D self, Vector6D o)"""
10119 return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)
10121 def get_origin(self):
10122 r"""get_origin(DefaultEmbedding6D self) -> Vector6D"""
10123 return _IMP_algebra.DefaultEmbedding6D_get_origin(self)
10125 def get_dimension(self):
10126 r"""get_dimension(DefaultEmbedding6D self) -> unsigned int"""
10127 return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)
10129 def set_unit_cell(self, o):
10130 r"""set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
10131 return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, o)
10133 def get_inverse_unit_cell(self):
10134 r"""get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10135 return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)
10137 def get_unit_cell(self):
10138 r"""get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10139 return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)
10141 def get_extended_index(self, o):
10142 r"""get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10143 return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, o)
10146 r"""get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
10147 return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)
10149 def get_center(self, *args):
10151 get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10152 get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
10154 return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)
10156 def get_bounding_box(self, *args):
10158 get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10159 get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10161 return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)
10163 def show(self, *args):
10164 r"""show(DefaultEmbedding6D self, _ostream out=std::cout)"""
10165 return _IMP_algebra.DefaultEmbedding6D_show(self, *args)
10168 r"""__str__(DefaultEmbedding6D self) -> std::string"""
10169 return _IMP_algebra.DefaultEmbedding6D___str__(self)
10171 def __repr__(self):
10172 r"""__repr__(DefaultEmbedding6D self) -> std::string"""
10173 return _IMP_algebra.DefaultEmbedding6D___repr__(self)
10175 def __cmp__(self, arg2):
10176 r"""__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
10177 return _IMP_algebra.DefaultEmbedding6D___cmp__(self, arg2)
10179 def __eq__(self, arg2):
10180 r"""__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
10181 return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)
10183 def _get_as_binary(self):
10184 r"""_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
10185 return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)
10187 def _set_from_binary(self, p):
10188 r"""_set_from_binary(DefaultEmbedding6D self, PyObject * p)"""
10189 return _IMP_algebra.DefaultEmbedding6D__set_from_binary(self, p)
10191 def __getstate__(self):
10192 p = self._get_as_binary()
10193 if len(self.__dict__) > 1:
10194 d = self.__dict__.copy()
10199 def __setstate__(self, p):
10200 if not hasattr(self,
'this'):
10202 if isinstance(p, tuple):
10204 self.__dict__.update(d)
10205 return self._set_from_binary(p)
10207 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
10210 _IMP_algebra.DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
10211 class DefaultEmbeddingKD(object):
10212 r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< -1 > class."""
10214 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10216 def __init__(self, *args):
10218 __init__(DefaultEmbeddingKD self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
10219 __init__(DefaultEmbeddingKD self) -> DefaultEmbeddingKD
10221 _IMP_algebra.DefaultEmbeddingKD_swiginit(self, _IMP_algebra.new_DefaultEmbeddingKD(*args))
10223 def set_origin(self, o):
10224 r"""set_origin(DefaultEmbeddingKD self, VectorKD o)"""
10225 return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)
10227 def get_origin(self):
10228 r"""get_origin(DefaultEmbeddingKD self) -> VectorKD"""
10229 return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)
10231 def get_dimension(self):
10232 r"""get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
10233 return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)
10235 def set_unit_cell(self, o):
10236 r"""set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
10237 return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, o)
10239 def get_inverse_unit_cell(self):
10240 r"""get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10241 return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)
10243 def get_unit_cell(self):
10244 r"""get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10245 return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)
10247 def get_extended_index(self, o):
10248 r"""get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
10249 return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, o)
10252 r"""get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
10253 return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)
10255 def get_center(self, *args):
10257 get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
10258 get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
10260 return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)
10262 def get_bounding_box(self, *args):
10264 get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
10265 get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
10267 return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)
10269 def show(self, *args):
10270 r"""show(DefaultEmbeddingKD self, _ostream out=std::cout)"""
10271 return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)
10274 r"""__str__(DefaultEmbeddingKD self) -> std::string"""
10275 return _IMP_algebra.DefaultEmbeddingKD___str__(self)
10277 def __repr__(self):
10278 r"""__repr__(DefaultEmbeddingKD self) -> std::string"""
10279 return _IMP_algebra.DefaultEmbeddingKD___repr__(self)
10281 def __cmp__(self, arg2):
10282 r"""__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
10283 return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, arg2)
10285 def __eq__(self, arg2):
10286 r"""__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
10287 return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)
10289 def _get_as_binary(self):
10290 r"""_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
10291 return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)
10293 def _set_from_binary(self, p):
10294 r"""_set_from_binary(DefaultEmbeddingKD self, PyObject * p)"""
10295 return _IMP_algebra.DefaultEmbeddingKD__set_from_binary(self, p)
10297 def __getstate__(self):
10298 p = self._get_as_binary()
10299 if len(self.__dict__) > 1:
10300 d = self.__dict__.copy()
10305 def __setstate__(self, p):
10306 if not hasattr(self,
'this'):
10308 if isinstance(p, tuple):
10310 self.__dict__.update(d)
10311 return self._set_from_binary(p)
10313 __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
10316 _IMP_algebra.DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
10317 class LogEmbedding1D(object):
10318 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 1 > class."""
10320 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10322 def __init__(self, *args):
10324 __init__(LogEmbedding1D self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
10325 __init__(LogEmbedding1D self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
10326 __init__(LogEmbedding1D self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
10327 __init__(LogEmbedding1D self) -> LogEmbedding1D
10329 _IMP_algebra.LogEmbedding1D_swiginit(self, _IMP_algebra.new_LogEmbedding1D(*args))
10331 def set_origin(self, o):
10332 r"""set_origin(LogEmbedding1D self, Vector1D o)"""
10333 return _IMP_algebra.LogEmbedding1D_set_origin(self, o)
10335 def get_origin(self):
10336 r"""get_origin(LogEmbedding1D self) -> Vector1D"""
10337 return _IMP_algebra.LogEmbedding1D_get_origin(self)
10339 def get_dimension(self):
10340 r"""get_dimension(LogEmbedding1D self) -> unsigned int"""
10341 return _IMP_algebra.LogEmbedding1D_get_dimension(self)
10343 def set_unit_cell(self, *args):
10345 set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
10346 set_unit_cell(LogEmbedding1D self, Vector1D o)
10348 return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)
10350 def get_unit_cell(self):
10351 r"""get_unit_cell(LogEmbedding1D self) -> Vector1D"""
10352 return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)
10354 def get_extended_index(self, o):
10355 r"""get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
10356 return _IMP_algebra.LogEmbedding1D_get_extended_index(self, o)
10359 r"""get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
10360 return _IMP_algebra.LogEmbedding1D_get_index(self, o)
10362 def get_center(self, *args):
10364 get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
10365 get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
10367 return _IMP_algebra.LogEmbedding1D_get_center(self, *args)
10369 def get_bounding_box(self, *args):
10371 get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
10372 get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
10374 return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)
10376 def show(self, *args):
10377 r"""show(LogEmbedding1D self, _ostream out=std::cout)"""
10378 return _IMP_algebra.LogEmbedding1D_show(self, *args)
10381 r"""__str__(LogEmbedding1D self) -> std::string"""
10382 return _IMP_algebra.LogEmbedding1D___str__(self)
10384 def __repr__(self):
10385 r"""__repr__(LogEmbedding1D self) -> std::string"""
10386 return _IMP_algebra.LogEmbedding1D___repr__(self)
10388 def __cmp__(self, arg2):
10389 r"""__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
10390 return _IMP_algebra.LogEmbedding1D___cmp__(self, arg2)
10392 def __eq__(self, arg2):
10393 r"""__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
10394 return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)
10396 def _get_as_binary(self):
10397 r"""_get_as_binary(LogEmbedding1D self) -> PyObject *"""
10398 return _IMP_algebra.LogEmbedding1D__get_as_binary(self)
10400 def _set_from_binary(self, p):
10401 r"""_set_from_binary(LogEmbedding1D self, PyObject * p)"""
10402 return _IMP_algebra.LogEmbedding1D__set_from_binary(self, p)
10404 def __getstate__(self):
10405 p = self._get_as_binary()
10406 if len(self.__dict__) > 1:
10407 d = self.__dict__.copy()
10412 def __setstate__(self, p):
10413 if not hasattr(self,
'this'):
10415 if isinstance(p, tuple):
10417 self.__dict__.update(d)
10418 return self._set_from_binary(p)
10420 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
10423 _IMP_algebra.LogEmbedding1D_swigregister(LogEmbedding1D)
10424 class LogEmbedding2D(object):
10425 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 2 > class."""
10427 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10429 def __init__(self, *args):
10431 __init__(LogEmbedding2D self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
10432 __init__(LogEmbedding2D self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
10433 __init__(LogEmbedding2D self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
10434 __init__(LogEmbedding2D self) -> LogEmbedding2D
10436 _IMP_algebra.LogEmbedding2D_swiginit(self, _IMP_algebra.new_LogEmbedding2D(*args))
10438 def set_origin(self, o):
10439 r"""set_origin(LogEmbedding2D self, Vector2D o)"""
10440 return _IMP_algebra.LogEmbedding2D_set_origin(self, o)
10442 def get_origin(self):
10443 r"""get_origin(LogEmbedding2D self) -> Vector2D"""
10444 return _IMP_algebra.LogEmbedding2D_get_origin(self)
10446 def get_dimension(self):
10447 r"""get_dimension(LogEmbedding2D self) -> unsigned int"""
10448 return _IMP_algebra.LogEmbedding2D_get_dimension(self)
10450 def set_unit_cell(self, *args):
10452 set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
10453 set_unit_cell(LogEmbedding2D self, Vector2D o)
10455 return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)
10457 def get_unit_cell(self):
10458 r"""get_unit_cell(LogEmbedding2D self) -> Vector2D"""
10459 return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)
10461 def get_extended_index(self, o):
10462 r"""get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
10463 return _IMP_algebra.LogEmbedding2D_get_extended_index(self, o)
10466 r"""get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
10467 return _IMP_algebra.LogEmbedding2D_get_index(self, o)
10469 def get_center(self, *args):
10471 get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
10472 get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
10474 return _IMP_algebra.LogEmbedding2D_get_center(self, *args)
10476 def get_bounding_box(self, *args):
10478 get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
10479 get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
10481 return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)
10483 def show(self, *args):
10484 r"""show(LogEmbedding2D self, _ostream out=std::cout)"""
10485 return _IMP_algebra.LogEmbedding2D_show(self, *args)
10488 r"""__str__(LogEmbedding2D self) -> std::string"""
10489 return _IMP_algebra.LogEmbedding2D___str__(self)
10491 def __repr__(self):
10492 r"""__repr__(LogEmbedding2D self) -> std::string"""
10493 return _IMP_algebra.LogEmbedding2D___repr__(self)
10495 def __cmp__(self, arg2):
10496 r"""__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
10497 return _IMP_algebra.LogEmbedding2D___cmp__(self, arg2)
10499 def __eq__(self, arg2):
10500 r"""__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
10501 return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)
10503 def _get_as_binary(self):
10504 r"""_get_as_binary(LogEmbedding2D self) -> PyObject *"""
10505 return _IMP_algebra.LogEmbedding2D__get_as_binary(self)
10507 def _set_from_binary(self, p):
10508 r"""_set_from_binary(LogEmbedding2D self, PyObject * p)"""
10509 return _IMP_algebra.LogEmbedding2D__set_from_binary(self, p)
10511 def __getstate__(self):
10512 p = self._get_as_binary()
10513 if len(self.__dict__) > 1:
10514 d = self.__dict__.copy()
10519 def __setstate__(self, p):
10520 if not hasattr(self,
'this'):
10522 if isinstance(p, tuple):
10524 self.__dict__.update(d)
10525 return self._set_from_binary(p)
10527 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
10530 _IMP_algebra.LogEmbedding2D_swigregister(LogEmbedding2D)
10531 class LogEmbedding4D(object):
10532 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 4 > class."""
10534 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10536 def __init__(self, *args):
10538 __init__(LogEmbedding4D self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
10539 __init__(LogEmbedding4D self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
10540 __init__(LogEmbedding4D self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
10541 __init__(LogEmbedding4D self) -> LogEmbedding4D
10543 _IMP_algebra.LogEmbedding4D_swiginit(self, _IMP_algebra.new_LogEmbedding4D(*args))
10545 def set_origin(self, o):
10546 r"""set_origin(LogEmbedding4D self, Vector4D o)"""
10547 return _IMP_algebra.LogEmbedding4D_set_origin(self, o)
10549 def get_origin(self):
10550 r"""get_origin(LogEmbedding4D self) -> Vector4D"""
10551 return _IMP_algebra.LogEmbedding4D_get_origin(self)
10553 def get_dimension(self):
10554 r"""get_dimension(LogEmbedding4D self) -> unsigned int"""
10555 return _IMP_algebra.LogEmbedding4D_get_dimension(self)
10557 def set_unit_cell(self, *args):
10559 set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
10560 set_unit_cell(LogEmbedding4D self, Vector4D o)
10562 return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)
10564 def get_unit_cell(self):
10565 r"""get_unit_cell(LogEmbedding4D self) -> Vector4D"""
10566 return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)
10568 def get_extended_index(self, o):
10569 r"""get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
10570 return _IMP_algebra.LogEmbedding4D_get_extended_index(self, o)
10573 r"""get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
10574 return _IMP_algebra.LogEmbedding4D_get_index(self, o)
10576 def get_center(self, *args):
10578 get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
10579 get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
10581 return _IMP_algebra.LogEmbedding4D_get_center(self, *args)
10583 def get_bounding_box(self, *args):
10585 get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
10586 get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
10588 return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)
10590 def show(self, *args):
10591 r"""show(LogEmbedding4D self, _ostream out=std::cout)"""
10592 return _IMP_algebra.LogEmbedding4D_show(self, *args)
10595 r"""__str__(LogEmbedding4D self) -> std::string"""
10596 return _IMP_algebra.LogEmbedding4D___str__(self)
10598 def __repr__(self):
10599 r"""__repr__(LogEmbedding4D self) -> std::string"""
10600 return _IMP_algebra.LogEmbedding4D___repr__(self)
10602 def __cmp__(self, arg2):
10603 r"""__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
10604 return _IMP_algebra.LogEmbedding4D___cmp__(self, arg2)
10606 def __eq__(self, arg2):
10607 r"""__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
10608 return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)
10610 def _get_as_binary(self):
10611 r"""_get_as_binary(LogEmbedding4D self) -> PyObject *"""
10612 return _IMP_algebra.LogEmbedding4D__get_as_binary(self)
10614 def _set_from_binary(self, p):
10615 r"""_set_from_binary(LogEmbedding4D self, PyObject * p)"""
10616 return _IMP_algebra.LogEmbedding4D__set_from_binary(self, p)
10618 def __getstate__(self):
10619 p = self._get_as_binary()
10620 if len(self.__dict__) > 1:
10621 d = self.__dict__.copy()
10626 def __setstate__(self, p):
10627 if not hasattr(self,
'this'):
10629 if isinstance(p, tuple):
10631 self.__dict__.update(d)
10632 return self._set_from_binary(p)
10634 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
10637 _IMP_algebra.LogEmbedding4D_swigregister(LogEmbedding4D)
10638 class LogEmbedding5D(object):
10639 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 5 > class."""
10641 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10643 def __init__(self, *args):
10645 __init__(LogEmbedding5D self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
10646 __init__(LogEmbedding5D self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
10647 __init__(LogEmbedding5D self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
10648 __init__(LogEmbedding5D self) -> LogEmbedding5D
10650 _IMP_algebra.LogEmbedding5D_swiginit(self, _IMP_algebra.new_LogEmbedding5D(*args))
10652 def set_origin(self, o):
10653 r"""set_origin(LogEmbedding5D self, Vector5D o)"""
10654 return _IMP_algebra.LogEmbedding5D_set_origin(self, o)
10656 def get_origin(self):
10657 r"""get_origin(LogEmbedding5D self) -> Vector5D"""
10658 return _IMP_algebra.LogEmbedding5D_get_origin(self)
10660 def get_dimension(self):
10661 r"""get_dimension(LogEmbedding5D self) -> unsigned int"""
10662 return _IMP_algebra.LogEmbedding5D_get_dimension(self)
10664 def set_unit_cell(self, *args):
10666 set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
10667 set_unit_cell(LogEmbedding5D self, Vector5D o)
10669 return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)
10671 def get_unit_cell(self):
10672 r"""get_unit_cell(LogEmbedding5D self) -> Vector5D"""
10673 return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)
10675 def get_extended_index(self, o):
10676 r"""get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10677 return _IMP_algebra.LogEmbedding5D_get_extended_index(self, o)
10680 r"""get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
10681 return _IMP_algebra.LogEmbedding5D_get_index(self, o)
10683 def get_center(self, *args):
10685 get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10686 get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
10688 return _IMP_algebra.LogEmbedding5D_get_center(self, *args)
10690 def get_bounding_box(self, *args):
10692 get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10693 get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10695 return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)
10697 def show(self, *args):
10698 r"""show(LogEmbedding5D self, _ostream out=std::cout)"""
10699 return _IMP_algebra.LogEmbedding5D_show(self, *args)
10702 r"""__str__(LogEmbedding5D self) -> std::string"""
10703 return _IMP_algebra.LogEmbedding5D___str__(self)
10705 def __repr__(self):
10706 r"""__repr__(LogEmbedding5D self) -> std::string"""
10707 return _IMP_algebra.LogEmbedding5D___repr__(self)
10709 def __cmp__(self, arg2):
10710 r"""__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
10711 return _IMP_algebra.LogEmbedding5D___cmp__(self, arg2)
10713 def __eq__(self, arg2):
10714 r"""__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
10715 return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)
10717 def _get_as_binary(self):
10718 r"""_get_as_binary(LogEmbedding5D self) -> PyObject *"""
10719 return _IMP_algebra.LogEmbedding5D__get_as_binary(self)
10721 def _set_from_binary(self, p):
10722 r"""_set_from_binary(LogEmbedding5D self, PyObject * p)"""
10723 return _IMP_algebra.LogEmbedding5D__set_from_binary(self, p)
10725 def __getstate__(self):
10726 p = self._get_as_binary()
10727 if len(self.__dict__) > 1:
10728 d = self.__dict__.copy()
10733 def __setstate__(self, p):
10734 if not hasattr(self,
'this'):
10736 if isinstance(p, tuple):
10738 self.__dict__.update(d)
10739 return self._set_from_binary(p)
10741 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
10744 _IMP_algebra.LogEmbedding5D_swigregister(LogEmbedding5D)
10745 class LogEmbedding6D(object):
10746 r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 6 > class."""
10748 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10750 def __init__(self, *args):
10752 __init__(LogEmbedding6D self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
10753 __init__(LogEmbedding6D self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
10754 __init__(LogEmbedding6D self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
10755 __init__(LogEmbedding6D self) -> LogEmbedding6D
10757 _IMP_algebra.LogEmbedding6D_swiginit(self, _IMP_algebra.new_LogEmbedding6D(*args))
10759 def set_origin(self, o):
10760 r"""set_origin(LogEmbedding6D self, Vector6D o)"""
10761 return _IMP_algebra.LogEmbedding6D_set_origin(self, o)
10763 def get_origin(self):
10764 r"""get_origin(LogEmbedding6D self) -> Vector6D"""
10765 return _IMP_algebra.LogEmbedding6D_get_origin(self)
10767 def get_dimension(self):
10768 r"""get_dimension(LogEmbedding6D self) -> unsigned int"""
10769 return _IMP_algebra.LogEmbedding6D_get_dimension(self)
10771 def set_unit_cell(self, *args):
10773 set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
10774 set_unit_cell(LogEmbedding6D self, Vector6D o)
10776 return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)
10778 def get_unit_cell(self):
10779 r"""get_unit_cell(LogEmbedding6D self) -> Vector6D"""
10780 return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)
10782 def get_extended_index(self, o):
10783 r"""get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10784 return _IMP_algebra.LogEmbedding6D_get_extended_index(self, o)
10787 r"""get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
10788 return _IMP_algebra.LogEmbedding6D_get_index(self, o)
10790 def get_center(self, *args):
10792 get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10793 get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
10795 return _IMP_algebra.LogEmbedding6D_get_center(self, *args)
10797 def get_bounding_box(self, *args):
10799 get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10800 get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10802 return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)
10804 def show(self, *args):
10805 r"""show(LogEmbedding6D self, _ostream out=std::cout)"""
10806 return _IMP_algebra.LogEmbedding6D_show(self, *args)
10809 r"""__str__(LogEmbedding6D self) -> std::string"""
10810 return _IMP_algebra.LogEmbedding6D___str__(self)
10812 def __repr__(self):
10813 r"""__repr__(LogEmbedding6D self) -> std::string"""
10814 return _IMP_algebra.LogEmbedding6D___repr__(self)
10816 def __cmp__(self, arg2):
10817 r"""__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
10818 return _IMP_algebra.LogEmbedding6D___cmp__(self, arg2)
10820 def __eq__(self, arg2):
10821 r"""__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
10822 return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)
10824 def _get_as_binary(self):
10825 r"""_get_as_binary(LogEmbedding6D self) -> PyObject *"""
10826 return _IMP_algebra.LogEmbedding6D__get_as_binary(self)
10828 def _set_from_binary(self, p):
10829 r"""_set_from_binary(LogEmbedding6D self, PyObject * p)"""
10830 return _IMP_algebra.LogEmbedding6D__set_from_binary(self, p)
10832 def __getstate__(self):
10833 p = self._get_as_binary()
10834 if len(self.__dict__) > 1:
10835 d = self.__dict__.copy()
10840 def __setstate__(self, p):
10841 if not hasattr(self,
'this'):
10843 if isinstance(p, tuple):
10845 self.__dict__.update(d)
10846 return self._set_from_binary(p)
10848 __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
10851 _IMP_algebra.LogEmbedding6D_swigregister(LogEmbedding6D)
10852 class SpherePatch3D(_GeometricPrimitive3D):
10853 r"""Proxy of C++ IMP::algebra::SpherePatch3D class."""
10855 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10857 def __init__(self, *args):
10859 __init__(SpherePatch3D self) -> SpherePatch3D
10860 __init__(SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
10862 _IMP_algebra.SpherePatch3D_swiginit(self, _IMP_algebra.new_SpherePatch3D(*args))
10864 def get_contains(self, p):
10865 r"""get_contains(SpherePatch3D self, Vector3D p) -> bool"""
10866 return _IMP_algebra.SpherePatch3D_get_contains(self, p)
10868 def get_plane(self):
10869 r"""get_plane(SpherePatch3D self) -> Plane3D"""
10870 return _IMP_algebra.SpherePatch3D_get_plane(self)
10872 def get_sphere(self):
10873 r"""get_sphere(SpherePatch3D self) -> Sphere3D"""
10874 return _IMP_algebra.SpherePatch3D_get_sphere(self)
10876 def show(self, *args):
10877 r"""show(SpherePatch3D self, _ostream out=std::cout)"""
10878 return _IMP_algebra.SpherePatch3D_show(self, *args)
10880 def get_boundary_point(self):
10881 r"""get_boundary_point(SpherePatch3D self) -> Vector3D"""
10882 return _IMP_algebra.SpherePatch3D_get_boundary_point(self)
10885 r"""__str__(SpherePatch3D self) -> std::string"""
10886 return _IMP_algebra.SpherePatch3D___str__(self)
10888 def __repr__(self):
10889 r"""__repr__(SpherePatch3D self) -> std::string"""
10890 return _IMP_algebra.SpherePatch3D___repr__(self)
10892 def _get_as_binary(self):
10893 r"""_get_as_binary(SpherePatch3D self) -> PyObject *"""
10894 return _IMP_algebra.SpherePatch3D__get_as_binary(self)
10896 def _set_from_binary(self, p):
10897 r"""_set_from_binary(SpherePatch3D self, PyObject * p)"""
10898 return _IMP_algebra.SpherePatch3D__set_from_binary(self, p)
10900 def __getstate__(self):
10901 p = self._get_as_binary()
10902 if len(self.__dict__) > 1:
10903 d = self.__dict__.copy()
10908 def __setstate__(self, p):
10909 if not hasattr(self,
'this'):
10911 if isinstance(p, tuple):
10913 self.__dict__.update(d)
10914 return self._set_from_binary(p)
10916 __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
10919 _IMP_algebra.SpherePatch3D_swigregister(SpherePatch3D)
10923 get_area(Plane3D g) -> double
10924 get_area(SpherePatch3D g) -> double
10926 return _IMP_algebra.get_area(*args)
10928 def get_sphere_patch_3d_geometry(g):
10929 r"""get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
10930 return _IMP_algebra.get_sphere_patch_3d_geometry(g)
10931 class Cone3D(_GeometricPrimitive3D):
10932 r"""Proxy of C++ IMP::algebra::Cone3D class."""
10934 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
10936 def __init__(self, *args):
10938 __init__(Cone3D self) -> Cone3D
10939 __init__(Cone3D self, Segment3D s, double radius) -> Cone3D
10941 _IMP_algebra.Cone3D_swiginit(self, _IMP_algebra.new_Cone3D(*args))
10944 r"""get_tip(Cone3D self) -> Vector3D"""
10945 return _IMP_algebra.Cone3D_get_tip(self)
10947 def get_direction(self):
10948 r"""get_direction(Cone3D self) -> Vector3D"""
10949 return _IMP_algebra.Cone3D_get_direction(self)
10952 r"""get_height(Cone3D self) -> double"""
10953 return _IMP_algebra.Cone3D_get_height(self)
10956 r"""get_angle(Cone3D self) -> double"""
10957 return _IMP_algebra.Cone3D_get_angle(self)
10959 def get_radius(self):
10960 r"""get_radius(Cone3D self) -> double"""
10961 return _IMP_algebra.Cone3D_get_radius(self)
10963 def get_contains(self, v):
10964 r"""get_contains(Cone3D self, Vector3D v) -> bool"""
10965 return _IMP_algebra.Cone3D_get_contains(self, v)
10967 def get_base_plane(self):
10968 r"""get_base_plane(Cone3D self) -> Plane3D"""
10969 return _IMP_algebra.Cone3D_get_base_plane(self)
10971 def show(self, *args):
10972 r"""show(Cone3D self, _ostream out=std::cout)"""
10973 return _IMP_algebra.Cone3D_show(self, *args)
10976 r"""__str__(Cone3D self) -> std::string"""
10977 return _IMP_algebra.Cone3D___str__(self)
10979 def __repr__(self):
10980 r"""__repr__(Cone3D self) -> std::string"""
10981 return _IMP_algebra.Cone3D___repr__(self)
10983 def _get_as_binary(self):
10984 r"""_get_as_binary(Cone3D self) -> PyObject *"""
10985 return _IMP_algebra.Cone3D__get_as_binary(self)
10987 def _set_from_binary(self, p):
10988 r"""_set_from_binary(Cone3D self, PyObject * p)"""
10989 return _IMP_algebra.Cone3D__set_from_binary(self, p)
10991 def __getstate__(self):
10992 p = self._get_as_binary()
10993 if len(self.__dict__) > 1:
10994 d = self.__dict__.copy()
10999 def __setstate__(self, p):
11000 if not hasattr(self,
'this'):
11002 if isinstance(p, tuple):
11004 self.__dict__.update(d)
11005 return self._set_from_binary(p)
11007 __swig_destroy__ = _IMP_algebra.delete_Cone3D
11010 _IMP_algebra.Cone3D_swigregister(Cone3D)
11014 get_surface_area(BoundingBox3D g) -> double
11015 get_surface_area(Sphere3D g) -> double
11016 get_surface_area(Cylinder3D g) -> double
11017 get_surface_area(Ellipsoid3D g) -> double
11018 get_surface_area(Cone3D g) -> double
11020 return _IMP_algebra.get_surface_area(*args)
11024 get_volume(BoundingBox3D g) -> double
11025 get_volume(Sphere3D g) -> double
11026 get_volume(Cylinder3D g) -> double
11027 get_volume(Ellipsoid3D g) -> double
11028 get_volume(Cone3D g) -> double
11030 return _IMP_algebra.get_volume(*args)
11032 def get_cone_3d_geometry(g):
11033 r"""get_cone_3d_geometry(Cone3D g) -> Cone3D"""
11034 return _IMP_algebra.get_cone_3d_geometry(g)
11037 r"""write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
11038 return _IMP_algebra.write_pts(vs, out)
11041 r"""read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
11042 return _IMP_algebra.read_pts(input)
11045 r"""write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
11046 return _IMP_algebra.write_spheres(vs, out)
11049 r"""read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
11050 return _IMP_algebra.read_spheres(input)
11053 r"""get_random_vector_on_unit_sphere() -> Vector3D"""
11054 return _IMP_algebra.get_random_vector_on_unit_sphere()
11057 r"""get_grid_surface_cover(Cylinder3D cyl, int number_of_cycles, int number_of_points_on_cycle) -> IMP::algebra::Vector3Ds"""
11058 return _IMP_algebra.get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle)
11061 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"""
11062 return _IMP_algebra.get_random_chain(*args)
11065 r"""reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
11066 return _IMP_algebra.reversed_read(dest, size, nitems, f, reverse)
11069 r"""reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)"""
11070 return _IMP_algebra.reversed_write(src, size, nitems, f, reverse)
11073 r"""get_is_big_endian() -> bool"""
11074 return _IMP_algebra.get_is_big_endian()
11077 r"""get_is_little_endian() -> bool"""
11078 return _IMP_algebra.get_is_little_endian()
11082 get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
11083 get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
11085 return _IMP_algebra.get_shortest_segment(*args)
11087 r"""Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class."""
11089 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11091 def __init__(self, vs, query_estimate=1):
11092 r"""__init__(DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D"""
11093 _IMP_algebra.DynamicNearestNeighbor3D_swiginit(self, _IMP_algebra.new_DynamicNearestNeighbor3D(vs, query_estimate))
11095 def get_in_ball(self, id, distance):
11096 r"""get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
11097 return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, id, distance)
11099 def set_coordinates(self, id, nc):
11100 r"""set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
11101 return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, id, nc)
11103 def get_version_info(self):
11104 r"""get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
11105 return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)
11106 __swig_destroy__ = _IMP_algebra.delete_DynamicNearestNeighbor3D
11109 r"""__str__(DynamicNearestNeighbor3D self) -> std::string"""
11110 return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)
11112 def __repr__(self):
11113 r"""__repr__(DynamicNearestNeighbor3D self) -> std::string"""
11114 return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)
11118 return _object_cast_to_DynamicNearestNeighbor3D(o)
11122 _IMP_algebra.DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
11124 r"""Proxy of C++ IMP::algebra::VectorKDMetric class."""
11126 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11128 def __init__(self, name):
11129 r"""__init__(VectorKDMetric self, std::string name) -> VectorKDMetric"""
11130 if self.__class__ == VectorKDMetric:
11134 _IMP_algebra.VectorKDMetric_swiginit(self, _IMP_algebra.new_VectorKDMetric(_self, name))
11136 if self.__class__ != VectorKDMetric:
11137 _director_objects.register(self)
11143 r"""get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
11144 return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)
11147 r"""get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
11148 return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)
11151 r"""__str__(VectorKDMetric self) -> std::string"""
11152 return _IMP_algebra.VectorKDMetric___str__(self)
11154 def __repr__(self):
11155 r"""__repr__(VectorKDMetric self) -> std::string"""
11156 return _IMP_algebra.VectorKDMetric___repr__(self)
11160 return _object_cast_to_VectorKDMetric(o)
11163 def get_type_name(self):
11164 return self.__class__.__name__
11165 def do_show(self, out):
11167 def get_version_info(self):
11168 if"IMP::algebra" ==
"IMP":
11169 return VersionInfo(self.__module__,
11176 return _object_cast_to_VectorKDMetric(o)
11178 __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
11179 def __disown__(self):
11181 _IMP_algebra.disown_VectorKDMetric(self)
11182 return weakref.proxy(self)
11184 def do_destroy(self):
11185 r"""do_destroy(VectorKDMetric self)"""
11186 return _IMP_algebra.VectorKDMetric_do_destroy(self)
11189 _IMP_algebra.VectorKDMetric_swigregister(VectorKDMetric)
11190 class EuclideanVectorKDMetric(VectorKDMetric):
11191 r"""Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class."""
11193 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11195 def __init__(self, *args):
11196 r"""__init__(EuclideanVectorKDMetric self, std::string name="EuclideanVectorKDMetric%1%") -> EuclideanVectorKDMetric"""
11197 _IMP_algebra.EuclideanVectorKDMetric_swiginit(self, _IMP_algebra.new_EuclideanVectorKDMetric(*args))
11199 def get_version_info(self):
11200 r"""get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
11201 return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)
11202 __swig_destroy__ = _IMP_algebra.delete_EuclideanVectorKDMetric
11205 r"""__str__(EuclideanVectorKDMetric self) -> std::string"""
11206 return _IMP_algebra.EuclideanVectorKDMetric___str__(self)
11208 def __repr__(self):
11209 r"""__repr__(EuclideanVectorKDMetric self) -> std::string"""
11210 return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)
11214 return _object_cast_to_EuclideanVectorKDMetric(o)
11217 def _get_as_binary(self):
11218 r"""_get_as_binary(EuclideanVectorKDMetric self) -> PyObject *"""
11219 return _IMP_algebra.EuclideanVectorKDMetric__get_as_binary(self)
11221 def _set_from_binary(self, p):
11222 r"""_set_from_binary(EuclideanVectorKDMetric self, PyObject * p)"""
11223 return _IMP_algebra.EuclideanVectorKDMetric__set_from_binary(self, p)
11225 def __getstate__(self):
11226 p = self._get_as_binary()
11227 if len(self.__dict__) > 1:
11228 d = self.__dict__.copy()
11233 def __setstate__(self, p):
11234 if not hasattr(self,
'this'):
11236 if isinstance(p, tuple):
11238 self.__dict__.update(d)
11239 return self._set_from_binary(p)
11243 _IMP_algebra.EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
11244 class MaxVectorKDMetric(VectorKDMetric):
11245 r"""Proxy of C++ IMP::algebra::MaxVectorKDMetric class."""
11247 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11249 def __init__(self, *args):
11250 r"""__init__(MaxVectorKDMetric self, std::string name="MaxVectorKDMetric%1%") -> MaxVectorKDMetric"""
11251 _IMP_algebra.MaxVectorKDMetric_swiginit(self, _IMP_algebra.new_MaxVectorKDMetric(*args))
11253 def get_version_info(self):
11254 r"""get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
11255 return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)
11256 __swig_destroy__ = _IMP_algebra.delete_MaxVectorKDMetric
11259 r"""__str__(MaxVectorKDMetric self) -> std::string"""
11260 return _IMP_algebra.MaxVectorKDMetric___str__(self)
11262 def __repr__(self):
11263 r"""__repr__(MaxVectorKDMetric self) -> std::string"""
11264 return _IMP_algebra.MaxVectorKDMetric___repr__(self)
11268 return _object_cast_to_MaxVectorKDMetric(o)
11271 def _get_as_binary(self):
11272 r"""_get_as_binary(MaxVectorKDMetric self) -> PyObject *"""
11273 return _IMP_algebra.MaxVectorKDMetric__get_as_binary(self)
11275 def _set_from_binary(self, p):
11276 r"""_set_from_binary(MaxVectorKDMetric self, PyObject * p)"""
11277 return _IMP_algebra.MaxVectorKDMetric__set_from_binary(self, p)
11279 def __getstate__(self):
11280 p = self._get_as_binary()
11281 if len(self.__dict__) > 1:
11282 d = self.__dict__.copy()
11287 def __setstate__(self, p):
11288 if not hasattr(self,
'this'):
11290 if isinstance(p, tuple):
11292 self.__dict__.update(d)
11293 return self._set_from_binary(p)
11297 _IMP_algebra.MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
11298 class Gaussian3D(_GeometricPrimitive3D):
11299 r"""Proxy of C++ IMP::algebra::Gaussian3D class."""
11301 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11303 def __init__(self, *args):
11305 __init__(Gaussian3D self) -> Gaussian3D
11306 __init__(Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
11308 _IMP_algebra.Gaussian3D_swiginit(self, _IMP_algebra.new_Gaussian3D(*args))
11310 def get_reference_frame(self):
11311 r"""get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
11312 return _IMP_algebra.Gaussian3D_get_reference_frame(self)
11314 def get_variances(self):
11315 r"""get_variances(Gaussian3D self) -> Vector3D"""
11316 return _IMP_algebra.Gaussian3D_get_variances(self)
11318 def get_center(self):
11319 r"""get_center(Gaussian3D self) -> Vector3D"""
11320 return _IMP_algebra.Gaussian3D_get_center(self)
11322 def show(self, *args):
11323 r"""show(Gaussian3D self, _ostream out=std::cout)"""
11324 return _IMP_algebra.Gaussian3D_show(self, *args)
11327 r"""__str__(Gaussian3D self) -> std::string"""
11328 return _IMP_algebra.Gaussian3D___str__(self)
11330 def __repr__(self):
11331 r"""__repr__(Gaussian3D self) -> std::string"""
11332 return _IMP_algebra.Gaussian3D___repr__(self)
11334 def _get_as_binary(self):
11335 r"""_get_as_binary(Gaussian3D self) -> PyObject *"""
11336 return _IMP_algebra.Gaussian3D__get_as_binary(self)
11338 def _set_from_binary(self, p):
11339 r"""_set_from_binary(Gaussian3D self, PyObject * p)"""
11340 return _IMP_algebra.Gaussian3D__set_from_binary(self, p)
11342 def __getstate__(self):
11343 p = self._get_as_binary()
11344 if len(self.__dict__) > 1:
11345 d = self.__dict__.copy()
11350 def __setstate__(self, p):
11351 if not hasattr(self,
'this'):
11353 if isinstance(p, tuple):
11355 self.__dict__.update(d)
11356 return self._set_from_binary(p)
11358 __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
11361 _IMP_algebra.Gaussian3D_swigregister(Gaussian3D)
11364 r"""get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
11365 return _IMP_algebra.get_covariance(g)
11368 r"""get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
11369 return _IMP_algebra.get_gaussian_from_covariance(covariance, center)
11372 r"""get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D"""
11373 return _IMP_algebra.get_rasterized(gmm, weights, cell_width, bb)
11376 r"""get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb, double factor=2.5) -> DenseDoubleGrid3D"""
11377 return _IMP_algebra.get_rasterized_fast(gmm, weights, cell_width, bb, factor)
11379 def _pass_matrix_xf(m):
11380 r"""_pass_matrix_xf(Eigen::MatrixXf const & m) -> Eigen::MatrixXf"""
11381 return _IMP_algebra._pass_matrix_xf(m)
11383 def _pass_matrix_xd(m):
11384 r"""_pass_matrix_xd(Eigen::MatrixXd const & m) -> Eigen::MatrixXd"""
11385 return _IMP_algebra._pass_matrix_xd(m)
11387 def _pass_matrix_3d(m):
11388 r"""_pass_matrix_3d(Eigen::Matrix3d const & m) -> Eigen::Matrix3d"""
11389 return _IMP_algebra._pass_matrix_3d(m)
11391 def _pass_array_xd(m):
11392 r"""_pass_array_xd(Eigen::ArrayXXd const & m) -> Eigen::ArrayXXd"""
11393 return _IMP_algebra._pass_array_xd(m)
11395 def _pass_vector_xd(m):
11396 r"""_pass_vector_xd(Eigen::VectorXd const & m) -> Eigen::VectorXd"""
11397 return _IMP_algebra._pass_vector_xd(m)
11399 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 1 > class."""
11401 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11403 def __init__(self, vs, epsilon=0):
11404 r"""__init__(NearestNeighbor1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D"""
11405 _IMP_algebra.NearestNeighbor1D_swiginit(self, _IMP_algebra.new_NearestNeighbor1D(vs, epsilon))
11407 def set_query_log(self, fname):
11408 r"""set_query_log(NearestNeighbor1D self, std::string fname)"""
11409 return _IMP_algebra.NearestNeighbor1D_set_query_log(self, fname)
11411 def get_nearest_neighbor(self, *args):
11413 get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
11414 get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
11416 return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)
11418 def get_nearest_neighbors(self, *args):
11420 get_nearest_neighbors(NearestNeighbor1D self, unsigned int i, unsigned int k) -> IMP::Ints
11421 get_nearest_neighbors(NearestNeighbor1D self, Vector1D v, unsigned int k) -> IMP::Ints
11423 return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)
11425 def get_in_ball(self, *args):
11427 get_in_ball(NearestNeighbor1D self, unsigned int i, double distance) -> IMP::Ints
11428 get_in_ball(NearestNeighbor1D self, Vector1D pt, double distance) -> IMP::Ints
11430 return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)
11432 def get_version_info(self):
11433 r"""get_version_info(NearestNeighbor1D self) -> VersionInfo"""
11434 return _IMP_algebra.NearestNeighbor1D_get_version_info(self)
11435 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor1D
11438 r"""__str__(NearestNeighbor1D self) -> std::string"""
11439 return _IMP_algebra.NearestNeighbor1D___str__(self)
11441 def __repr__(self):
11442 r"""__repr__(NearestNeighbor1D self) -> std::string"""
11443 return _IMP_algebra.NearestNeighbor1D___repr__(self)
11447 return _object_cast_to_NearestNeighborD(o)
11451 _IMP_algebra.NearestNeighbor1D_swigregister(NearestNeighbor1D)
11453 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 2 > class."""
11455 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11457 def __init__(self, vs, epsilon=0):
11458 r"""__init__(NearestNeighbor2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D"""
11459 _IMP_algebra.NearestNeighbor2D_swiginit(self, _IMP_algebra.new_NearestNeighbor2D(vs, epsilon))
11461 def set_query_log(self, fname):
11462 r"""set_query_log(NearestNeighbor2D self, std::string fname)"""
11463 return _IMP_algebra.NearestNeighbor2D_set_query_log(self, fname)
11465 def get_nearest_neighbor(self, *args):
11467 get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
11468 get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
11470 return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)
11472 def get_nearest_neighbors(self, *args):
11474 get_nearest_neighbors(NearestNeighbor2D self, unsigned int i, unsigned int k) -> IMP::Ints
11475 get_nearest_neighbors(NearestNeighbor2D self, Vector2D v, unsigned int k) -> IMP::Ints
11477 return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)
11479 def get_in_ball(self, *args):
11481 get_in_ball(NearestNeighbor2D self, unsigned int i, double distance) -> IMP::Ints
11482 get_in_ball(NearestNeighbor2D self, Vector2D pt, double distance) -> IMP::Ints
11484 return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)
11486 def get_version_info(self):
11487 r"""get_version_info(NearestNeighbor2D self) -> VersionInfo"""
11488 return _IMP_algebra.NearestNeighbor2D_get_version_info(self)
11489 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor2D
11492 r"""__str__(NearestNeighbor2D self) -> std::string"""
11493 return _IMP_algebra.NearestNeighbor2D___str__(self)
11495 def __repr__(self):
11496 r"""__repr__(NearestNeighbor2D self) -> std::string"""
11497 return _IMP_algebra.NearestNeighbor2D___repr__(self)
11501 return _object_cast_to_NearestNeighborD(o)
11505 _IMP_algebra.NearestNeighbor2D_swigregister(NearestNeighbor2D)
11507 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 3 > class."""
11509 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11511 def __init__(self, vs, epsilon=0):
11512 r"""__init__(NearestNeighbor3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D"""
11513 _IMP_algebra.NearestNeighbor3D_swiginit(self, _IMP_algebra.new_NearestNeighbor3D(vs, epsilon))
11515 def set_query_log(self, fname):
11516 r"""set_query_log(NearestNeighbor3D self, std::string fname)"""
11517 return _IMP_algebra.NearestNeighbor3D_set_query_log(self, fname)
11519 def get_nearest_neighbor(self, *args):
11521 get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
11522 get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
11524 return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)
11526 def get_nearest_neighbors(self, *args):
11528 get_nearest_neighbors(NearestNeighbor3D self, unsigned int i, unsigned int k) -> IMP::Ints
11529 get_nearest_neighbors(NearestNeighbor3D self, Vector3D v, unsigned int k) -> IMP::Ints
11531 return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)
11533 def get_in_ball(self, *args):
11535 get_in_ball(NearestNeighbor3D self, unsigned int i, double distance) -> IMP::Ints
11536 get_in_ball(NearestNeighbor3D self, Vector3D pt, double distance) -> IMP::Ints
11538 return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)
11540 def get_version_info(self):
11541 r"""get_version_info(NearestNeighbor3D self) -> VersionInfo"""
11542 return _IMP_algebra.NearestNeighbor3D_get_version_info(self)
11543 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor3D
11546 r"""__str__(NearestNeighbor3D self) -> std::string"""
11547 return _IMP_algebra.NearestNeighbor3D___str__(self)
11549 def __repr__(self):
11550 r"""__repr__(NearestNeighbor3D self) -> std::string"""
11551 return _IMP_algebra.NearestNeighbor3D___repr__(self)
11555 return _object_cast_to_NearestNeighborD(o)
11559 _IMP_algebra.NearestNeighbor3D_swigregister(NearestNeighbor3D)
11561 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 4 > class."""
11563 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11565 def __init__(self, vs, epsilon=0):
11566 r"""__init__(NearestNeighbor4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D"""
11567 _IMP_algebra.NearestNeighbor4D_swiginit(self, _IMP_algebra.new_NearestNeighbor4D(vs, epsilon))
11569 def set_query_log(self, fname):
11570 r"""set_query_log(NearestNeighbor4D self, std::string fname)"""
11571 return _IMP_algebra.NearestNeighbor4D_set_query_log(self, fname)
11573 def get_nearest_neighbor(self, *args):
11575 get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
11576 get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
11578 return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)
11580 def get_nearest_neighbors(self, *args):
11582 get_nearest_neighbors(NearestNeighbor4D self, unsigned int i, unsigned int k) -> IMP::Ints
11583 get_nearest_neighbors(NearestNeighbor4D self, Vector4D v, unsigned int k) -> IMP::Ints
11585 return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)
11587 def get_in_ball(self, *args):
11589 get_in_ball(NearestNeighbor4D self, unsigned int i, double distance) -> IMP::Ints
11590 get_in_ball(NearestNeighbor4D self, Vector4D pt, double distance) -> IMP::Ints
11592 return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)
11594 def get_version_info(self):
11595 r"""get_version_info(NearestNeighbor4D self) -> VersionInfo"""
11596 return _IMP_algebra.NearestNeighbor4D_get_version_info(self)
11597 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor4D
11600 r"""__str__(NearestNeighbor4D self) -> std::string"""
11601 return _IMP_algebra.NearestNeighbor4D___str__(self)
11603 def __repr__(self):
11604 r"""__repr__(NearestNeighbor4D self) -> std::string"""
11605 return _IMP_algebra.NearestNeighbor4D___repr__(self)
11609 return _object_cast_to_NearestNeighborD(o)
11613 _IMP_algebra.NearestNeighbor4D_swigregister(NearestNeighbor4D)
11615 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 5 > class."""
11617 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11619 def __init__(self, vs, epsilon=0):
11620 r"""__init__(NearestNeighbor5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D"""
11621 _IMP_algebra.NearestNeighbor5D_swiginit(self, _IMP_algebra.new_NearestNeighbor5D(vs, epsilon))
11623 def set_query_log(self, fname):
11624 r"""set_query_log(NearestNeighbor5D self, std::string fname)"""
11625 return _IMP_algebra.NearestNeighbor5D_set_query_log(self, fname)
11627 def get_nearest_neighbor(self, *args):
11629 get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
11630 get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
11632 return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)
11634 def get_nearest_neighbors(self, *args):
11636 get_nearest_neighbors(NearestNeighbor5D self, unsigned int i, unsigned int k) -> IMP::Ints
11637 get_nearest_neighbors(NearestNeighbor5D self, Vector5D v, unsigned int k) -> IMP::Ints
11639 return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)
11641 def get_in_ball(self, *args):
11643 get_in_ball(NearestNeighbor5D self, unsigned int i, double distance) -> IMP::Ints
11644 get_in_ball(NearestNeighbor5D self, Vector5D pt, double distance) -> IMP::Ints
11646 return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)
11648 def get_version_info(self):
11649 r"""get_version_info(NearestNeighbor5D self) -> VersionInfo"""
11650 return _IMP_algebra.NearestNeighbor5D_get_version_info(self)
11651 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor5D
11654 r"""__str__(NearestNeighbor5D self) -> std::string"""
11655 return _IMP_algebra.NearestNeighbor5D___str__(self)
11657 def __repr__(self):
11658 r"""__repr__(NearestNeighbor5D self) -> std::string"""
11659 return _IMP_algebra.NearestNeighbor5D___repr__(self)
11663 return _object_cast_to_NearestNeighborD(o)
11667 _IMP_algebra.NearestNeighbor5D_swigregister(NearestNeighbor5D)
11669 r"""Proxy of C++ IMP::algebra::NearestNeighborD< 6 > class."""
11671 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11673 def __init__(self, vs, epsilon=0):
11674 r"""__init__(NearestNeighbor6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D"""
11675 _IMP_algebra.NearestNeighbor6D_swiginit(self, _IMP_algebra.new_NearestNeighbor6D(vs, epsilon))
11677 def set_query_log(self, fname):
11678 r"""set_query_log(NearestNeighbor6D self, std::string fname)"""
11679 return _IMP_algebra.NearestNeighbor6D_set_query_log(self, fname)
11681 def get_nearest_neighbor(self, *args):
11683 get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
11684 get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
11686 return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)
11688 def get_nearest_neighbors(self, *args):
11690 get_nearest_neighbors(NearestNeighbor6D self, unsigned int i, unsigned int k) -> IMP::Ints
11691 get_nearest_neighbors(NearestNeighbor6D self, Vector6D v, unsigned int k) -> IMP::Ints
11693 return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)
11695 def get_in_ball(self, *args):
11697 get_in_ball(NearestNeighbor6D self, unsigned int i, double distance) -> IMP::Ints
11698 get_in_ball(NearestNeighbor6D self, Vector6D pt, double distance) -> IMP::Ints
11700 return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)
11702 def get_version_info(self):
11703 r"""get_version_info(NearestNeighbor6D self) -> VersionInfo"""
11704 return _IMP_algebra.NearestNeighbor6D_get_version_info(self)
11705 __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor6D
11708 r"""__str__(NearestNeighbor6D self) -> std::string"""
11709 return _IMP_algebra.NearestNeighbor6D___str__(self)
11711 def __repr__(self):
11712 r"""__repr__(NearestNeighbor6D self) -> std::string"""
11713 return _IMP_algebra.NearestNeighbor6D___repr__(self)
11717 return _object_cast_to_NearestNeighborD(o)
11721 _IMP_algebra.NearestNeighbor6D_swigregister(NearestNeighbor6D)
11723 r"""Proxy of C++ IMP::algebra::NearestNeighborD< -1 > class."""
11725 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11727 def __init__(self, vs, epsilon=0):
11728 r"""__init__(NearestNeighborKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD"""
11729 _IMP_algebra.NearestNeighborKD_swiginit(self, _IMP_algebra.new_NearestNeighborKD(vs, epsilon))
11731 def set_query_log(self, fname):
11732 r"""set_query_log(NearestNeighborKD self, std::string fname)"""
11733 return _IMP_algebra.NearestNeighborKD_set_query_log(self, fname)
11735 def get_nearest_neighbor(self, *args):
11737 get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
11738 get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
11740 return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)
11742 def get_nearest_neighbors(self, *args):
11744 get_nearest_neighbors(NearestNeighborKD self, unsigned int i, unsigned int k) -> IMP::Ints
11745 get_nearest_neighbors(NearestNeighborKD self, VectorKD v, unsigned int k) -> IMP::Ints
11747 return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)
11749 def get_in_ball(self, *args):
11751 get_in_ball(NearestNeighborKD self, unsigned int i, double distance) -> IMP::Ints
11752 get_in_ball(NearestNeighborKD self, VectorKD pt, double distance) -> IMP::Ints
11754 return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)
11756 def get_version_info(self):
11757 r"""get_version_info(NearestNeighborKD self) -> VersionInfo"""
11758 return _IMP_algebra.NearestNeighborKD_get_version_info(self)
11759 __swig_destroy__ = _IMP_algebra.delete_NearestNeighborKD
11762 r"""__str__(NearestNeighborKD self) -> std::string"""
11763 return _IMP_algebra.NearestNeighborKD___str__(self)
11765 def __repr__(self):
11766 r"""__repr__(NearestNeighborKD self) -> std::string"""
11767 return _IMP_algebra.NearestNeighborKD___repr__(self)
11771 return _object_cast_to_NearestNeighborD(o)
11775 _IMP_algebra.NearestNeighborKD_swigregister(NearestNeighborKD)
11778 r"""get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
11779 return _IMP_algebra.get_transformation_aligning_pair(set_from, set_to)
11780 class PrincipalComponentAnalysis1D(_GeometricPrimitive1D):
11781 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 1 > class."""
11783 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11785 def __init__(self, *args):
11787 __init__(PrincipalComponentAnalysis1D self) -> PrincipalComponentAnalysis1D
11788 __init__(PrincipalComponentAnalysis1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
11790 _IMP_algebra.PrincipalComponentAnalysis1D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis1D(*args))
11793 r"""get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
11794 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)
11796 def get_principal_component(self, i):
11797 r"""get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
11798 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, i)
11800 def get_principal_values(self):
11801 r"""get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
11802 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)
11804 def get_principal_value(self, i):
11805 r"""get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
11806 return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, i)
11809 r"""get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
11810 return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)
11812 def set_centroid(self, cntr):
11813 r"""set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
11814 return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)
11816 def show(self, *args):
11817 r"""show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)"""
11818 return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)
11820 def __cmp__(self, o):
11821 r"""__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
11822 return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, o)
11824 def __eq__(self, o):
11825 r"""__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11826 return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)
11828 def __ne__(self, o):
11829 r"""__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11830 return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)
11832 def __lt__(self, o):
11833 r"""__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11834 return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)
11836 def __gt__(self, o):
11837 r"""__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11838 return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)
11840 def __ge__(self, o):
11841 r"""__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11842 return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)
11844 def __le__(self, o):
11845 r"""__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11846 return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)
11849 r"""__str__(PrincipalComponentAnalysis1D self) -> std::string"""
11850 return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)
11852 def __repr__(self):
11853 r"""__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
11854 return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)
11856 def _get_as_binary(self):
11857 r"""_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
11858 return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)
11860 def _set_from_binary(self, p):
11861 r"""_set_from_binary(PrincipalComponentAnalysis1D self, PyObject * p)"""
11862 return _IMP_algebra.PrincipalComponentAnalysis1D__set_from_binary(self, p)
11864 def __getstate__(self):
11865 p = self._get_as_binary()
11866 if len(self.__dict__) > 1:
11867 d = self.__dict__.copy()
11872 def __setstate__(self, p):
11873 if not hasattr(self,
'this'):
11875 if isinstance(p, tuple):
11877 self.__dict__.update(d)
11878 return self._set_from_binary(p)
11880 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
11883 _IMP_algebra.PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
11884 class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
11885 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 2 > class."""
11887 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11889 def __init__(self, *args):
11891 __init__(PrincipalComponentAnalysis2D self) -> PrincipalComponentAnalysis2D
11892 __init__(PrincipalComponentAnalysis2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
11894 _IMP_algebra.PrincipalComponentAnalysis2D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis2D(*args))
11897 r"""get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
11898 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)
11900 def get_principal_component(self, i):
11901 r"""get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
11902 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, i)
11904 def get_principal_values(self):
11905 r"""get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
11906 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)
11908 def get_principal_value(self, i):
11909 r"""get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
11910 return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, i)
11913 r"""get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
11914 return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)
11916 def set_centroid(self, cntr):
11917 r"""set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
11918 return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)
11920 def show(self, *args):
11921 r"""show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)"""
11922 return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)
11924 def __cmp__(self, o):
11925 r"""__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
11926 return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, o)
11928 def __eq__(self, o):
11929 r"""__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11930 return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)
11932 def __ne__(self, o):
11933 r"""__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11934 return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)
11936 def __lt__(self, o):
11937 r"""__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11938 return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)
11940 def __gt__(self, o):
11941 r"""__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11942 return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)
11944 def __ge__(self, o):
11945 r"""__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11946 return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)
11948 def __le__(self, o):
11949 r"""__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11950 return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)
11953 r"""__str__(PrincipalComponentAnalysis2D self) -> std::string"""
11954 return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)
11956 def __repr__(self):
11957 r"""__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
11958 return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)
11960 def _get_as_binary(self):
11961 r"""_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
11962 return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)
11964 def _set_from_binary(self, p):
11965 r"""_set_from_binary(PrincipalComponentAnalysis2D self, PyObject * p)"""
11966 return _IMP_algebra.PrincipalComponentAnalysis2D__set_from_binary(self, p)
11968 def __getstate__(self):
11969 p = self._get_as_binary()
11970 if len(self.__dict__) > 1:
11971 d = self.__dict__.copy()
11976 def __setstate__(self, p):
11977 if not hasattr(self,
'this'):
11979 if isinstance(p, tuple):
11981 self.__dict__.update(d)
11982 return self._set_from_binary(p)
11984 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
11987 _IMP_algebra.PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
11988 class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
11989 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 3 > class."""
11991 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
11993 def __init__(self, *args):
11995 __init__(PrincipalComponentAnalysis3D self) -> PrincipalComponentAnalysis3D
11996 __init__(PrincipalComponentAnalysis3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
11998 _IMP_algebra.PrincipalComponentAnalysis3D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis3D(*args))
12001 r"""get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
12002 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)
12004 def get_principal_component(self, i):
12005 r"""get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
12006 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, i)
12008 def get_principal_values(self):
12009 r"""get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
12010 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)
12012 def get_principal_value(self, i):
12013 r"""get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
12014 return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, i)
12017 r"""get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
12018 return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)
12020 def set_centroid(self, cntr):
12021 r"""set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
12022 return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)
12024 def show(self, *args):
12025 r"""show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)"""
12026 return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)
12028 def __cmp__(self, o):
12029 r"""__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
12030 return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, o)
12032 def __eq__(self, o):
12033 r"""__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12034 return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)
12036 def __ne__(self, o):
12037 r"""__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12038 return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)
12040 def __lt__(self, o):
12041 r"""__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12042 return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)
12044 def __gt__(self, o):
12045 r"""__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12046 return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)
12048 def __ge__(self, o):
12049 r"""__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12050 return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)
12052 def __le__(self, o):
12053 r"""__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12054 return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)
12057 r"""__str__(PrincipalComponentAnalysis3D self) -> std::string"""
12058 return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)
12060 def __repr__(self):
12061 r"""__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
12062 return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)
12064 def _get_as_binary(self):
12065 r"""_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
12066 return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)
12068 def _set_from_binary(self, p):
12069 r"""_set_from_binary(PrincipalComponentAnalysis3D self, PyObject * p)"""
12070 return _IMP_algebra.PrincipalComponentAnalysis3D__set_from_binary(self, p)
12072 def __getstate__(self):
12073 p = self._get_as_binary()
12074 if len(self.__dict__) > 1:
12075 d = self.__dict__.copy()
12080 def __setstate__(self, p):
12081 if not hasattr(self,
'this'):
12083 if isinstance(p, tuple):
12085 self.__dict__.update(d)
12086 return self._set_from_binary(p)
12088 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
12091 _IMP_algebra.PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
12092 class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
12093 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 4 > class."""
12095 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12097 def __init__(self, *args):
12099 __init__(PrincipalComponentAnalysis4D self) -> PrincipalComponentAnalysis4D
12100 __init__(PrincipalComponentAnalysis4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
12102 _IMP_algebra.PrincipalComponentAnalysis4D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis4D(*args))
12105 r"""get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
12106 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)
12108 def get_principal_component(self, i):
12109 r"""get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
12110 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, i)
12112 def get_principal_values(self):
12113 r"""get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
12114 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)
12116 def get_principal_value(self, i):
12117 r"""get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
12118 return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, i)
12121 r"""get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
12122 return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)
12124 def set_centroid(self, cntr):
12125 r"""set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
12126 return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)
12128 def show(self, *args):
12129 r"""show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)"""
12130 return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)
12132 def __cmp__(self, o):
12133 r"""__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
12134 return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, o)
12136 def __eq__(self, o):
12137 r"""__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12138 return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)
12140 def __ne__(self, o):
12141 r"""__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12142 return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)
12144 def __lt__(self, o):
12145 r"""__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12146 return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)
12148 def __gt__(self, o):
12149 r"""__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12150 return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)
12152 def __ge__(self, o):
12153 r"""__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12154 return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)
12156 def __le__(self, o):
12157 r"""__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12158 return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)
12161 r"""__str__(PrincipalComponentAnalysis4D self) -> std::string"""
12162 return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)
12164 def __repr__(self):
12165 r"""__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
12166 return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)
12168 def _get_as_binary(self):
12169 r"""_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
12170 return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)
12172 def _set_from_binary(self, p):
12173 r"""_set_from_binary(PrincipalComponentAnalysis4D self, PyObject * p)"""
12174 return _IMP_algebra.PrincipalComponentAnalysis4D__set_from_binary(self, p)
12176 def __getstate__(self):
12177 p = self._get_as_binary()
12178 if len(self.__dict__) > 1:
12179 d = self.__dict__.copy()
12184 def __setstate__(self, p):
12185 if not hasattr(self,
'this'):
12187 if isinstance(p, tuple):
12189 self.__dict__.update(d)
12190 return self._set_from_binary(p)
12192 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
12195 _IMP_algebra.PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
12196 class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
12197 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 5 > class."""
12199 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12201 def __init__(self, *args):
12203 __init__(PrincipalComponentAnalysis5D self) -> PrincipalComponentAnalysis5D
12204 __init__(PrincipalComponentAnalysis5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
12206 _IMP_algebra.PrincipalComponentAnalysis5D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis5D(*args))
12209 r"""get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
12210 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)
12212 def get_principal_component(self, i):
12213 r"""get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
12214 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, i)
12216 def get_principal_values(self):
12217 r"""get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
12218 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)
12220 def get_principal_value(self, i):
12221 r"""get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
12222 return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, i)
12225 r"""get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
12226 return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)
12228 def set_centroid(self, cntr):
12229 r"""set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
12230 return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)
12232 def show(self, *args):
12233 r"""show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)"""
12234 return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)
12236 def __cmp__(self, o):
12237 r"""__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
12238 return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, o)
12240 def __eq__(self, o):
12241 r"""__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12242 return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)
12244 def __ne__(self, o):
12245 r"""__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12246 return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)
12248 def __lt__(self, o):
12249 r"""__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12250 return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)
12252 def __gt__(self, o):
12253 r"""__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12254 return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)
12256 def __ge__(self, o):
12257 r"""__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12258 return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)
12260 def __le__(self, o):
12261 r"""__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12262 return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)
12265 r"""__str__(PrincipalComponentAnalysis5D self) -> std::string"""
12266 return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)
12268 def __repr__(self):
12269 r"""__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
12270 return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)
12272 def _get_as_binary(self):
12273 r"""_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
12274 return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)
12276 def _set_from_binary(self, p):
12277 r"""_set_from_binary(PrincipalComponentAnalysis5D self, PyObject * p)"""
12278 return _IMP_algebra.PrincipalComponentAnalysis5D__set_from_binary(self, p)
12280 def __getstate__(self):
12281 p = self._get_as_binary()
12282 if len(self.__dict__) > 1:
12283 d = self.__dict__.copy()
12288 def __setstate__(self, p):
12289 if not hasattr(self,
'this'):
12291 if isinstance(p, tuple):
12293 self.__dict__.update(d)
12294 return self._set_from_binary(p)
12296 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
12299 _IMP_algebra.PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
12300 class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
12301 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 6 > class."""
12303 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12305 def __init__(self, *args):
12307 __init__(PrincipalComponentAnalysis6D self) -> PrincipalComponentAnalysis6D
12308 __init__(PrincipalComponentAnalysis6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
12310 _IMP_algebra.PrincipalComponentAnalysis6D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis6D(*args))
12313 r"""get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
12314 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)
12316 def get_principal_component(self, i):
12317 r"""get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
12318 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, i)
12320 def get_principal_values(self):
12321 r"""get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
12322 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)
12324 def get_principal_value(self, i):
12325 r"""get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
12326 return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, i)
12329 r"""get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
12330 return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)
12332 def set_centroid(self, cntr):
12333 r"""set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
12334 return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)
12336 def show(self, *args):
12337 r"""show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)"""
12338 return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)
12340 def __cmp__(self, o):
12341 r"""__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
12342 return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, o)
12344 def __eq__(self, o):
12345 r"""__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12346 return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)
12348 def __ne__(self, o):
12349 r"""__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12350 return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)
12352 def __lt__(self, o):
12353 r"""__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12354 return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)
12356 def __gt__(self, o):
12357 r"""__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12358 return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)
12360 def __ge__(self, o):
12361 r"""__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12362 return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)
12364 def __le__(self, o):
12365 r"""__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12366 return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)
12369 r"""__str__(PrincipalComponentAnalysis6D self) -> std::string"""
12370 return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)
12372 def __repr__(self):
12373 r"""__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
12374 return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)
12376 def _get_as_binary(self):
12377 r"""_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
12378 return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)
12380 def _set_from_binary(self, p):
12381 r"""_set_from_binary(PrincipalComponentAnalysis6D self, PyObject * p)"""
12382 return _IMP_algebra.PrincipalComponentAnalysis6D__set_from_binary(self, p)
12384 def __getstate__(self):
12385 p = self._get_as_binary()
12386 if len(self.__dict__) > 1:
12387 d = self.__dict__.copy()
12392 def __setstate__(self, p):
12393 if not hasattr(self,
'this'):
12395 if isinstance(p, tuple):
12397 self.__dict__.update(d)
12398 return self._set_from_binary(p)
12400 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
12403 _IMP_algebra.PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
12404 class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
12405 r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< -1 > class."""
12407 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12409 def __init__(self, *args):
12411 __init__(PrincipalComponentAnalysisKD self) -> PrincipalComponentAnalysisKD
12412 __init__(PrincipalComponentAnalysisKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
12414 _IMP_algebra.PrincipalComponentAnalysisKD_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysisKD(*args))
12417 r"""get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
12418 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)
12420 def get_principal_component(self, i):
12421 r"""get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
12422 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, i)
12424 def get_principal_values(self):
12425 r"""get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
12426 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)
12428 def get_principal_value(self, i):
12429 r"""get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
12430 return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, i)
12433 r"""get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
12434 return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)
12436 def set_centroid(self, cntr):
12437 r"""set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
12438 return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)
12440 def show(self, *args):
12441 r"""show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)"""
12442 return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)
12444 def __cmp__(self, o):
12445 r"""__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
12446 return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, o)
12448 def __eq__(self, o):
12449 r"""__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12450 return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)
12452 def __ne__(self, o):
12453 r"""__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12454 return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)
12456 def __lt__(self, o):
12457 r"""__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12458 return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)
12460 def __gt__(self, o):
12461 r"""__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12462 return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)
12464 def __ge__(self, o):
12465 r"""__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12466 return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)
12468 def __le__(self, o):
12469 r"""__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12470 return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)
12473 r"""__str__(PrincipalComponentAnalysisKD self) -> std::string"""
12474 return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)
12476 def __repr__(self):
12477 r"""__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
12478 return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)
12480 def _get_as_binary(self):
12481 r"""_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
12482 return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)
12484 def _set_from_binary(self, p):
12485 r"""_set_from_binary(PrincipalComponentAnalysisKD self, PyObject * p)"""
12486 return _IMP_algebra.PrincipalComponentAnalysisKD__set_from_binary(self, p)
12488 def __getstate__(self):
12489 p = self._get_as_binary()
12490 if len(self.__dict__) > 1:
12491 d = self.__dict__.copy()
12496 def __setstate__(self, p):
12497 if not hasattr(self,
'this'):
12499 if isinstance(p, tuple):
12501 self.__dict__.update(d)
12502 return self._set_from_binary(p)
12504 __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
12507 _IMP_algebra.PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)
12511 get_principal_components(IMP::Vector< IMP::algebra::Vector1D > const & a) -> PrincipalComponentAnalysis1D
12512 get_principal_components(IMP::Vector< IMP::algebra::Vector2D > const & a) -> PrincipalComponentAnalysis2D
12513 get_principal_components(IMP::Vector< IMP::algebra::Vector3D > const & a) -> PrincipalComponentAnalysis3D
12514 get_principal_components(IMP::Vector< IMP::algebra::Vector4D > const & a) -> PrincipalComponentAnalysis4D
12515 get_principal_components(IMP::Vector< IMP::algebra::Vector5D > const & a) -> PrincipalComponentAnalysis5D
12516 get_principal_components(IMP::Vector< IMP::algebra::Vector6D > const & a) -> PrincipalComponentAnalysis6D
12517 get_principal_components(IMP::Vector< IMP::algebra::VectorKD > const & a) -> PrincipalComponentAnalysisKD
12519 return _IMP_algebra.get_principal_components(*args)
12523 get_distance(Rotation3D r0, Rotation3D r1) -> double
12524 get_distance(Line3D s, Vector3D p) -> double
12525 get_distance(Line3D a, Line3D b) -> double
12526 get_distance(Segment3D s, Vector3D p) -> double
12527 get_distance(Segment3D a, Segment3D b) -> double
12528 get_distance(Plane3D pln, Vector3D p) -> double
12529 get_distance(Vector1D a, Vector1D b) -> double
12530 get_distance(Vector2D a, Vector2D b) -> double
12531 get_distance(Vector3D a, Vector3D b) -> double
12532 get_distance(Vector4D a, Vector4D b) -> double
12533 get_distance(Vector5D a, Vector5D b) -> double
12534 get_distance(Vector6D a, Vector6D b) -> double
12535 get_distance(VectorKD a, VectorKD b) -> double
12536 get_distance(Sphere1D a, Sphere1D b) -> double
12537 get_distance(Sphere2D a, Sphere2D b) -> double
12538 get_distance(Sphere3D a, Sphere3D b) -> double
12539 get_distance(Sphere4D a, Sphere4D b) -> double
12540 get_distance(Sphere5D a, Sphere5D b) -> double
12541 get_distance(Sphere6D a, Sphere6D b) -> double
12542 get_distance(SphereKD a, SphereKD b) -> double
12544 return _IMP_algebra.get_distance(*args)
12548 get_squared_distance(Vector1D a, Vector1D b) -> double
12549 get_squared_distance(Vector2D a, Vector2D b) -> double
12550 get_squared_distance(Vector3D a, Vector3D b) -> double
12551 get_squared_distance(Vector4D a, Vector4D b) -> double
12552 get_squared_distance(Vector5D a, Vector5D b) -> double
12553 get_squared_distance(Vector6D a, Vector6D b) -> double
12554 get_squared_distance(VectorKD a, VectorKD b) -> double
12556 return _IMP_algebra.get_squared_distance(*args)
12558 def get_basis_vector_1d(coordinate):
12559 r"""get_basis_vector_1d(unsigned int coordinate) -> Vector1D"""
12560 return _IMP_algebra.get_basis_vector_1d(coordinate)
12562 def get_basis_vector_2d(coordinate):
12563 r"""get_basis_vector_2d(unsigned int coordinate) -> Vector2D"""
12564 return _IMP_algebra.get_basis_vector_2d(coordinate)
12566 def get_basis_vector_3d(coordinate):
12567 r"""get_basis_vector_3d(unsigned int coordinate) -> Vector3D"""
12568 return _IMP_algebra.get_basis_vector_3d(coordinate)
12570 def get_basis_vector_4d(coordinate):
12571 r"""get_basis_vector_4d(unsigned int coordinate) -> Vector4D"""
12572 return _IMP_algebra.get_basis_vector_4d(coordinate)
12574 def get_basis_vector_5d(coordinate):
12575 r"""get_basis_vector_5d(unsigned int coordinate) -> Vector5D"""
12576 return _IMP_algebra.get_basis_vector_5d(coordinate)
12578 def get_basis_vector_6d(coordinate):
12579 r"""get_basis_vector_6d(unsigned int coordinate) -> Vector6D"""
12580 return _IMP_algebra.get_basis_vector_6d(coordinate)
12582 def get_zero_vector_1d():
12583 r"""get_zero_vector_1d() -> Vector1D"""
12584 return _IMP_algebra.get_zero_vector_1d()
12586 def get_zero_vector_2d():
12587 r"""get_zero_vector_2d() -> Vector2D"""
12588 return _IMP_algebra.get_zero_vector_2d()
12590 def get_zero_vector_3d():
12591 r"""get_zero_vector_3d() -> Vector3D"""
12592 return _IMP_algebra.get_zero_vector_3d()
12594 def get_zero_vector_4d():
12595 r"""get_zero_vector_4d() -> Vector4D"""
12596 return _IMP_algebra.get_zero_vector_4d()
12598 def get_zero_vector_5d():
12599 r"""get_zero_vector_5d() -> Vector5D"""
12600 return _IMP_algebra.get_zero_vector_5d()
12602 def get_zero_vector_6d():
12603 r"""get_zero_vector_6d() -> Vector6D"""
12604 return _IMP_algebra.get_zero_vector_6d()
12606 def get_ones_vector_1d(v=1):
12607 r"""get_ones_vector_1d(double v=1) -> Vector1D"""
12608 return _IMP_algebra.get_ones_vector_1d(v)
12610 def get_ones_vector_2d(v=1):
12611 r"""get_ones_vector_2d(double v=1) -> Vector2D"""
12612 return _IMP_algebra.get_ones_vector_2d(v)
12614 def get_ones_vector_3d(v=1):
12615 r"""get_ones_vector_3d(double v=1) -> Vector3D"""
12616 return _IMP_algebra.get_ones_vector_3d(v)
12618 def get_ones_vector_4d(v=1):
12619 r"""get_ones_vector_4d(double v=1) -> Vector4D"""
12620 return _IMP_algebra.get_ones_vector_4d(v)
12622 def get_ones_vector_5d(v=1):
12623 r"""get_ones_vector_5d(double v=1) -> Vector5D"""
12624 return _IMP_algebra.get_ones_vector_5d(v)
12626 def get_ones_vector_6d(v=1):
12627 r"""get_ones_vector_6d(double v=1) -> Vector6D"""
12628 return _IMP_algebra.get_ones_vector_6d(v)
12630 def get_unit_bounding_box_1d():
12631 r"""get_unit_bounding_box_1d() -> BoundingBox1D"""
12632 return _IMP_algebra.get_unit_bounding_box_1d()
12634 def get_unit_bounding_box_2d():
12635 r"""get_unit_bounding_box_2d() -> BoundingBox2D"""
12636 return _IMP_algebra.get_unit_bounding_box_2d()
12638 def get_unit_bounding_box_3d():
12639 r"""get_unit_bounding_box_3d() -> BoundingBox3D"""
12640 return _IMP_algebra.get_unit_bounding_box_3d()
12642 def get_unit_bounding_box_4d():
12643 r"""get_unit_bounding_box_4d() -> BoundingBox4D"""
12644 return _IMP_algebra.get_unit_bounding_box_4d()
12646 def get_unit_bounding_box_5d():
12647 r"""get_unit_bounding_box_5d() -> BoundingBox5D"""
12648 return _IMP_algebra.get_unit_bounding_box_5d()
12650 def get_unit_bounding_box_6d():
12651 r"""get_unit_bounding_box_6d() -> BoundingBox6D"""
12652 return _IMP_algebra.get_unit_bounding_box_6d()
12654 def get_cube_1d(radius):
12655 r"""get_cube_1d(double radius) -> BoundingBox1D"""
12656 return _IMP_algebra.get_cube_1d(radius)
12658 def get_cube_2d(radius):
12659 r"""get_cube_2d(double radius) -> BoundingBox2D"""
12660 return _IMP_algebra.get_cube_2d(radius)
12662 def get_cube_3d(radius):
12663 r"""get_cube_3d(double radius) -> BoundingBox3D"""
12664 return _IMP_algebra.get_cube_3d(radius)
12666 def get_cube_4d(radius):
12667 r"""get_cube_4d(double radius) -> BoundingBox4D"""
12668 return _IMP_algebra.get_cube_4d(radius)
12670 def get_cube_5d(radius):
12671 r"""get_cube_5d(double radius) -> BoundingBox5D"""
12672 return _IMP_algebra.get_cube_5d(radius)
12674 def get_cube_6d(radius):
12675 r"""get_cube_6d(double radius) -> BoundingBox6D"""
12676 return _IMP_algebra.get_cube_6d(radius)
12678 def get_unit_sphere_1d():
12679 r"""get_unit_sphere_1d() -> Sphere1D"""
12680 return _IMP_algebra.get_unit_sphere_1d()
12682 def get_unit_sphere_2d():
12683 r"""get_unit_sphere_2d() -> Sphere2D"""
12684 return _IMP_algebra.get_unit_sphere_2d()
12686 def get_unit_sphere_3d():
12687 r"""get_unit_sphere_3d() -> Sphere3D"""
12688 return _IMP_algebra.get_unit_sphere_3d()
12690 def get_unit_sphere_4d():
12691 r"""get_unit_sphere_4d() -> Sphere4D"""
12692 return _IMP_algebra.get_unit_sphere_4d()
12694 def get_unit_sphere_5d():
12695 r"""get_unit_sphere_5d() -> Sphere5D"""
12696 return _IMP_algebra.get_unit_sphere_5d()
12698 def get_unit_sphere_6d():
12699 r"""get_unit_sphere_6d() -> Sphere6D"""
12700 return _IMP_algebra.get_unit_sphere_6d()
12704 get_interiors_intersect(Sphere1D a, Sphere1D b) -> bool
12705 get_interiors_intersect(Sphere2D a, Sphere2D b) -> bool
12706 get_interiors_intersect(Sphere3D a, Sphere3D b) -> bool
12707 get_interiors_intersect(Sphere4D a, Sphere4D b) -> bool
12708 get_interiors_intersect(Sphere5D a, Sphere5D b) -> bool
12709 get_interiors_intersect(Sphere6D a, Sphere6D b) -> bool
12710 get_interiors_intersect(SphereKD a, SphereKD b) -> bool
12711 get_interiors_intersect(BoundingBox1D a, BoundingBox1D b) -> bool
12712 get_interiors_intersect(BoundingBox2D a, BoundingBox2D b) -> bool
12713 get_interiors_intersect(BoundingBox3D a, BoundingBox3D b) -> bool
12714 get_interiors_intersect(BoundingBox4D a, BoundingBox4D b) -> bool
12715 get_interiors_intersect(BoundingBox5D a, BoundingBox5D b) -> bool
12716 get_interiors_intersect(BoundingBox6D a, BoundingBox6D b) -> bool
12717 get_interiors_intersect(BoundingBoxKD a, BoundingBoxKD b) -> bool
12719 return _IMP_algebra.get_interiors_intersect(*args)
12723 get_random_vector_on(Sphere1D a) -> Vector1D
12724 get_random_vector_on(Sphere2D a) -> Vector2D
12725 get_random_vector_on(Sphere3D a) -> Vector3D
12726 get_random_vector_on(Sphere4D a) -> Vector4D
12727 get_random_vector_on(Sphere5D a) -> Vector5D
12728 get_random_vector_on(Sphere6D a) -> Vector6D
12729 get_random_vector_on(SphereKD a) -> VectorKD
12730 get_random_vector_on(UnitSimplex1D a) -> Vector1D
12731 get_random_vector_on(UnitSimplex2D a) -> Vector2D
12732 get_random_vector_on(UnitSimplex3D a) -> Vector3D
12733 get_random_vector_on(UnitSimplex4D a) -> Vector4D
12734 get_random_vector_on(UnitSimplex5D a) -> Vector5D
12735 get_random_vector_on(UnitSimplex6D a) -> Vector6D
12736 get_random_vector_on(UnitSimplexKD a) -> VectorKD
12737 get_random_vector_on(BoundingBox1D a) -> Vector1D
12738 get_random_vector_on(BoundingBox2D a) -> Vector2D
12739 get_random_vector_on(BoundingBox3D a) -> Vector3D
12740 get_random_vector_on(BoundingBox4D a) -> Vector4D
12741 get_random_vector_on(BoundingBox5D a) -> Vector5D
12742 get_random_vector_on(BoundingBox6D a) -> Vector6D
12743 get_random_vector_on(BoundingBoxKD a) -> VectorKD
12745 return _IMP_algebra.get_random_vector_on(*args)
12749 get_random_vector_in(Cylinder3D c) -> Vector3D
12750 get_random_vector_in(Sphere1D a) -> Vector1D
12751 get_random_vector_in(Sphere2D a) -> Vector2D
12752 get_random_vector_in(Sphere3D a) -> Vector3D
12753 get_random_vector_in(Sphere4D a) -> Vector4D
12754 get_random_vector_in(Sphere5D a) -> Vector5D
12755 get_random_vector_in(Sphere6D a) -> Vector6D
12756 get_random_vector_in(SphereKD a) -> VectorKD
12757 get_random_vector_in(BoundingBox1D a) -> Vector1D
12758 get_random_vector_in(BoundingBox2D a) -> Vector2D
12759 get_random_vector_in(BoundingBox3D a) -> Vector3D
12760 get_random_vector_in(BoundingBox4D a) -> Vector4D
12761 get_random_vector_in(BoundingBox5D a) -> Vector5D
12762 get_random_vector_in(BoundingBox6D a) -> Vector6D
12763 get_random_vector_in(BoundingBoxKD a) -> VectorKD
12765 return _IMP_algebra.get_random_vector_in(*args)
12769 get_intersection(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12770 get_intersection(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12771 get_intersection(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12772 get_intersection(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12773 get_intersection(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12774 get_intersection(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12775 get_intersection(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12777 return _IMP_algebra.get_intersection(*args)
12781 get_union(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12782 get_union(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12783 get_union(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12784 get_union(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12785 get_union(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12786 get_union(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12787 get_union(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12789 return _IMP_algebra.get_union(*args)
12791 def get_bounding_box(*args):
12793 get_bounding_box(Line3D g) -> BoundingBox3D
12794 get_bounding_box(Segment3D g) -> BoundingBox3D
12795 get_bounding_box(Plane3D g) -> BoundingBox3D
12796 get_bounding_box(Cylinder3D g) -> BoundingBox3D
12797 get_bounding_box(Ellipsoid3D g) -> BoundingBox3D
12798 get_bounding_box(SpherePatch3D g) -> BoundingBox3D
12799 get_bounding_box(Cone3D g) -> BoundingBox3D
12800 get_bounding_box(Sphere1D a) -> BoundingBox1D
12801 get_bounding_box(Sphere2D a) -> BoundingBox2D
12802 get_bounding_box(Sphere3D a) -> BoundingBox3D
12803 get_bounding_box(Sphere4D a) -> BoundingBox4D
12804 get_bounding_box(Sphere5D a) -> BoundingBox5D
12805 get_bounding_box(Sphere6D a) -> BoundingBox6D
12806 get_bounding_box(SphereKD a) -> BoundingBoxKD
12808 return _IMP_algebra.get_bounding_box(*args)
12812 get_uniform_surface_cover(Cylinder3D cyl, int number_of_points) -> IMP::algebra::Vector3Ds
12813 get_uniform_surface_cover(SpherePatch3D sph, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12814 get_uniform_surface_cover(Cone3D cone, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12815 get_uniform_surface_cover(IMP::algebra::Sphere3Ds const & _in, double points_per_square_angstrom) -> IMP::algebra::Vector3Ds
12816 get_uniform_surface_cover(Sphere1D a, unsigned int const & b) -> IMP::algebra::Vector1Ds
12817 get_uniform_surface_cover(Sphere2D a, unsigned int const & b) -> IMP::algebra::Vector2Ds
12818 get_uniform_surface_cover(Sphere3D a, unsigned int const & b) -> IMP::algebra::Vector3Ds
12819 get_uniform_surface_cover(Sphere4D a, unsigned int const & b) -> IMP::algebra::Vector4Ds
12820 get_uniform_surface_cover(Sphere5D a, unsigned int const & b) -> IMP::algebra::Vector5Ds
12821 get_uniform_surface_cover(Sphere6D a, unsigned int const & b) -> IMP::algebra::Vector6Ds
12822 get_uniform_surface_cover(SphereKD a, unsigned int const & b) -> IMP::algebra::VectorKDs
12824 return _IMP_algebra.get_uniform_surface_cover(*args)
12828 get_grid_interior_cover_by_spacing(BoundingBox1D a, double const & b) -> IMP::algebra::Vector1Ds
12829 get_grid_interior_cover_by_spacing(BoundingBox2D a, double const & b) -> IMP::algebra::Vector2Ds
12830 get_grid_interior_cover_by_spacing(BoundingBox3D a, double const & b) -> IMP::algebra::Vector3Ds
12831 get_grid_interior_cover_by_spacing(BoundingBox4D a, double const & b) -> IMP::algebra::Vector4Ds
12832 get_grid_interior_cover_by_spacing(BoundingBox5D a, double const & b) -> IMP::algebra::Vector5Ds
12833 get_grid_interior_cover_by_spacing(BoundingBox6D a, double const & b) -> IMP::algebra::Vector6Ds
12834 get_grid_interior_cover_by_spacing(BoundingBoxKD a, double const & b) -> IMP::algebra::VectorKDs
12836 return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
12840 get_projected(Line3D l, Vector3D p) -> Vector3D
12841 get_projected(Line3D l, Segment3D s) -> Segment3D
12842 get_projected(UnitSimplex1D a, Vector1D b) -> Vector1D
12843 get_projected(UnitSimplex2D a, Vector2D b) -> Vector2D
12844 get_projected(UnitSimplex3D a, Vector3D b) -> Vector3D
12845 get_projected(UnitSimplex4D a, Vector4D b) -> Vector4D
12846 get_projected(UnitSimplex5D a, Vector5D b) -> Vector5D
12847 get_projected(UnitSimplex6D a, Vector6D b) -> Vector6D
12848 get_projected(UnitSimplexKD a, VectorKD b) -> VectorKD
12850 return _IMP_algebra.get_projected(*args)
12854 get_vertices(BoundingBox1D a) -> IMP::Vector< IMP::algebra::Vector1D >
12855 get_vertices(BoundingBox2D a) -> IMP::Vector< IMP::algebra::Vector2D >
12856 get_vertices(BoundingBox3D a) -> IMP::Vector< IMP::algebra::Vector3D >
12857 get_vertices(BoundingBox4D a) -> IMP::Vector< IMP::algebra::Vector4D >
12858 get_vertices(BoundingBox5D a) -> IMP::Vector< IMP::algebra::Vector5D >
12859 get_vertices(BoundingBox6D a) -> IMP::Vector< IMP::algebra::Vector6D >
12860 get_vertices(BoundingBoxKD a) -> IMP::Vector< IMP::algebra::VectorKD >
12861 get_vertices(UnitSimplex1D a) -> IMP::Vector< IMP::algebra::Vector1D >
12862 get_vertices(UnitSimplex2D a) -> IMP::Vector< IMP::algebra::Vector2D >
12863 get_vertices(UnitSimplex3D a) -> IMP::Vector< IMP::algebra::Vector3D >
12864 get_vertices(UnitSimplex4D a) -> IMP::Vector< IMP::algebra::Vector4D >
12865 get_vertices(UnitSimplex5D a) -> IMP::Vector< IMP::algebra::Vector5D >
12866 get_vertices(UnitSimplex6D a) -> IMP::Vector< IMP::algebra::Vector6D >
12867 get_vertices(UnitSimplexKD a) -> IMP::Vector< IMP::algebra::VectorKD >
12869 return _IMP_algebra.get_vertices(*args)
12873 get_increasing_from_embedded(UnitSimplex1D a, Vector1D b) -> Vector1D
12874 get_increasing_from_embedded(UnitSimplex2D a, Vector2D b) -> Vector2D
12875 get_increasing_from_embedded(UnitSimplex3D a, Vector3D b) -> Vector3D
12876 get_increasing_from_embedded(UnitSimplex4D a, Vector4D b) -> Vector4D
12877 get_increasing_from_embedded(UnitSimplex5D a, Vector5D b) -> Vector5D
12878 get_increasing_from_embedded(UnitSimplex6D a, Vector6D b) -> Vector6D
12879 get_increasing_from_embedded(UnitSimplexKD a, VectorKD b) -> VectorKD
12881 return _IMP_algebra.get_increasing_from_embedded(*args)
12885 get_embedded_from_increasing(UnitSimplex1D a, Vector1D b) -> Vector1D
12886 get_embedded_from_increasing(UnitSimplex2D a, Vector2D b) -> Vector2D
12887 get_embedded_from_increasing(UnitSimplex3D a, Vector3D b) -> Vector3D
12888 get_embedded_from_increasing(UnitSimplex4D a, Vector4D b) -> Vector4D
12889 get_embedded_from_increasing(UnitSimplex5D a, Vector5D b) -> Vector5D
12890 get_embedded_from_increasing(UnitSimplex6D a, Vector6D b) -> Vector6D
12891 get_embedded_from_increasing(UnitSimplexKD a, VectorKD b) -> VectorKD
12893 return _IMP_algebra.get_embedded_from_increasing(*args)
12894 class _AxisAnglePair(object):
12895 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,double > class."""
12897 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12898 __repr__ = _swig_repr
12900 def __init__(self, *args):
12902 __init__(_AxisAnglePair self) -> _AxisAnglePair
12903 __init__(_AxisAnglePair self, Vector3D first, double second) -> _AxisAnglePair
12904 __init__(_AxisAnglePair self, _AxisAnglePair other) -> _AxisAnglePair
12906 _IMP_algebra._AxisAnglePair_swiginit(self, _IMP_algebra.new__AxisAnglePair(*args))
12907 first = property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
12908 second = property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set, doc=
r"""second : double""")
12911 def __repr__(self):
12912 return str((self.first, self.second))
12913 def __getitem__(self, index):
12914 if not (index % 2):
12918 def __setitem__(self, index, val):
12919 if not (index % 2):
12923 __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
12926 _IMP_algebra._AxisAnglePair_swigregister(_AxisAnglePair)
12929 r"""get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 > > const & source, IMP::Vector< IMP::algebra::VectorD< 3 > > const & target) -> Transformation3D"""
12930 return _IMP_algebra.get_transformation_aligning_first_to_second(source, target)
12931 class _RotatedVector3DAdjoint(object):
12932 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,IMP::algebra::VectorD< 4 > > class."""
12934 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12935 __repr__ = _swig_repr
12937 def __init__(self, *args):
12939 __init__(_RotatedVector3DAdjoint self) -> _RotatedVector3DAdjoint
12940 __init__(_RotatedVector3DAdjoint self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
12941 __init__(_RotatedVector3DAdjoint self, _RotatedVector3DAdjoint other) -> _RotatedVector3DAdjoint
12943 _IMP_algebra._RotatedVector3DAdjoint_swiginit(self, _IMP_algebra.new__RotatedVector3DAdjoint(*args))
12944 first = property(_IMP_algebra._RotatedVector3DAdjoint_first_get, _IMP_algebra._RotatedVector3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
12945 second = property(_IMP_algebra._RotatedVector3DAdjoint_second_get, _IMP_algebra._RotatedVector3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(4)>""")
12948 def __repr__(self):
12949 return str((self.first, self.second))
12950 def __getitem__(self, index):
12951 if not (index % 2):
12955 def __setitem__(self, index, val):
12956 if not (index % 2):
12960 __swig_destroy__ = _IMP_algebra.delete__RotatedVector3DAdjoint
12963 _IMP_algebra._RotatedVector3DAdjoint_swigregister(_RotatedVector3DAdjoint)
12964 class _ComposeRotation3DAdjoint(object):
12965 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 4 > > class."""
12967 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
12968 __repr__ = _swig_repr
12970 def __init__(self, *args):
12972 __init__(_ComposeRotation3DAdjoint self) -> _ComposeRotation3DAdjoint
12973 __init__(_ComposeRotation3DAdjoint self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
12974 __init__(_ComposeRotation3DAdjoint self, _ComposeRotation3DAdjoint other) -> _ComposeRotation3DAdjoint
12976 _IMP_algebra._ComposeRotation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeRotation3DAdjoint(*args))
12977 first = property(_IMP_algebra._ComposeRotation3DAdjoint_first_get, _IMP_algebra._ComposeRotation3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(4)>""")
12978 second = property(_IMP_algebra._ComposeRotation3DAdjoint_second_get, _IMP_algebra._ComposeRotation3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(4)>""")
12981 def __repr__(self):
12982 return str((self.first, self.second))
12983 def __getitem__(self, index):
12984 if not (index % 2):
12988 def __setitem__(self, index, val):
12989 if not (index % 2):
12993 __swig_destroy__ = _IMP_algebra.delete__ComposeRotation3DAdjoint
12996 _IMP_algebra._ComposeRotation3DAdjoint_swigregister(_ComposeRotation3DAdjoint)
12997 class _Transformation3DAdjoint(object):
12998 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > class."""
13000 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13001 __repr__ = _swig_repr
13003 def __init__(self, *args):
13005 __init__(_Transformation3DAdjoint self) -> _Transformation3DAdjoint
13006 __init__(_Transformation3DAdjoint self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
13007 __init__(_Transformation3DAdjoint self, _Transformation3DAdjoint other) -> _Transformation3DAdjoint
13009 _IMP_algebra._Transformation3DAdjoint_swiginit(self, _IMP_algebra.new__Transformation3DAdjoint(*args))
13010 first = property(_IMP_algebra._Transformation3DAdjoint_first_get, _IMP_algebra._Transformation3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(4)>""")
13011 second = property(_IMP_algebra._Transformation3DAdjoint_second_get, _IMP_algebra._Transformation3DAdjoint_second_set, doc=
r"""second : IMP::algebra::VectorD<(3)>""")
13014 def __repr__(self):
13015 return str((self.first, self.second))
13016 def __getitem__(self, index):
13017 if not (index % 2):
13021 def __setitem__(self, index, val):
13022 if not (index % 2):
13026 __swig_destroy__ = _IMP_algebra.delete__Transformation3DAdjoint
13029 _IMP_algebra._Transformation3DAdjoint_swigregister(_Transformation3DAdjoint)
13030 class _TransformedVector3DAdjoint(object):
13031 r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > > class."""
13033 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13034 __repr__ = _swig_repr
13036 def __init__(self, *args):
13038 __init__(_TransformedVector3DAdjoint self) -> _TransformedVector3DAdjoint
13039 __init__(_TransformedVector3DAdjoint self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
13040 __init__(_TransformedVector3DAdjoint self, _TransformedVector3DAdjoint other) -> _TransformedVector3DAdjoint
13042 _IMP_algebra._TransformedVector3DAdjoint_swiginit(self, _IMP_algebra.new__TransformedVector3DAdjoint(*args))
13043 first = property(_IMP_algebra._TransformedVector3DAdjoint_first_get, _IMP_algebra._TransformedVector3DAdjoint_first_set, doc=
r"""first : IMP::algebra::VectorD<(3)>""")
13044 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)>)>""")
13047 def __repr__(self):
13048 return str((self.first, self.second))
13049 def __getitem__(self, index):
13050 if not (index % 2):
13054 def __setitem__(self, index, val):
13055 if not (index % 2):
13059 __swig_destroy__ = _IMP_algebra.delete__TransformedVector3DAdjoint
13062 _IMP_algebra._TransformedVector3DAdjoint_swigregister(_TransformedVector3DAdjoint)
13063 class _ComposeTransformation3DAdjoint(object):
13064 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."""
13066 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
13067 __repr__ = _swig_repr
13069 def __init__(self, *args):
13071 __init__(_ComposeTransformation3DAdjoint self) -> _ComposeTransformation3DAdjoint
13072 __init__(_ComposeTransformation3DAdjoint self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
13073 __init__(_ComposeTransformation3DAdjoint self, _ComposeTransformation3DAdjoint other) -> _ComposeTransformation3DAdjoint
13075 _IMP_algebra._ComposeTransformation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeTransformation3DAdjoint(*args))
13076 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)>)>""")
13077 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)>)>""")
13080 def __repr__(self):
13081 return str((self.first, self.second))
13082 def __getitem__(self, index):
13083 if not (index % 2):
13087 def __setitem__(self, index, val):
13088 if not (index % 2):
13092 __swig_destroy__ = _IMP_algebra.delete__ComposeTransformation3DAdjoint
13095 _IMP_algebra._ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)
13098 r"""get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13099 return _IMP_algebra.get_rmsd_transforming_first(tr, v0, v1)
13102 r"""get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13103 return _IMP_algebra.get_rmsd(v0, v1)
13105 def get_weighted_rmsd_transforming_first(tr, v0, v1, weights):
13106 r"""get_weighted_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13107 return _IMP_algebra.get_weighted_rmsd_transforming_first(tr, v0, v1, weights)
13110 r"""get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13111 return _IMP_algebra.get_weighted_rmsd(v0, v1, weights)
13113 LinearFit=LinearFit2D
13114 ParabolicFit=ParabolicFit2D
13118 r"""get_module_version() -> std::string const"""
13119 return _IMP_algebra.get_module_version()
13122 r"""get_example_path(std::string fname) -> std::string"""
13123 return _IMP_algebra.get_example_path(fname)
13126 r"""get_data_path(std::string fname) -> std::string"""
13127 return _IMP_algebra.get_data_path(fname)
13129 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.