IMP logo
IMP Reference Guide  2.20.2
The Integrative Modeling Platform
algebra/__init__.py
1 # This file was automatically generated by SWIG (https://www.swig.org).
2 # Version 4.2.1
3 #
4 # Do not make changes to this file unless you know what you are doing - modify
5 # the SWIG interface file instead.
6 
7 
8 # This wrapper is part of IMP,
9 # Copyright 2007-2024 IMP Inventors. All rights reserved.
10 
11 from __future__ import print_function, division, absolute_import
12 
13 
14 
15 from sys import version_info as _swig_python_version_info
16 import _IMP_algebra
17 
18 try:
19  import builtins as __builtin__
20 except ImportError:
21  import __builtin__
22 
23 def _swig_repr(self):
24  try:
25  strthis = "proxy of " + self.this.__repr__()
26  except __builtin__.Exception:
27  strthis = ""
28  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
29 
30 
31 def _swig_setattr_nondynamic_instance_variable(set):
32  def set_instance_attr(self, name, value):
33  if name == "this":
34  set(self, name, value)
35  elif name == "thisown":
36  self.this.own(value)
37  elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
38  set(self, name, value)
39  else:
40  raise AttributeError("You cannot add instance attributes to %s" % self)
41  return set_instance_attr
42 
43 
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):
47  set(cls, name, value)
48  else:
49  raise AttributeError("You cannot add class attributes to %s" % cls)
50  return set_class_attr
51 
52 
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"""
55  def wrapper(cls):
56  return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
57  return wrapper
58 
59 
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__)
63 
64 
65 import weakref
66 
67 class IMP_ALGEBRA_SwigPyIterator(object):
68  r"""Proxy of C++ swig::IMP_ALGEBRA_SwigPyIterator class."""
69 
70  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
71 
72  def __init__(self, *args, **kwargs):
73  raise AttributeError("No constructor defined - class is abstract")
74  __repr__ = _swig_repr
75  __swig_destroy__ = _IMP_algebra.delete_IMP_ALGEBRA_SwigPyIterator
76 
77  def value(self):
78  r"""value(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
79  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_value(self)
80 
81  def incr(self, n=1):
82  r"""incr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator"""
83  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_incr(self, n)
84 
85  def decr(self, n=1):
86  r"""decr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator"""
87  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_decr(self, n)
88 
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)
92 
93  def equal(self, x):
94  r"""equal(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
95  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_equal(self, x)
96 
97  def copy(self):
98  r"""copy(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator"""
99  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_copy(self)
100 
101  def next(self):
102  r"""next(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
103  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_next(self)
104 
105  def __next__(self):
106  r"""__next__(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
107  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___next__(self)
108 
109  def previous(self):
110  r"""previous(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
111  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_previous(self)
112 
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)
116 
117  def __eq__(self, x):
118  r"""__eq__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
119  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___eq__(self, x)
120 
121  def __ne__(self, x):
122  r"""__ne__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
123  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___ne__(self, x)
124 
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)
128 
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)
132 
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)
136 
137  def __sub__(self, *args):
138  r"""
139  __sub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator
140  __sub__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t
141  """
142  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___sub__(self, *args)
143  def __iter__(self):
144  return self
145 
146 # Register IMP_ALGEBRA_SwigPyIterator in _IMP_algebra:
147 _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_swigregister(IMP_ALGEBRA_SwigPyIterator)
148 
149 _value_types=[]
150 _object_types=[]
151 _raii_types=[]
152 _plural_types=[]
153 
154 IMP_DEBUG = _IMP_algebra.IMP_DEBUG
155 
156 IMP_RELEASE = _IMP_algebra.IMP_RELEASE
157 
158 IMP_SILENT = _IMP_algebra.IMP_SILENT
159 
160 IMP_PROGRESS = _IMP_algebra.IMP_PROGRESS
161 
162 IMP_TERSE = _IMP_algebra.IMP_TERSE
163 
164 IMP_VERBOSE = _IMP_algebra.IMP_VERBOSE
165 
166 IMP_MEMORY = _IMP_algebra.IMP_MEMORY
167 
168 IMP_NONE = _IMP_algebra.IMP_NONE
169 
170 IMP_USAGE = _IMP_algebra.IMP_USAGE
171 
172 IMP_INTERNAL = _IMP_algebra.IMP_INTERNAL
173 
174 IMP_KERNEL_HAS_LOG4CXX = _IMP_algebra.IMP_KERNEL_HAS_LOG4CXX
175 
176 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_algebra.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
177 
178 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_algebra.IMP_COMPILER_HAS_DEBUG_VECTOR
179 
180 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_algebra.IMP_COMPILER_HAS_RANDOM_SHUFFLE
181 
182 IMP_COMPILER_HAS_THREE_WAY = _IMP_algebra.IMP_COMPILER_HAS_THREE_WAY
183 
184 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_KERNEL_HAS_BOOST_RANDOM
185 
186 IMP_KERNEL_HAS_NUMPY = _IMP_algebra.IMP_KERNEL_HAS_NUMPY
187 
188 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_algebra.IMP_KERNEL_HAS_GPERFTOOLS
189 
190 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
191 
192 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
193 
194 IMPKERNEL_SHOW_WARNINGS = _IMP_algebra.IMPKERNEL_SHOW_WARNINGS
195 
196 
197 import sys
198 class _DirectorObjects(object):
199  """@internal Simple class to keep references to director objects
200  to prevent premature deletion."""
201  def __init__(self):
202  self._objects = []
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)
208  def cleanup(self):
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]
215 # Do in two steps so the references are kept until the end of the
216 # function (deleting references may trigger a fresh call to this method)
217  self._objects = objs
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()
222 
223 class _ostream(object):
224  r"""Proxy of C++ std::ostream class."""
225 
226  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
227 
228  def __init__(self, *args, **kwargs):
229  raise AttributeError("No constructor defined")
230  __repr__ = _swig_repr
231 
232  def write(self, osa_buf):
233  r"""write(_ostream self, char const * osa_buf)"""
234  return _IMP_algebra._ostream_write(self, osa_buf)
235 
236 # Register _ostream in _IMP_algebra:
237 _IMP_algebra._ostream_swigregister(_ostream)
238 IMP_C_OPEN_BINARY = _IMP_algebra.IMP_C_OPEN_BINARY
239 
240 import IMP
241 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_FILESYSTEM
242 
243 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
244 
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_CGAL_HAS_BOOST_RANDOM
246 
247 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_SYSTEM
248 
249 IMP_CGAL_HAS_NUMPY = _IMP_algebra.IMP_CGAL_HAS_NUMPY
250 
251 IMPCGAL_SHOW_WARNINGS = _IMP_algebra.IMPCGAL_SHOW_WARNINGS
252 
253 import IMP.cgal
254 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_IMP_CGAL
255 
256 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
257 
258 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
259 
260 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_RANDOM
261 
262 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SYSTEM
263 
264 IMP_ALGEBRA_HAS_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_CGAL
265 
266 IMP_ALGEBRA_HAS_NUMPY = _IMP_algebra.IMP_ALGEBRA_HAS_NUMPY
267 
268 IMP_ALGEBRA_HAS_ANN = _IMP_algebra.IMP_ALGEBRA_HAS_ANN
269 
270 IMPALGEBRA_SHOW_WARNINGS = _IMP_algebra.IMPALGEBRA_SHOW_WARNINGS
271 
272 
273 def get_vector(v):
274  try:
275  return v.get_coordinates()
276  except:
277  return v
278 def get_sphere(v):
279  try:
280  return v.get_sphere()
281  except:
282  return v
283 
284 
285 _object_types.append("VectorKDMetric")
286 
287 
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)
291 
292 _object_types.append("EuclideanVectorKDMetric")
293 
294 
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)
298 
299 _object_types.append("MaxVectorKDMetric")
300 
301 
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)
305 
306 _object_types.append("DynamicNearestNeighbor3D")
307 
308 
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)
312 
313 Rotation2Ds=list
314 _plural_types.append("Rotation2Ds")
315 _value_types.append("Rotation2D")
316 
317 
318 Rotation3Ds=list
319 _plural_types.append("Rotation3Ds")
320 _value_types.append("Rotation3D")
321 
322 
323 Reflection3Ds=list
324 _plural_types.append("Reflection3Ds")
325 _value_types.append("Reflection3D")
326 
327 
328 Transformation2Ds=list
329 _plural_types.append("Transformation2Ds")
330 _value_types.append("Transformation2D")
331 
332 
333 Transformation3Ds=list
334 _plural_types.append("Transformation3Ds")
335 _value_types.append("Transformation3D")
336 
337 
338 SphericalVector3Ds=list
339 _plural_types.append("SphericalVector3Ds")
340 _value_types.append("SphericalVector3D")
341 
342 
343 Triangle3Ds=list
344 _plural_types.append("Triangle3Ds")
345 _value_types.append("Triangle3D")
346 
347 
348 Cone3Ds=list
349 _plural_types.append("Cone3Ds")
350 _value_types.append("Cone3D")
351 
352 
353 Cylinder3Ds=list
354 _plural_types.append("Cylinder3Ds")
355 _value_types.append("Cylinder3D")
356 
357 
358 Ellipsoid3Ds=list
359 _plural_types.append("Ellipsoid3Ds")
360 _value_types.append("Ellipsoid3D")
361 
362 
363 Line3Ds=list
364 _plural_types.append("Line3Ds")
365 _value_types.append("Line3D")
366 
367 
368 Plane3Ds=list
369 _plural_types.append("Plane3Ds")
370 _value_types.append("Plane3D")
371 
372 
373 Segment3Ds=list
374 _plural_types.append("Segment3Ds")
375 _value_types.append("Segment3D")
376 
377 
378 SpherePatch3Ds=list
379 _plural_types.append("SpherePatch3Ds")
380 _value_types.append("SpherePatch3D")
381 
382 
383 ConnollySurfacePoints=list
384 _plural_types.append("ConnollySurfacePoints")
385 _value_types.append("ConnollySurfacePoint")
386 
387 
388 Sphere1Ds=list
389 _plural_types.append("Sphere1Ds")
390 _value_types.append("Sphere1D")
391 
392 
393 Sphere2Ds=list
394 _plural_types.append("Sphere2Ds")
395 _value_types.append("Sphere2D")
396 
397 
398 Sphere3Ds=list
399 _plural_types.append("Sphere3Ds")
400 _value_types.append("Sphere3D")
401 
402 
403 Sphere4Ds=list
404 _plural_types.append("Sphere4Ds")
405 _value_types.append("Sphere4D")
406 
407 
408 Sphere5Ds=list
409 _plural_types.append("Sphere5Ds")
410 _value_types.append("Sphere5D")
411 
412 
413 Sphere6Ds=list
414 _plural_types.append("Sphere6Ds")
415 _value_types.append("Sphere6D")
416 
417 
418 Sphere1Ds=list
419 _plural_types.append("Sphere1Ds")
420 _value_types.append("SphereD<1>")
421 
422 
423 Sphere2Ds=list
424 _plural_types.append("Sphere2Ds")
425 _value_types.append("SphereD<2>")
426 
427 
428 Sphere3Ds=list
429 _plural_types.append("Sphere3Ds")
430 _value_types.append("SphereD<3>")
431 
432 
433 Sphere4Ds=list
434 _plural_types.append("Sphere4Ds")
435 _value_types.append("SphereD<4>")
436 
437 
438 Sphere5Ds=list
439 _plural_types.append("Sphere5Ds")
440 _value_types.append("SphereD<5>")
441 
442 
443 Sphere6Ds=list
444 _plural_types.append("Sphere6Ds")
445 _value_types.append("SphereD<6>")
446 
447 
448 SphereKDs=list
449 _plural_types.append("SphereKDs")
450 _value_types.append("SphereKD")
451 
452 
453 SphereKDs=list
454 _plural_types.append("SphereKDs")
455 _value_types.append("SphereD<-1>")
456 
457 
458 UnitSimplex1Ds=list
459 _plural_types.append("UnitSimplex1Ds")
460 _value_types.append("UnitSimplex1D")
461 
462 
463 UnitSimplex2Ds=list
464 _plural_types.append("UnitSimplex2Ds")
465 _value_types.append("UnitSimplex2D")
466 
467 
468 UnitSimplex3Ds=list
469 _plural_types.append("UnitSimplex3Ds")
470 _value_types.append("UnitSimplex3D")
471 
472 
473 UnitSimplex4Ds=list
474 _plural_types.append("UnitSimplex4Ds")
475 _value_types.append("UnitSimplex4D")
476 
477 
478 UnitSimplex5Ds=list
479 _plural_types.append("UnitSimplex5Ds")
480 _value_types.append("UnitSimplex5D")
481 
482 
483 UnitSimplex6Ds=list
484 _plural_types.append("UnitSimplex6Ds")
485 _value_types.append("UnitSimplex6D")
486 
487 
488 UnitSimplex1Ds=list
489 _plural_types.append("UnitSimplex1Ds")
490 _value_types.append("UnitSimplexD<1>")
491 
492 
493 UnitSimplex2Ds=list
494 _plural_types.append("UnitSimplex2Ds")
495 _value_types.append("UnitSimplexD<2>")
496 
497 
498 UnitSimplex3Ds=list
499 _plural_types.append("UnitSimplex3Ds")
500 _value_types.append("UnitSimplexD<3>")
501 
502 
503 UnitSimplex4Ds=list
504 _plural_types.append("UnitSimplex4Ds")
505 _value_types.append("UnitSimplexD<4>")
506 
507 
508 UnitSimplex5Ds=list
509 _plural_types.append("UnitSimplex5Ds")
510 _value_types.append("UnitSimplexD<5>")
511 
512 
513 UnitSimplex6Ds=list
514 _plural_types.append("UnitSimplex6Ds")
515 _value_types.append("UnitSimplexD<6>")
516 
517 
518 UnitSimplexKDs=list
519 _plural_types.append("UnitSimplexKDs")
520 _value_types.append("UnitSimplexKD")
521 
522 
523 UnitSimplexKDs=list
524 _plural_types.append("UnitSimplexKDs")
525 _value_types.append("UnitSimplexD<-1>")
526 
527 
528 BoundingBox1Ds=list
529 _plural_types.append("BoundingBox1Ds")
530 _value_types.append("BoundingBox1D")
531 
532 
533 BoundingBox2Ds=list
534 _plural_types.append("BoundingBox2Ds")
535 _value_types.append("BoundingBox2D")
536 
537 
538 BoundingBox3Ds=list
539 _plural_types.append("BoundingBox3Ds")
540 _value_types.append("BoundingBox3D")
541 
542 
543 BoundingBox4Ds=list
544 _plural_types.append("BoundingBox4Ds")
545 _value_types.append("BoundingBox4D")
546 
547 
548 BoundingBox5Ds=list
549 _plural_types.append("BoundingBox5Ds")
550 _value_types.append("BoundingBox5D")
551 
552 
553 BoundingBox6Ds=list
554 _plural_types.append("BoundingBox6Ds")
555 _value_types.append("BoundingBox6D")
556 
557 
558 BoundingBox1Ds=list
559 _plural_types.append("BoundingBox1Ds")
560 _value_types.append("BoundingBoxD<1>")
561 
562 
563 BoundingBox2Ds=list
564 _plural_types.append("BoundingBox2Ds")
565 _value_types.append("BoundingBoxD<2>")
566 
567 
568 BoundingBox3Ds=list
569 _plural_types.append("BoundingBox3Ds")
570 _value_types.append("BoundingBoxD<3>")
571 
572 
573 BoundingBox4Ds=list
574 _plural_types.append("BoundingBox4Ds")
575 _value_types.append("BoundingBoxD<4>")
576 
577 
578 BoundingBox5Ds=list
579 _plural_types.append("BoundingBox5Ds")
580 _value_types.append("BoundingBoxD<5>")
581 
582 
583 BoundingBox6Ds=list
584 _plural_types.append("BoundingBox6Ds")
585 _value_types.append("BoundingBoxD<6>")
586 
587 
588 BoundingBoxKDs=list
589 _plural_types.append("BoundingBoxKDs")
590 _value_types.append("BoundingBoxKD")
591 
592 
593 BoundingBoxKDs=list
594 _plural_types.append("BoundingBoxKDs")
595 _value_types.append("BoundingBoxD<-1>")
596 
597 
598 PrincipalComponentAnalysis1Ds=list
599 _plural_types.append("PrincipalComponentAnalysis1Ds")
600 _value_types.append("PrincipalComponentAnalysis1D")
601 
602 
603 PrincipalComponentAnalysis2Ds=list
604 _plural_types.append("PrincipalComponentAnalysis2Ds")
605 _value_types.append("PrincipalComponentAnalysis2D")
606 
607 
608 PrincipalComponentAnalysis3Ds=list
609 _plural_types.append("PrincipalComponentAnalysis3Ds")
610 _value_types.append("PrincipalComponentAnalysis3D")
611 
612 
613 PrincipalComponentAnalysis4Ds=list
614 _plural_types.append("PrincipalComponentAnalysis4Ds")
615 _value_types.append("PrincipalComponentAnalysis4D")
616 
617 
618 PrincipalComponentAnalysis5Ds=list
619 _plural_types.append("PrincipalComponentAnalysis5Ds")
620 _value_types.append("PrincipalComponentAnalysis5D")
621 
622 
623 PrincipalComponentAnalysis6Ds=list
624 _plural_types.append("PrincipalComponentAnalysis6Ds")
625 _value_types.append("PrincipalComponentAnalysis6D")
626 
627 
628 PrincipalComponentAnalysis1Ds=list
629 _plural_types.append("PrincipalComponentAnalysis1Ds")
630 _value_types.append("PrincipalComponentAnalysisD<1>")
631 
632 
633 PrincipalComponentAnalysis2Ds=list
634 _plural_types.append("PrincipalComponentAnalysis2Ds")
635 _value_types.append("PrincipalComponentAnalysisD<2>")
636 
637 
638 PrincipalComponentAnalysis3Ds=list
639 _plural_types.append("PrincipalComponentAnalysis3Ds")
640 _value_types.append("PrincipalComponentAnalysisD<3>")
641 
642 
643 PrincipalComponentAnalysis4Ds=list
644 _plural_types.append("PrincipalComponentAnalysis4Ds")
645 _value_types.append("PrincipalComponentAnalysisD<4>")
646 
647 
648 PrincipalComponentAnalysis5Ds=list
649 _plural_types.append("PrincipalComponentAnalysis5Ds")
650 _value_types.append("PrincipalComponentAnalysisD<5>")
651 
652 
653 PrincipalComponentAnalysis6Ds=list
654 _plural_types.append("PrincipalComponentAnalysis6Ds")
655 _value_types.append("PrincipalComponentAnalysisD<6>")
656 
657 
658 PrincipalComponentAnalysisKDs=list
659 _plural_types.append("PrincipalComponentAnalysisKDs")
660 _value_types.append("PrincipalComponentAnalysisKD")
661 
662 
663 PrincipalComponentAnalysisKDs=list
664 _plural_types.append("PrincipalComponentAnalysisKDs")
665 _value_types.append("PrincipalComponentAnalysisD<-1>")
666 
667 
668 _object_types.append("NearestNeighbor1D")
669 
670 
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)
674 
675 _object_types.append("NearestNeighbor2D")
676 
677 
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)
681 
682 _object_types.append("NearestNeighbor3D")
683 
684 
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)
688 
689 _object_types.append("NearestNeighbor4D")
690 
691 
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)
695 
696 _object_types.append("NearestNeighbor5D")
697 
698 
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)
702 
703 _object_types.append("NearestNeighbor6D")
704 
705 
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)
709 
710 _object_types.append("NearestNeighborKD")
711 
712 
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)
716 
717 ReferenceFrame3Ds=list
718 _plural_types.append("ReferenceFrame3Ds")
719 _value_types.append("ReferenceFrame3D")
720 
721 
722 Gaussian3Ds=list
723 _plural_types.append("Gaussian3Ds")
724 _value_types.append("Gaussian3D")
725 
726 
727 DefaultEmbedding1Ds=list
728 _plural_types.append("DefaultEmbedding1Ds")
729 _value_types.append("DefaultEmbedding1D")
730 
731 
732 DefaultEmbedding2Ds=list
733 _plural_types.append("DefaultEmbedding2Ds")
734 _value_types.append("DefaultEmbedding2D")
735 
736 
737 DefaultEmbedding3Ds=list
738 _plural_types.append("DefaultEmbedding3Ds")
739 _value_types.append("DefaultEmbedding3D")
740 
741 
742 DefaultEmbedding4Ds=list
743 _plural_types.append("DefaultEmbedding4Ds")
744 _value_types.append("DefaultEmbedding4D")
745 
746 
747 DefaultEmbedding5Ds=list
748 _plural_types.append("DefaultEmbedding5Ds")
749 _value_types.append("DefaultEmbedding5D")
750 
751 
752 DefaultEmbedding6Ds=list
753 _plural_types.append("DefaultEmbedding6Ds")
754 _value_types.append("DefaultEmbedding6D")
755 
756 
757 DefaultEmbedding1Ds=list
758 _plural_types.append("DefaultEmbedding1Ds")
759 _value_types.append("DefaultEmbeddingD<1>")
760 
761 
762 DefaultEmbedding2Ds=list
763 _plural_types.append("DefaultEmbedding2Ds")
764 _value_types.append("DefaultEmbeddingD<2>")
765 
766 
767 DefaultEmbedding3Ds=list
768 _plural_types.append("DefaultEmbedding3Ds")
769 _value_types.append("DefaultEmbeddingD<3>")
770 
771 
772 DefaultEmbedding4Ds=list
773 _plural_types.append("DefaultEmbedding4Ds")
774 _value_types.append("DefaultEmbeddingD<4>")
775 
776 
777 DefaultEmbedding5Ds=list
778 _plural_types.append("DefaultEmbedding5Ds")
779 _value_types.append("DefaultEmbeddingD<5>")
780 
781 
782 DefaultEmbedding6Ds=list
783 _plural_types.append("DefaultEmbedding6Ds")
784 _value_types.append("DefaultEmbeddingD<6>")
785 
786 
787 DefaultEmbeddingKDs=list
788 _plural_types.append("DefaultEmbeddingKDs")
789 _value_types.append("DefaultEmbeddingKD")
790 
791 
792 DefaultEmbeddingKDs=list
793 _plural_types.append("DefaultEmbeddingKDs")
794 _value_types.append("DefaultEmbeddingD<-1>")
795 
796 
797 LogEmbedding1Ds=list
798 _plural_types.append("LogEmbedding1Ds")
799 _value_types.append("LogEmbedding1D")
800 
801 
802 LogEmbedding2Ds=list
803 _plural_types.append("LogEmbedding2Ds")
804 _value_types.append("LogEmbedding2D")
805 
806 
807 LogEmbedding3Ds=list
808 _plural_types.append("LogEmbedding3Ds")
809 _value_types.append("LogEmbedding3D")
810 
811 
812 LogEmbedding4Ds=list
813 _plural_types.append("LogEmbedding4Ds")
814 _value_types.append("LogEmbedding4D")
815 
816 
817 LogEmbedding5Ds=list
818 _plural_types.append("LogEmbedding5Ds")
819 _value_types.append("LogEmbedding5D")
820 
821 
822 LogEmbedding6Ds=list
823 _plural_types.append("LogEmbedding6Ds")
824 _value_types.append("LogEmbedding6D")
825 
826 
827 LogEmbedding1Ds=list
828 _plural_types.append("LogEmbedding1Ds")
829 _value_types.append("LogEmbeddingD<1>")
830 
831 
832 LogEmbedding2Ds=list
833 _plural_types.append("LogEmbedding2Ds")
834 _value_types.append("LogEmbeddingD<2>")
835 
836 
837 LogEmbedding3Ds=list
838 _plural_types.append("LogEmbedding3Ds")
839 _value_types.append("LogEmbeddingD<3>")
840 
841 
842 LogEmbedding4Ds=list
843 _plural_types.append("LogEmbedding4Ds")
844 _value_types.append("LogEmbeddingD<4>")
845 
846 
847 LogEmbedding5Ds=list
848 _plural_types.append("LogEmbedding5Ds")
849 _value_types.append("LogEmbeddingD<5>")
850 
851 
852 LogEmbedding6Ds=list
853 _plural_types.append("LogEmbedding6Ds")
854 _value_types.append("LogEmbeddingD<6>")
855 
856 
857 LogEmbeddingKDs=list
858 _plural_types.append("LogEmbeddingKDs")
859 _value_types.append("LogEmbeddingKD")
860 
861 
862 LogEmbeddingKDs=list
863 _plural_types.append("LogEmbeddingKDs")
864 _value_types.append("LogEmbeddingD<-1>")
865 
866 
867 GridIndex1Ds=list
868 _plural_types.append("GridIndex1Ds")
869 _value_types.append("GridIndex1D")
870 
871 
872 GridIndex2Ds=list
873 _plural_types.append("GridIndex2Ds")
874 _value_types.append("GridIndex2D")
875 
876 
877 GridIndex3Ds=list
878 _plural_types.append("GridIndex3Ds")
879 _value_types.append("GridIndex3D")
880 
881 
882 GridIndex4Ds=list
883 _plural_types.append("GridIndex4Ds")
884 _value_types.append("GridIndex4D")
885 
886 
887 GridIndex5Ds=list
888 _plural_types.append("GridIndex5Ds")
889 _value_types.append("GridIndex5D")
890 
891 
892 GridIndex6Ds=list
893 _plural_types.append("GridIndex6Ds")
894 _value_types.append("GridIndex6D")
895 
896 
897 GridIndex1Ds=list
898 _plural_types.append("GridIndex1Ds")
899 _value_types.append("GridIndexD<1>")
900 
901 
902 GridIndex2Ds=list
903 _plural_types.append("GridIndex2Ds")
904 _value_types.append("GridIndexD<2>")
905 
906 
907 GridIndex3Ds=list
908 _plural_types.append("GridIndex3Ds")
909 _value_types.append("GridIndexD<3>")
910 
911 
912 GridIndex4Ds=list
913 _plural_types.append("GridIndex4Ds")
914 _value_types.append("GridIndexD<4>")
915 
916 
917 GridIndex5Ds=list
918 _plural_types.append("GridIndex5Ds")
919 _value_types.append("GridIndexD<5>")
920 
921 
922 GridIndex6Ds=list
923 _plural_types.append("GridIndex6Ds")
924 _value_types.append("GridIndexD<6>")
925 
926 
927 GridIndexKDs=list
928 _plural_types.append("GridIndexKDs")
929 _value_types.append("GridIndexKD")
930 
931 
932 GridIndexKDs=list
933 _plural_types.append("GridIndexKDs")
934 _value_types.append("GridIndexD<-1>")
935 
936 
937 ExtendedGridIndex1Ds=list
938 _plural_types.append("ExtendedGridIndex1Ds")
939 _value_types.append("ExtendedGridIndex1D")
940 
941 
942 ExtendedGridIndex2Ds=list
943 _plural_types.append("ExtendedGridIndex2Ds")
944 _value_types.append("ExtendedGridIndex2D")
945 
946 
947 ExtendedGridIndex3Ds=list
948 _plural_types.append("ExtendedGridIndex3Ds")
949 _value_types.append("ExtendedGridIndex3D")
950 
951 
952 ExtendedGridIndex4Ds=list
953 _plural_types.append("ExtendedGridIndex4Ds")
954 _value_types.append("ExtendedGridIndex4D")
955 
956 
957 ExtendedGridIndex5Ds=list
958 _plural_types.append("ExtendedGridIndex5Ds")
959 _value_types.append("ExtendedGridIndex5D")
960 
961 
962 ExtendedGridIndex6Ds=list
963 _plural_types.append("ExtendedGridIndex6Ds")
964 _value_types.append("ExtendedGridIndex6D")
965 
966 
967 ExtendedGridIndex1Ds=list
968 _plural_types.append("ExtendedGridIndex1Ds")
969 _value_types.append("ExtendedGridIndexD<1>")
970 
971 
972 ExtendedGridIndex2Ds=list
973 _plural_types.append("ExtendedGridIndex2Ds")
974 _value_types.append("ExtendedGridIndexD<2>")
975 
976 
977 ExtendedGridIndex3Ds=list
978 _plural_types.append("ExtendedGridIndex3Ds")
979 _value_types.append("ExtendedGridIndexD<3>")
980 
981 
982 ExtendedGridIndex4Ds=list
983 _plural_types.append("ExtendedGridIndex4Ds")
984 _value_types.append("ExtendedGridIndexD<4>")
985 
986 
987 ExtendedGridIndex5Ds=list
988 _plural_types.append("ExtendedGridIndex5Ds")
989 _value_types.append("ExtendedGridIndexD<5>")
990 
991 
992 ExtendedGridIndex6Ds=list
993 _plural_types.append("ExtendedGridIndex6Ds")
994 _value_types.append("ExtendedGridIndexD<6>")
995 
996 
997 ExtendedGridIndexKDs=list
998 _plural_types.append("ExtendedGridIndexKDs")
999 _value_types.append("ExtendedGridIndexKD")
1000 
1001 
1002 ExtendedGridIndexKDs=list
1003 _plural_types.append("ExtendedGridIndexKDs")
1004 _value_types.append("ExtendedGridIndexD<-1>")
1005 
1006 
1007 BoundedGridRange1Ds=list
1008 _plural_types.append("BoundedGridRange1Ds")
1009 _value_types.append("BoundedGridRange1D")
1010 
1011 
1012 BoundedGridRange2Ds=list
1013 _plural_types.append("BoundedGridRange2Ds")
1014 _value_types.append("BoundedGridRange2D")
1015 
1016 
1017 BoundedGridRange3Ds=list
1018 _plural_types.append("BoundedGridRange3Ds")
1019 _value_types.append("BoundedGridRange3D")
1020 
1021 
1022 BoundedGridRange4Ds=list
1023 _plural_types.append("BoundedGridRange4Ds")
1024 _value_types.append("BoundedGridRange4D")
1025 
1026 
1027 BoundedGridRange5Ds=list
1028 _plural_types.append("BoundedGridRange5Ds")
1029 _value_types.append("BoundedGridRange5D")
1030 
1031 
1032 BoundedGridRange6Ds=list
1033 _plural_types.append("BoundedGridRange6Ds")
1034 _value_types.append("BoundedGridRange6D")
1035 
1036 
1037 BoundedGridRange1Ds=list
1038 _plural_types.append("BoundedGridRange1Ds")
1039 _value_types.append("BoundedGridRangeD<1>")
1040 
1041 
1042 BoundedGridRange2Ds=list
1043 _plural_types.append("BoundedGridRange2Ds")
1044 _value_types.append("BoundedGridRangeD<2>")
1045 
1046 
1047 BoundedGridRange3Ds=list
1048 _plural_types.append("BoundedGridRange3Ds")
1049 _value_types.append("BoundedGridRangeD<3>")
1050 
1051 
1052 BoundedGridRange4Ds=list
1053 _plural_types.append("BoundedGridRange4Ds")
1054 _value_types.append("BoundedGridRangeD<4>")
1055 
1056 
1057 BoundedGridRange5Ds=list
1058 _plural_types.append("BoundedGridRange5Ds")
1059 _value_types.append("BoundedGridRangeD<5>")
1060 
1061 
1062 BoundedGridRange6Ds=list
1063 _plural_types.append("BoundedGridRange6Ds")
1064 _value_types.append("BoundedGridRangeD<6>")
1065 
1066 
1067 BoundedGridRangeKDs=list
1068 _plural_types.append("BoundedGridRangeKDs")
1069 _value_types.append("BoundedGridRangeKD")
1070 
1071 
1072 BoundedGridRangeKDs=list
1073 _plural_types.append("BoundedGridRangeKDs")
1074 _value_types.append("BoundedGridRangeD<-1>")
1075 
1076 
1077 UnboundedGridRange1Ds=list
1078 _plural_types.append("UnboundedGridRange1Ds")
1079 _value_types.append("UnboundedGridRange1D")
1080 
1081 
1082 UnboundedGridRange2Ds=list
1083 _plural_types.append("UnboundedGridRange2Ds")
1084 _value_types.append("UnboundedGridRange2D")
1085 
1086 
1087 UnboundedGridRange3Ds=list
1088 _plural_types.append("UnboundedGridRange3Ds")
1089 _value_types.append("UnboundedGridRange3D")
1090 
1091 
1092 UnboundedGridRange4Ds=list
1093 _plural_types.append("UnboundedGridRange4Ds")
1094 _value_types.append("UnboundedGridRange4D")
1095 
1096 
1097 UnboundedGridRange5Ds=list
1098 _plural_types.append("UnboundedGridRange5Ds")
1099 _value_types.append("UnboundedGridRange5D")
1100 
1101 
1102 UnboundedGridRange6Ds=list
1103 _plural_types.append("UnboundedGridRange6Ds")
1104 _value_types.append("UnboundedGridRange6D")
1105 
1106 
1107 UnboundedGridRange1Ds=list
1108 _plural_types.append("UnboundedGridRange1Ds")
1109 _value_types.append("UnboundedGridRangeD<1>")
1110 
1111 
1112 UnboundedGridRange2Ds=list
1113 _plural_types.append("UnboundedGridRange2Ds")
1114 _value_types.append("UnboundedGridRangeD<2>")
1115 
1116 
1117 UnboundedGridRange3Ds=list
1118 _plural_types.append("UnboundedGridRange3Ds")
1119 _value_types.append("UnboundedGridRangeD<3>")
1120 
1121 
1122 UnboundedGridRange4Ds=list
1123 _plural_types.append("UnboundedGridRange4Ds")
1124 _value_types.append("UnboundedGridRangeD<4>")
1125 
1126 
1127 UnboundedGridRange5Ds=list
1128 _plural_types.append("UnboundedGridRange5Ds")
1129 _value_types.append("UnboundedGridRangeD<5>")
1130 
1131 
1132 UnboundedGridRange6Ds=list
1133 _plural_types.append("UnboundedGridRange6Ds")
1134 _value_types.append("UnboundedGridRangeD<6>")
1135 
1136 
1137 UnboundedGridRangeKDs=list
1138 _plural_types.append("UnboundedGridRangeKDs")
1139 _value_types.append("UnboundedGridRangeKD")
1140 
1141 
1142 UnboundedGridRangeKDs=list
1143 _plural_types.append("UnboundedGridRangeKDs")
1144 _value_types.append("UnboundedGridRangeD<-1>")
1145 
1146 
1147 LinearFit2Ds=list
1148 _plural_types.append("LinearFit2Ds")
1149 _value_types.append("LinearFit2D")
1150 
1151 
1152 ParabolicFit2Ds=list
1153 _plural_types.append("ParabolicFit2Ds")
1154 _value_types.append("ParabolicFit2D")
1155 
1156 
1157 FixedXYZs=list
1158 _plural_types.append("FixedXYZs")
1159 _value_types.append("FixedXYZ")
1160 
1161 class _GeometricPrimitive1D(object):
1162  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 1 > class."""
1163 
1164  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1165 
1166  def __init__(self, *args, **kwargs):
1167  raise AttributeError("No constructor defined")
1168  __repr__ = _swig_repr
1169  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive1D
1170 
1171 # Register _GeometricPrimitive1D in _IMP_algebra:
1172 _IMP_algebra._GeometricPrimitive1D_swigregister(_GeometricPrimitive1D)
1173 class _GeometricPrimitive2D(object):
1174  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 2 > class."""
1175 
1176  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1177 
1178  def __init__(self, *args, **kwargs):
1179  raise AttributeError("No constructor defined")
1180  __repr__ = _swig_repr
1181  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive2D
1182 
1183 # Register _GeometricPrimitive2D in _IMP_algebra:
1184 _IMP_algebra._GeometricPrimitive2D_swigregister(_GeometricPrimitive2D)
1185 class _GeometricPrimitive3D(object):
1186  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 3 > class."""
1187 
1188  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1189 
1190  def __init__(self, *args, **kwargs):
1191  raise AttributeError("No constructor defined")
1192  __repr__ = _swig_repr
1193  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive3D
1194 
1195 # Register _GeometricPrimitive3D in _IMP_algebra:
1196 _IMP_algebra._GeometricPrimitive3D_swigregister(_GeometricPrimitive3D)
1197 class _GeometricPrimitive4D(object):
1198  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 4 > class."""
1199 
1200  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1201 
1202  def __init__(self, *args, **kwargs):
1203  raise AttributeError("No constructor defined")
1204  __repr__ = _swig_repr
1205  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive4D
1206 
1207 # Register _GeometricPrimitive4D in _IMP_algebra:
1208 _IMP_algebra._GeometricPrimitive4D_swigregister(_GeometricPrimitive4D)
1209 class _GeometricPrimitive5D(object):
1210  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 5 > class."""
1211 
1212  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1213 
1214  def __init__(self, *args, **kwargs):
1215  raise AttributeError("No constructor defined")
1216  __repr__ = _swig_repr
1217  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive5D
1218 
1219 # Register _GeometricPrimitive5D in _IMP_algebra:
1220 _IMP_algebra._GeometricPrimitive5D_swigregister(_GeometricPrimitive5D)
1221 class _GeometricPrimitive6D(object):
1222  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< 6 > class."""
1223 
1224  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1225 
1226  def __init__(self, *args, **kwargs):
1227  raise AttributeError("No constructor defined")
1228  __repr__ = _swig_repr
1229  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive6D
1230 
1231 # Register _GeometricPrimitive6D in _IMP_algebra:
1232 _IMP_algebra._GeometricPrimitive6D_swigregister(_GeometricPrimitive6D)
1233 class _GeometricPrimitiveKD(object):
1234  r"""Proxy of C++ IMP::algebra::GeometricPrimitiveD< -1 > class."""
1235 
1236  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1237 
1238  def __init__(self, *args, **kwargs):
1239  raise AttributeError("No constructor defined")
1240  __repr__ = _swig_repr
1241  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitiveKD
1242 
1243 # Register _GeometricPrimitiveKD in _IMP_algebra:
1244 _IMP_algebra._GeometricPrimitiveKD_swigregister(_GeometricPrimitiveKD)
1245 
1246 Vector1Ds=list
1247 _plural_types.append("Vector1Ds")
1248 _value_types.append("Vector1D")
1249 
1250 
1251 Vector2Ds=list
1252 _plural_types.append("Vector2Ds")
1253 _value_types.append("Vector2D")
1254 
1255 
1256 Vector3Ds=list
1257 _plural_types.append("Vector3Ds")
1258 _value_types.append("Vector3D")
1259 
1260 
1261 Vector4Ds=list
1262 _plural_types.append("Vector4Ds")
1263 _value_types.append("Vector4D")
1264 
1265 
1266 Vector5Ds=list
1267 _plural_types.append("Vector5Ds")
1268 _value_types.append("Vector5D")
1269 
1270 
1271 Vector6Ds=list
1272 _plural_types.append("Vector6Ds")
1273 _value_types.append("Vector6D")
1274 
1275 
1276 Vector1Ds=list
1277 _plural_types.append("Vector1Ds")
1278 _value_types.append("VectorD<1>")
1279 
1280 
1281 Vector2Ds=list
1282 _plural_types.append("Vector2Ds")
1283 _value_types.append("VectorD<2>")
1284 
1285 
1286 Vector3Ds=list
1287 _plural_types.append("Vector3Ds")
1288 _value_types.append("VectorD<3>")
1289 
1290 
1291 Vector4Ds=list
1292 _plural_types.append("Vector4Ds")
1293 _value_types.append("VectorD<4>")
1294 
1295 
1296 Vector5Ds=list
1297 _plural_types.append("Vector5Ds")
1298 _value_types.append("VectorD<5>")
1299 
1300 
1301 Vector6Ds=list
1302 _plural_types.append("Vector6Ds")
1303 _value_types.append("VectorD<6>")
1304 
1305 
1306 VectorKDs=list
1307 _plural_types.append("VectorKDs")
1308 _value_types.append("VectorKD")
1309 
1310 
1311 VectorKDs=list
1312 _plural_types.append("VectorKDs")
1313 _value_types.append("VectorD<-1>")
1314 
1315 class _VectorBaseKD(_GeometricPrimitiveKD):
1316  r"""Proxy of C++ IMP::algebra::VectorBaseD< -1 > class."""
1317 
1318  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1319  __repr__ = _swig_repr
1320 
1321  def __init__(self):
1322  r"""__init__(_VectorBaseKD self) -> _VectorBaseKD"""
1323  _IMP_algebra._VectorBaseKD_swiginit(self, _IMP_algebra.new__VectorBaseKD())
1324 
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)
1328 
1329  def get_squared_magnitude(self):
1330  r"""get_squared_magnitude(_VectorBaseKD self) -> double"""
1331  return _IMP_algebra._VectorBaseKD_get_squared_magnitude(self)
1332 
1333  def get_magnitude(self):
1334  r"""get_magnitude(_VectorBaseKD self) -> double"""
1335  return _IMP_algebra._VectorBaseKD_get_magnitude(self)
1336 
1337  def __mul__(self, o):
1338  r"""__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1339  return _IMP_algebra._VectorBaseKD___mul__(self, o)
1340 
1341  def __iadd__(self, o):
1342  r"""__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1343  return _IMP_algebra._VectorBaseKD___iadd__(self, o)
1344 
1345  def __isub__(self, o):
1346  r"""__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1347  return _IMP_algebra._VectorBaseKD___isub__(self, o)
1348 
1349  def __itruediv__(self, *args):
1350  return _IMP_algebra._VectorBaseKD___itruediv__(self, *args)
1351  __idiv__ = __itruediv__
1352 
1353 
1354 
1355  def __imul__(self, f):
1356  r"""__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1357  return _IMP_algebra._VectorBaseKD___imul__(self, f)
1358 
1359  def show(self, *args):
1360  r"""
1361  show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
1362  show(_VectorBaseKD self, _ostream out=std::cout)
1363  """
1364  return _IMP_algebra._VectorBaseKD_show(self, *args)
1365 
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
1370 
1371 # Register _VectorBaseKD in _IMP_algebra:
1372 _IMP_algebra._VectorBaseKD_swigregister(_VectorBaseKD)
1373 class _VectorBase1D(_GeometricPrimitive1D):
1374  r"""Proxy of C++ IMP::algebra::VectorBaseD< 1 > class."""
1375 
1376  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1377  __repr__ = _swig_repr
1378 
1379  def __init__(self):
1380  r"""__init__(_VectorBase1D self) -> _VectorBase1D"""
1381  _IMP_algebra._VectorBase1D_swiginit(self, _IMP_algebra.new__VectorBase1D())
1382 
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)
1386 
1387  def get_squared_magnitude(self):
1388  r"""get_squared_magnitude(_VectorBase1D self) -> double"""
1389  return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)
1390 
1391  def get_magnitude(self):
1392  r"""get_magnitude(_VectorBase1D self) -> double"""
1393  return _IMP_algebra._VectorBase1D_get_magnitude(self)
1394 
1395  def __mul__(self, o):
1396  r"""__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
1397  return _IMP_algebra._VectorBase1D___mul__(self, o)
1398 
1399  def __iadd__(self, o):
1400  r"""__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1401  return _IMP_algebra._VectorBase1D___iadd__(self, o)
1402 
1403  def __isub__(self, o):
1404  r"""__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1405  return _IMP_algebra._VectorBase1D___isub__(self, o)
1406 
1407  def __itruediv__(self, *args):
1408  return _IMP_algebra._VectorBase1D___itruediv__(self, *args)
1409  __idiv__ = __itruediv__
1410 
1411 
1412 
1413  def __imul__(self, f):
1414  r"""__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
1415  return _IMP_algebra._VectorBase1D___imul__(self, f)
1416 
1417  def show(self, *args):
1418  r"""
1419  show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
1420  show(_VectorBase1D self, _ostream out=std::cout)
1421  """
1422  return _IMP_algebra._VectorBase1D_show(self, *args)
1423 
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
1428 
1429 # Register _VectorBase1D in _IMP_algebra:
1430 _IMP_algebra._VectorBase1D_swigregister(_VectorBase1D)
1431 class _VectorBase2D(_GeometricPrimitive2D):
1432  r"""Proxy of C++ IMP::algebra::VectorBaseD< 2 > class."""
1433 
1434  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1435  __repr__ = _swig_repr
1436 
1437  def __init__(self):
1438  r"""__init__(_VectorBase2D self) -> _VectorBase2D"""
1439  _IMP_algebra._VectorBase2D_swiginit(self, _IMP_algebra.new__VectorBase2D())
1440 
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)
1444 
1445  def get_squared_magnitude(self):
1446  r"""get_squared_magnitude(_VectorBase2D self) -> double"""
1447  return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)
1448 
1449  def get_magnitude(self):
1450  r"""get_magnitude(_VectorBase2D self) -> double"""
1451  return _IMP_algebra._VectorBase2D_get_magnitude(self)
1452 
1453  def __mul__(self, o):
1454  r"""__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
1455  return _IMP_algebra._VectorBase2D___mul__(self, o)
1456 
1457  def __iadd__(self, o):
1458  r"""__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1459  return _IMP_algebra._VectorBase2D___iadd__(self, o)
1460 
1461  def __isub__(self, o):
1462  r"""__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1463  return _IMP_algebra._VectorBase2D___isub__(self, o)
1464 
1465  def __itruediv__(self, *args):
1466  return _IMP_algebra._VectorBase2D___itruediv__(self, *args)
1467  __idiv__ = __itruediv__
1468 
1469 
1470 
1471  def __imul__(self, f):
1472  r"""__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
1473  return _IMP_algebra._VectorBase2D___imul__(self, f)
1474 
1475  def show(self, *args):
1476  r"""
1477  show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
1478  show(_VectorBase2D self, _ostream out=std::cout)
1479  """
1480  return _IMP_algebra._VectorBase2D_show(self, *args)
1481 
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
1486 
1487 # Register _VectorBase2D in _IMP_algebra:
1488 _IMP_algebra._VectorBase2D_swigregister(_VectorBase2D)
1489 class _VectorBase3D(_GeometricPrimitive3D):
1490  r"""Proxy of C++ IMP::algebra::VectorBaseD< 3 > class."""
1491 
1492  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1493  __repr__ = _swig_repr
1494 
1495  def __init__(self):
1496  r"""__init__(_VectorBase3D self) -> _VectorBase3D"""
1497  _IMP_algebra._VectorBase3D_swiginit(self, _IMP_algebra.new__VectorBase3D())
1498 
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)
1502 
1503  def get_squared_magnitude(self):
1504  r"""get_squared_magnitude(_VectorBase3D self) -> double"""
1505  return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)
1506 
1507  def get_magnitude(self):
1508  r"""get_magnitude(_VectorBase3D self) -> double"""
1509  return _IMP_algebra._VectorBase3D_get_magnitude(self)
1510 
1511  def __mul__(self, o):
1512  r"""__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
1513  return _IMP_algebra._VectorBase3D___mul__(self, o)
1514 
1515  def __iadd__(self, o):
1516  r"""__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1517  return _IMP_algebra._VectorBase3D___iadd__(self, o)
1518 
1519  def __isub__(self, o):
1520  r"""__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1521  return _IMP_algebra._VectorBase3D___isub__(self, o)
1522 
1523  def __itruediv__(self, *args):
1524  return _IMP_algebra._VectorBase3D___itruediv__(self, *args)
1525  __idiv__ = __itruediv__
1526 
1527 
1528 
1529  def __imul__(self, f):
1530  r"""__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
1531  return _IMP_algebra._VectorBase3D___imul__(self, f)
1532 
1533  def show(self, *args):
1534  r"""
1535  show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
1536  show(_VectorBase3D self, _ostream out=std::cout)
1537  """
1538  return _IMP_algebra._VectorBase3D_show(self, *args)
1539 
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
1544 
1545 # Register _VectorBase3D in _IMP_algebra:
1546 _IMP_algebra._VectorBase3D_swigregister(_VectorBase3D)
1547 class _VectorBase4D(_GeometricPrimitive4D):
1548  r"""Proxy of C++ IMP::algebra::VectorBaseD< 4 > class."""
1549 
1550  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1551  __repr__ = _swig_repr
1552 
1553  def __init__(self):
1554  r"""__init__(_VectorBase4D self) -> _VectorBase4D"""
1555  _IMP_algebra._VectorBase4D_swiginit(self, _IMP_algebra.new__VectorBase4D())
1556 
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)
1560 
1561  def get_squared_magnitude(self):
1562  r"""get_squared_magnitude(_VectorBase4D self) -> double"""
1563  return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)
1564 
1565  def get_magnitude(self):
1566  r"""get_magnitude(_VectorBase4D self) -> double"""
1567  return _IMP_algebra._VectorBase4D_get_magnitude(self)
1568 
1569  def __mul__(self, o):
1570  r"""__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
1571  return _IMP_algebra._VectorBase4D___mul__(self, o)
1572 
1573  def __iadd__(self, o):
1574  r"""__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1575  return _IMP_algebra._VectorBase4D___iadd__(self, o)
1576 
1577  def __isub__(self, o):
1578  r"""__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1579  return _IMP_algebra._VectorBase4D___isub__(self, o)
1580 
1581  def __itruediv__(self, *args):
1582  return _IMP_algebra._VectorBase4D___itruediv__(self, *args)
1583  __idiv__ = __itruediv__
1584 
1585 
1586 
1587  def __imul__(self, f):
1588  r"""__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
1589  return _IMP_algebra._VectorBase4D___imul__(self, f)
1590 
1591  def show(self, *args):
1592  r"""
1593  show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
1594  show(_VectorBase4D self, _ostream out=std::cout)
1595  """
1596  return _IMP_algebra._VectorBase4D_show(self, *args)
1597 
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
1602 
1603 # Register _VectorBase4D in _IMP_algebra:
1604 _IMP_algebra._VectorBase4D_swigregister(_VectorBase4D)
1605 class _VectorBase5D(_GeometricPrimitive5D):
1606  r"""Proxy of C++ IMP::algebra::VectorBaseD< 5 > class."""
1607 
1608  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1609  __repr__ = _swig_repr
1610 
1611  def __init__(self):
1612  r"""__init__(_VectorBase5D self) -> _VectorBase5D"""
1613  _IMP_algebra._VectorBase5D_swiginit(self, _IMP_algebra.new__VectorBase5D())
1614 
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)
1618 
1619  def get_squared_magnitude(self):
1620  r"""get_squared_magnitude(_VectorBase5D self) -> double"""
1621  return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)
1622 
1623  def get_magnitude(self):
1624  r"""get_magnitude(_VectorBase5D self) -> double"""
1625  return _IMP_algebra._VectorBase5D_get_magnitude(self)
1626 
1627  def __mul__(self, o):
1628  r"""__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
1629  return _IMP_algebra._VectorBase5D___mul__(self, o)
1630 
1631  def __iadd__(self, o):
1632  r"""__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1633  return _IMP_algebra._VectorBase5D___iadd__(self, o)
1634 
1635  def __isub__(self, o):
1636  r"""__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1637  return _IMP_algebra._VectorBase5D___isub__(self, o)
1638 
1639  def __itruediv__(self, *args):
1640  return _IMP_algebra._VectorBase5D___itruediv__(self, *args)
1641  __idiv__ = __itruediv__
1642 
1643 
1644 
1645  def __imul__(self, f):
1646  r"""__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
1647  return _IMP_algebra._VectorBase5D___imul__(self, f)
1648 
1649  def show(self, *args):
1650  r"""
1651  show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
1652  show(_VectorBase5D self, _ostream out=std::cout)
1653  """
1654  return _IMP_algebra._VectorBase5D_show(self, *args)
1655 
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
1660 
1661 # Register _VectorBase5D in _IMP_algebra:
1662 _IMP_algebra._VectorBase5D_swigregister(_VectorBase5D)
1663 class _VectorBase6D(_GeometricPrimitive6D):
1664  r"""Proxy of C++ IMP::algebra::VectorBaseD< 6 > class."""
1665 
1666  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1667  __repr__ = _swig_repr
1668 
1669  def __init__(self):
1670  r"""__init__(_VectorBase6D self) -> _VectorBase6D"""
1671  _IMP_algebra._VectorBase6D_swiginit(self, _IMP_algebra.new__VectorBase6D())
1672 
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)
1676 
1677  def get_squared_magnitude(self):
1678  r"""get_squared_magnitude(_VectorBase6D self) -> double"""
1679  return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)
1680 
1681  def get_magnitude(self):
1682  r"""get_magnitude(_VectorBase6D self) -> double"""
1683  return _IMP_algebra._VectorBase6D_get_magnitude(self)
1684 
1685  def __mul__(self, o):
1686  r"""__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
1687  return _IMP_algebra._VectorBase6D___mul__(self, o)
1688 
1689  def __iadd__(self, o):
1690  r"""__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1691  return _IMP_algebra._VectorBase6D___iadd__(self, o)
1692 
1693  def __isub__(self, o):
1694  r"""__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1695  return _IMP_algebra._VectorBase6D___isub__(self, o)
1696 
1697  def __itruediv__(self, *args):
1698  return _IMP_algebra._VectorBase6D___itruediv__(self, *args)
1699  __idiv__ = __itruediv__
1700 
1701 
1702 
1703  def __imul__(self, f):
1704  r"""__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
1705  return _IMP_algebra._VectorBase6D___imul__(self, f)
1706 
1707  def show(self, *args):
1708  r"""
1709  show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
1710  show(_VectorBase6D self, _ostream out=std::cout)
1711  """
1712  return _IMP_algebra._VectorBase6D_show(self, *args)
1713 
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
1718 
1719 # Register _VectorBase6D in _IMP_algebra:
1720 _IMP_algebra._VectorBase6D_swigregister(_VectorBase6D)
1721 
1722 def get_basis_vector_kd(D, coordinate):
1723  r"""get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
1724  return _IMP_algebra.get_basis_vector_kd(D, coordinate)
1725 
1726 def get_zero_vector_kd(D):
1727  r"""get_zero_vector_kd(int D) -> VectorKD"""
1728  return _IMP_algebra.get_zero_vector_kd(D)
1729 
1730 def get_ones_vector_kd(D, v=1):
1731  r"""get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD"""
1732  return _IMP_algebra.get_ones_vector_kd(D, v)
1733 
1734 def get_vector_product(p1, p2):
1735  r"""get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
1736  return _IMP_algebra.get_vector_product(p1, p2)
1737 
1738 def get_orthogonal_vector(v):
1739  r"""get_orthogonal_vector(Vector3D v) -> Vector3D"""
1740  return _IMP_algebra.get_orthogonal_vector(v)
1741 
1742 def get_centroid(ps):
1743  r"""get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
1744  return _IMP_algebra.get_centroid(ps)
1745 
1746 def get_radius_of_gyration(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."""
1751 
1752  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1753 
1754  def __init__(self, *args):
1755  r"""
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
1760  """
1761  _IMP_algebra.Rotation3D_swiginit(self, _IMP_algebra.new_Rotation3D(*args))
1762  __swig_destroy__ = _IMP_algebra.delete_Rotation3D
1763 
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)
1767 
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)
1771 
1772  def get_rotated(self, o):
1773  r"""get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
1774  return _IMP_algebra.Rotation3D_get_rotated(self, o)
1775 
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)
1779 
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)
1783 
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)
1787 
1788  def show(self, *args):
1789  r"""show(Rotation3D self, _ostream out=std::cout)"""
1790  return _IMP_algebra.Rotation3D_show(self, *args)
1791 
1792  def get_inverse(self):
1793  r"""get_inverse(Rotation3D self) -> Rotation3D"""
1794  return _IMP_algebra.Rotation3D_get_inverse(self)
1795 
1796  def get_quaternion(self):
1797  r"""get_quaternion(Rotation3D self) -> Vector4D"""
1798  return _IMP_algebra.Rotation3D_get_quaternion(self)
1799 
1800  def __mul__(self, *args):
1801  r"""
1802  __mul__(Rotation3D self, Vector3D v) -> Vector3D
1803  __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
1804  """
1805  return _IMP_algebra.Rotation3D___mul__(self, *args)
1806 
1807  def __truediv__(self, *args):
1808  return _IMP_algebra.Rotation3D___truediv__(self, *args)
1809  __div__ = __truediv__
1810 
1811 
1812 
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)
1816 
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)
1820 
1821  def get_is_valid(self):
1822  r"""get_is_valid(Rotation3D self) -> bool"""
1823  return _IMP_algebra.Rotation3D_get_is_valid(self)
1824 
1825  def __str__(self):
1826  r"""__str__(Rotation3D self) -> std::string"""
1827  return _IMP_algebra.Rotation3D___str__(self)
1828 
1829  def __repr__(self):
1830  r"""__repr__(Rotation3D self) -> std::string"""
1831  return _IMP_algebra.Rotation3D___repr__(self)
1832 
1833  def _get_as_binary(self):
1834  r"""_get_as_binary(Rotation3D self) -> PyObject *"""
1835  return _IMP_algebra.Rotation3D__get_as_binary(self)
1836 
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)
1840 
1841  def __getstate__(self):
1842  p = self._get_as_binary()
1843  if len(self.__dict__) > 1:
1844  d = self.__dict__.copy()
1845  del d['this']
1846  p = (d, p)
1847  return p
1848 
1849  def __setstate__(self, p):
1850  if not hasattr(self, 'this'):
1851  self.__init__()
1852  if isinstance(p, tuple):
1853  d, p = p
1854  self.__dict__.update(d)
1855  return self._set_from_binary(p)
1856 
1857 
1858  __truediv__ = __div__
1859 
1860 
1861 # Register Rotation3D in _IMP_algebra:
1862 _IMP_algebra.Rotation3D_swigregister(Rotation3D)
1863 
1864 def get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm=False):
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)
1867 
1868 def get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm=False):
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)
1871 
1873  r"""get_identity_rotation_3d() -> Rotation3D"""
1874  return _IMP_algebra.get_identity_rotation_3d()
1875 
1876 def get_rotation_about_normalized_axis(axis_norm, angle):
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)
1879 
1880 def get_rotation_about_axis(axis, angle):
1881  r"""get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
1882  return _IMP_algebra.get_rotation_about_axis(axis, angle)
1883 
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)
1887 
1888 def get_rotation_from_matrix(*args):
1889  r"""
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
1892  """
1893  return _IMP_algebra.get_rotation_from_matrix(*args)
1894 
1895 def get_random_rotation_3d(*args):
1896  r"""
1897  get_random_rotation_3d() -> Rotation3D
1898  get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
1899  """
1900  return _IMP_algebra.get_random_rotation_3d(*args)
1901 
1902 def get_uniform_cover_rotations_3d(num_points):
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)
1905 
1907  r"""get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
1908  return _IMP_algebra.get_uniformly_sampled_rotations(delta)
1909 
1911  r"""get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
1912  return _IMP_algebra.get_rotation_from_vector4d(v)
1913 
1914 def get_rotation_from_fixed_xyz(xr, yr, zr):
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)
1917 
1918 def get_rotation_from_fixed_zxz(phi, theta, psi):
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)
1921 
1922 def get_rotation_from_fixed_zyz(Rot, Tilt, 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."""
1927 
1928  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1929 
1930  def __init__(self, *args):
1931  r"""
1932  __init__(FixedXYZ self) -> FixedXYZ
1933  __init__(FixedXYZ self, double x, double y, double z) -> FixedXYZ
1934  """
1935  _IMP_algebra.FixedXYZ_swiginit(self, _IMP_algebra.new_FixedXYZ(*args))
1936 
1937  def get_x(self):
1938  r"""get_x(FixedXYZ self) -> double"""
1939  return _IMP_algebra.FixedXYZ_get_x(self)
1940 
1941  def get_y(self):
1942  r"""get_y(FixedXYZ self) -> double"""
1943  return _IMP_algebra.FixedXYZ_get_y(self)
1944 
1945  def get_z(self):
1946  r"""get_z(FixedXYZ self) -> double"""
1947  return _IMP_algebra.FixedXYZ_get_z(self)
1948 
1949  def show(self, *args):
1950  r"""show(FixedXYZ self, _ostream out=std::cout)"""
1951  return _IMP_algebra.FixedXYZ_show(self, *args)
1952 
1953  def __str__(self):
1954  r"""__str__(FixedXYZ self) -> std::string"""
1955  return _IMP_algebra.FixedXYZ___str__(self)
1956 
1957  def __repr__(self):
1958  r"""__repr__(FixedXYZ self) -> std::string"""
1959  return _IMP_algebra.FixedXYZ___repr__(self)
1960 
1961  def _get_as_binary(self):
1962  r"""_get_as_binary(FixedXYZ self) -> PyObject *"""
1963  return _IMP_algebra.FixedXYZ__get_as_binary(self)
1964 
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)
1968 
1969  def __getstate__(self):
1970  p = self._get_as_binary()
1971  if len(self.__dict__) > 1:
1972  d = self.__dict__.copy()
1973  del d['this']
1974  p = (d, p)
1975  return p
1976 
1977  def __setstate__(self, p):
1978  if not hasattr(self, 'this'):
1979  self.__init__()
1980  if isinstance(p, tuple):
1981  d, p = p
1982  self.__dict__.update(d)
1983  return self._set_from_binary(p)
1984 
1985  __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
1986 
1987 # Register FixedXYZ in _IMP_algebra:
1988 _IMP_algebra.FixedXYZ_swigregister(FixedXYZ)
1989 
1991  r"""get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
1992  return _IMP_algebra.get_fixed_xyz_from_rotation(r)
1993 
1994 def get_interpolated(a, b, f):
1995  r"""get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
1996  return _IMP_algebra.get_interpolated(a, b, f)
1997 
1998 def get_rotation_from_x_y_axes(x, y):
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)
2001 
2002 def get_axis_and_angle(rot):
2003  r"""get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
2004  return _IMP_algebra.get_axis_and_angle(rot)
2005 
2007  r"""get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
2008  return _IMP_algebra.get_unit_bounding_box_kd(d)
2009 
2010 def get_cube_kd(d, radius):
2011  r"""get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
2012  return _IMP_algebra.get_cube_kd(d, radius)
2013 
2014 def get_edges(arg1):
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."""
2019 
2020  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2021 
2022  def __init__(self, *args):
2023  r"""
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
2028  """
2029  _IMP_algebra.Transformation3D_swiginit(self, _IMP_algebra.new_Transformation3D(*args))
2030  __swig_destroy__ = _IMP_algebra.delete_Transformation3D
2031 
2032  def get_transformed(self, o):
2033  r"""get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
2034  return _IMP_algebra.Transformation3D_get_transformed(self, o)
2035 
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)
2039 
2040  def __mul__(self, *args):
2041  r"""
2042  __mul__(Transformation3D self, Vector3D v) -> Vector3D
2043  __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
2044  """
2045  return _IMP_algebra.Transformation3D___mul__(self, *args)
2046 
2047  def __truediv__(self, *args):
2048  return _IMP_algebra.Transformation3D___truediv__(self, *args)
2049  __div__ = __truediv__
2050 
2051 
2052 
2053  def get_rotation(self):
2054  r"""get_rotation(Transformation3D self) -> Rotation3D"""
2055  return _IMP_algebra.Transformation3D_get_rotation(self)
2056 
2057  def get_translation(self):
2058  r"""get_translation(Transformation3D self) -> Vector3D"""
2059  return _IMP_algebra.Transformation3D_get_translation(self)
2060 
2061  def show(self, *args):
2062  r"""show(Transformation3D self, _ostream out=std::cout)"""
2063  return _IMP_algebra.Transformation3D_show(self, *args)
2064 
2065  def get_inverse(self):
2066  r"""get_inverse(Transformation3D self) -> Transformation3D"""
2067  return _IMP_algebra.Transformation3D_get_inverse(self)
2068 
2069  def get_is_valid(self):
2070  r"""get_is_valid(Transformation3D self) -> bool"""
2071  return _IMP_algebra.Transformation3D_get_is_valid(self)
2072 
2073  def __str__(self):
2074  r"""__str__(Transformation3D self) -> std::string"""
2075  return _IMP_algebra.Transformation3D___str__(self)
2076 
2077  def __repr__(self):
2078  r"""__repr__(Transformation3D self) -> std::string"""
2079  return _IMP_algebra.Transformation3D___repr__(self)
2080 
2081  def _get_as_binary(self):
2082  r"""_get_as_binary(Transformation3D self) -> PyObject *"""
2083  return _IMP_algebra.Transformation3D__get_as_binary(self)
2084 
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)
2088 
2089  def __getstate__(self):
2090  p = self._get_as_binary()
2091  if len(self.__dict__) > 1:
2092  d = self.__dict__.copy()
2093  del d['this']
2094  p = (d, p)
2095  return p
2096 
2097  def __setstate__(self, p):
2098  if not hasattr(self, 'this'):
2099  self.__init__()
2100  if isinstance(p, tuple):
2101  d, p = p
2102  self.__dict__.update(d)
2103  return self._set_from_binary(p)
2104 
2105 
2106  __truediv__ = __div__
2107 
2108 
2109 # Register Transformation3D in _IMP_algebra:
2110 _IMP_algebra.Transformation3D_swigregister(Transformation3D)
2111 
2113  r"""get_identity_transformation_3d() -> Transformation3D"""
2114  return _IMP_algebra.get_identity_transformation_3d()
2115 
2116 def compose_adjoint(*args):
2117  r"""
2118  compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
2119  compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
2120  """
2121  return _IMP_algebra.compose_adjoint(*args)
2122 
2123 def get_transformation_3d(t2d):
2124  r"""get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
2125  return _IMP_algebra.get_transformation_3d(t2d)
2126 
2127 def get_random_local_transformation(origin, max_translation=5., max_angle_in_rad=0.26):
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."""
2132 
2133  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2134 
2135  def __init__(self, *args):
2136  r"""
2137  __init__(Rotation2D self) -> Rotation2D
2138  __init__(Rotation2D self, double angle) -> Rotation2D
2139  """
2140  _IMP_algebra.Rotation2D_swiginit(self, _IMP_algebra.new_Rotation2D(*args))
2141 
2142  def get_rotated(self, *args):
2143  r"""
2144  get_rotated(Rotation2D self, Vector2D o) -> Vector2D
2145  get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
2146  """
2147  return _IMP_algebra.Rotation2D_get_rotated(self, *args)
2148 
2149  def get_inverse(self):
2150  r"""get_inverse(Rotation2D self) -> Rotation2D"""
2151  return _IMP_algebra.Rotation2D_get_inverse(self)
2152 
2153  def set_angle(self, angle):
2154  r"""set_angle(Rotation2D self, double angle)"""
2155  return _IMP_algebra.Rotation2D_set_angle(self, angle)
2156 
2157  def get_angle(self):
2158  r"""get_angle(Rotation2D self) -> double"""
2159  return _IMP_algebra.Rotation2D_get_angle(self)
2160 
2161  def show(self, *args):
2162  r"""show(Rotation2D self, _ostream out=std::cout)"""
2163  return _IMP_algebra.Rotation2D_show(self, *args)
2164 
2165  def __str__(self):
2166  r"""__str__(Rotation2D self) -> std::string"""
2167  return _IMP_algebra.Rotation2D___str__(self)
2168 
2169  def __repr__(self):
2170  r"""__repr__(Rotation2D self) -> std::string"""
2171  return _IMP_algebra.Rotation2D___repr__(self)
2172 
2173  def _get_as_binary(self):
2174  r"""_get_as_binary(Rotation2D self) -> PyObject *"""
2175  return _IMP_algebra.Rotation2D__get_as_binary(self)
2176 
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)
2180 
2181  def __getstate__(self):
2182  p = self._get_as_binary()
2183  if len(self.__dict__) > 1:
2184  d = self.__dict__.copy()
2185  del d['this']
2186  p = (d, p)
2187  return p
2188 
2189  def __setstate__(self, p):
2190  if not hasattr(self, 'this'):
2191  self.__init__()
2192  if isinstance(p, tuple):
2193  d, p = p
2194  self.__dict__.update(d)
2195  return self._set_from_binary(p)
2196 
2197  __swig_destroy__ = _IMP_algebra.delete_Rotation2D
2198 
2199 # Register Rotation2D in _IMP_algebra:
2200 _IMP_algebra.Rotation2D_swigregister(Rotation2D)
2201 
2203  r"""get_identity_rotation_2d() -> Rotation2D"""
2204  return _IMP_algebra.get_identity_rotation_2d()
2205 
2207  r"""get_random_rotation_2d() -> Rotation2D"""
2208  return _IMP_algebra.get_random_rotation_2d()
2209 
2210 def get_rotation_to_x_axis(v):
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."""
2215 
2216  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2217 
2218  def __init__(self, *args):
2219  r"""
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
2224  """
2225  _IMP_algebra.Transformation2D_swiginit(self, _IMP_algebra.new_Transformation2D(*args))
2226  __swig_destroy__ = _IMP_algebra.delete_Transformation2D
2227 
2228  def get_transformed(self, o):
2229  r"""get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
2230  return _IMP_algebra.Transformation2D_get_transformed(self, o)
2231 
2232  def __mul__(self, *args):
2233  r"""
2234  __mul__(Transformation2D self, Vector2D v) -> Vector2D
2235  __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
2236  """
2237  return _IMP_algebra.Transformation2D___mul__(self, *args)
2238 
2239  def __truediv__(self, *args):
2240  return _IMP_algebra.Transformation2D___truediv__(self, *args)
2241  __div__ = __truediv__
2242 
2243 
2244 
2245  def get_rotation(self):
2246  r"""get_rotation(Transformation2D self) -> Rotation2D"""
2247  return _IMP_algebra.Transformation2D_get_rotation(self)
2248 
2249  def set_rotation(self, angle):
2250  r"""set_rotation(Transformation2D self, double angle)"""
2251  return _IMP_algebra.Transformation2D_set_rotation(self, angle)
2252 
2253  def get_translation(self):
2254  r"""get_translation(Transformation2D self) -> Vector2D"""
2255  return _IMP_algebra.Transformation2D_get_translation(self)
2256 
2257  def set_translation(self, v):
2258  r"""set_translation(Transformation2D self, Vector2D v)"""
2259  return _IMP_algebra.Transformation2D_set_translation(self, v)
2260 
2261  def show(self, *args):
2262  r"""show(Transformation2D self, _ostream out=std::cout)"""
2263  return _IMP_algebra.Transformation2D_show(self, *args)
2264 
2265  def get_inverse(self):
2266  r"""get_inverse(Transformation2D self) -> Transformation2D"""
2267  return _IMP_algebra.Transformation2D_get_inverse(self)
2268 
2269  def __str__(self):
2270  r"""__str__(Transformation2D self) -> std::string"""
2271  return _IMP_algebra.Transformation2D___str__(self)
2272 
2273  def __repr__(self):
2274  r"""__repr__(Transformation2D self) -> std::string"""
2275  return _IMP_algebra.Transformation2D___repr__(self)
2276 
2277  def _get_as_binary(self):
2278  r"""_get_as_binary(Transformation2D self) -> PyObject *"""
2279  return _IMP_algebra.Transformation2D__get_as_binary(self)
2280 
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)
2284 
2285  def __getstate__(self):
2286  p = self._get_as_binary()
2287  if len(self.__dict__) > 1:
2288  d = self.__dict__.copy()
2289  del d['this']
2290  p = (d, p)
2291  return p
2292 
2293  def __setstate__(self, p):
2294  if not hasattr(self, 'this'):
2295  self.__init__()
2296  if isinstance(p, tuple):
2297  d, p = p
2298  self.__dict__.update(d)
2299  return self._set_from_binary(p)
2300 
2301 
2302  __truediv__ = __div__
2303 
2304 
2305 # Register Transformation2D in _IMP_algebra:
2306 _IMP_algebra.Transformation2D_swigregister(Transformation2D)
2307 
2309  r"""get_identity_transformation_2d() -> Transformation2D"""
2310  return _IMP_algebra.get_identity_transformation_2d()
2311 
2312 def get_rotation_about_point(*args):
2313  r"""
2314  get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
2315  get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
2316  """
2317  return _IMP_algebra.get_rotation_about_point(*args)
2318 
2319 def compose(*args):
2320  r"""
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
2325  """
2326  return _IMP_algebra.compose(*args)
2327 
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)
2331 
2332 def get_enclosing_sphere(*args):
2333  r"""
2334  get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
2335  get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
2336  """
2337  return _IMP_algebra.get_enclosing_sphere(*args)
2338 
2339 def get_ball_radius_from_volume_3d(volume):
2340  r"""get_ball_radius_from_volume_3d(double volume) -> double"""
2341  return _IMP_algebra.get_ball_radius_from_volume_3d(volume)
2342 
2344  r"""get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
2345  return _IMP_algebra.get_surface_area_and_volume(ss)
2346 
2347 def get_simplified_from_volume(_in, maximum_allowed_error_angstroms):
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)
2350 
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."""
2356 
2357  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2358 
2359  def __init__(self, *args, **kwargs):
2360  raise AttributeError("No constructor defined - class is abstract")
2361  __repr__ = _swig_repr
2362 
2363  def get_dimension(self):
2364  r"""get_dimension(_UnitSimplexBaseKD self) -> int"""
2365  return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)
2366 
2367  def get_barycenter(self):
2368  r"""get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
2369  return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)
2370 
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
2375 
2376 # Register _UnitSimplexBaseKD in _IMP_algebra:
2377 _IMP_algebra._UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
2378 class _UnitSimplexBase1D(_GeometricPrimitive1D):
2379  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 1 > class."""
2380 
2381  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2382 
2383  def __init__(self, *args, **kwargs):
2384  raise AttributeError("No constructor defined - class is abstract")
2385  __repr__ = _swig_repr
2386 
2387  def get_dimension(self):
2388  r"""get_dimension(_UnitSimplexBase1D self) -> int"""
2389  return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)
2390 
2391  def get_barycenter(self):
2392  r"""get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
2393  return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)
2394 
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
2399 
2400 # Register _UnitSimplexBase1D in _IMP_algebra:
2401 _IMP_algebra._UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
2402 class _UnitSimplexBase2D(_GeometricPrimitive2D):
2403  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 2 > class."""
2404 
2405  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2406 
2407  def __init__(self, *args, **kwargs):
2408  raise AttributeError("No constructor defined - class is abstract")
2409  __repr__ = _swig_repr
2410 
2411  def get_dimension(self):
2412  r"""get_dimension(_UnitSimplexBase2D self) -> int"""
2413  return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)
2414 
2415  def get_barycenter(self):
2416  r"""get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
2417  return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)
2418 
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
2423 
2424 # Register _UnitSimplexBase2D in _IMP_algebra:
2425 _IMP_algebra._UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
2426 class _UnitSimplexBase3D(_GeometricPrimitive3D):
2427  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 3 > class."""
2428 
2429  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2430 
2431  def __init__(self, *args, **kwargs):
2432  raise AttributeError("No constructor defined - class is abstract")
2433  __repr__ = _swig_repr
2434 
2435  def get_dimension(self):
2436  r"""get_dimension(_UnitSimplexBase3D self) -> int"""
2437  return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)
2438 
2439  def get_barycenter(self):
2440  r"""get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
2441  return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)
2442 
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
2447 
2448 # Register _UnitSimplexBase3D in _IMP_algebra:
2449 _IMP_algebra._UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
2450 class _UnitSimplexBase4D(_GeometricPrimitive4D):
2451  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 4 > class."""
2452 
2453  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2454 
2455  def __init__(self, *args, **kwargs):
2456  raise AttributeError("No constructor defined - class is abstract")
2457  __repr__ = _swig_repr
2458 
2459  def get_dimension(self):
2460  r"""get_dimension(_UnitSimplexBase4D self) -> int"""
2461  return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)
2462 
2463  def get_barycenter(self):
2464  r"""get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
2465  return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)
2466 
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
2471 
2472 # Register _UnitSimplexBase4D in _IMP_algebra:
2473 _IMP_algebra._UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
2474 class _UnitSimplexBase5D(_GeometricPrimitive5D):
2475  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 5 > class."""
2476 
2477  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2478 
2479  def __init__(self, *args, **kwargs):
2480  raise AttributeError("No constructor defined - class is abstract")
2481  __repr__ = _swig_repr
2482 
2483  def get_dimension(self):
2484  r"""get_dimension(_UnitSimplexBase5D self) -> int"""
2485  return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)
2486 
2487  def get_barycenter(self):
2488  r"""get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
2489  return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)
2490 
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
2495 
2496 # Register _UnitSimplexBase5D in _IMP_algebra:
2497 _IMP_algebra._UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
2498 class _UnitSimplexBase6D(_GeometricPrimitive6D):
2499  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 6 > class."""
2500 
2501  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2502 
2503  def __init__(self, *args, **kwargs):
2504  raise AttributeError("No constructor defined - class is abstract")
2505  __repr__ = _swig_repr
2506 
2507  def get_dimension(self):
2508  r"""get_dimension(_UnitSimplexBase6D self) -> int"""
2509  return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)
2510 
2511  def get_barycenter(self):
2512  r"""get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
2513  return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)
2514 
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
2519 
2520 # Register _UnitSimplexBase6D in _IMP_algebra:
2521 _IMP_algebra._UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
2522 class Vector1D(_VectorBase1D):
2523  r"""Proxy of C++ IMP::algebra::VectorD< 1 > class."""
2524 
2525  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2526 
2527  def get_unit_vector(self):
2528  r"""get_unit_vector(Vector1D self) -> Vector1D"""
2529  return _IMP_algebra.Vector1D_get_unit_vector(self)
2530 
2531  def __truediv__(self, *args):
2532  return _IMP_algebra.Vector1D___truediv__(self, *args)
2533  __div__ = __truediv__
2534 
2535 
2536 
2537  def __neg__(self):
2538  r"""__neg__(Vector1D self) -> Vector1D"""
2539  return _IMP_algebra.Vector1D___neg__(self)
2540 
2541  def __sub__(self, o):
2542  r"""__sub__(Vector1D self, Vector1D o) -> Vector1D"""
2543  return _IMP_algebra.Vector1D___sub__(self, o)
2544 
2545  def __add__(self, ret):
2546  r"""__add__(Vector1D self, Vector1D ret) -> Vector1D"""
2547  return _IMP_algebra.Vector1D___add__(self, ret)
2548 
2549  def __mul__(self, *args):
2550  r"""
2551  __mul__(Vector1D self, double s) -> Vector1D
2552  __mul__(Vector1D self, Vector1D o) -> double
2553  """
2554  return _IMP_algebra.Vector1D___mul__(self, *args)
2555 
2556  def __init__(self, *args):
2557  r"""
2558  __init__(Vector1D self, IMP::Floats const & f) -> Vector1D
2559  __init__(Vector1D self) -> Vector1D
2560  __init__(Vector1D self, double x) -> Vector1D
2561  """
2562  _IMP_algebra.Vector1D_swiginit(self, _IMP_algebra.new_Vector1D(*args))
2563 
2564  def __iadd__(self, *args):
2565  _IMP_algebra.Vector1D___iadd__(self, *args)
2566  return self
2567 
2568 
2569 
2570  def __imul__(self, *args):
2571  _IMP_algebra.Vector1D___imul__(self, *args)
2572  return self
2573 
2574 
2575 
2576  def __idiv__(self, *args):
2577  _IMP_algebra.Vector1D___idiv__(self, *args)
2578  return self
2579 
2580 
2581 
2582  def __isub__(self, *args):
2583  _IMP_algebra.Vector1D___isub__(self, *args)
2584  return self
2585 
2586 
2587 
2588  def __len__(self):
2589  r"""__len__(Vector1D self) -> unsigned int"""
2590  return _IMP_algebra.Vector1D___len__(self)
2591 
2592  def __rmul__(self, f):
2593  r"""__rmul__(Vector1D self, double f) -> Vector1D"""
2594  return _IMP_algebra.Vector1D___rmul__(self, f)
2595 
2596  def __str__(self):
2597  r"""__str__(Vector1D self) -> std::string"""
2598  return _IMP_algebra.Vector1D___str__(self)
2599 
2600  def __repr__(self):
2601  r"""__repr__(Vector1D self) -> std::string"""
2602  return _IMP_algebra.Vector1D___repr__(self)
2603 
2604  def __cmp__(self, arg2):
2605  r"""__cmp__(Vector1D self, Vector1D arg2) -> int"""
2606  return _IMP_algebra.Vector1D___cmp__(self, arg2)
2607 
2608  def __eq__(self, arg2):
2609  r"""__eq__(Vector1D self, Vector1D arg2) -> bool"""
2610  return _IMP_algebra.Vector1D___eq__(self, arg2)
2611 
2612  __truediv__ = __div__
2613  __itruediv__ = __idiv__
2614 
2615 
2616  def _get_as_binary(self):
2617  r"""_get_as_binary(Vector1D self) -> PyObject *"""
2618  return _IMP_algebra.Vector1D__get_as_binary(self)
2619 
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)
2623 
2624  def __getstate__(self):
2625  p = self._get_as_binary()
2626  if len(self.__dict__) > 1:
2627  d = self.__dict__.copy()
2628  del d['this']
2629  p = (d, p)
2630  return p
2631 
2632  def __setstate__(self, p):
2633  if not hasattr(self, 'this'):
2634  self.__init__()
2635  if isinstance(p, tuple):
2636  d, p = p
2637  self.__dict__.update(d)
2638  return self._set_from_binary(p)
2639 
2640 
2641  def __getitem__(self, index):
2642  r"""__getitem__(Vector1D self, int index) -> double"""
2643  return _IMP_algebra.Vector1D___getitem__(self, index)
2644 
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
2649 
2650 # Register Vector1D in _IMP_algebra:
2651 _IMP_algebra.Vector1D_swigregister(Vector1D)
2652 class Vector2D(_VectorBase2D):
2653  r"""Proxy of C++ IMP::algebra::VectorD< 2 > class."""
2654 
2655  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2656 
2657  def get_unit_vector(self):
2658  r"""get_unit_vector(Vector2D self) -> Vector2D"""
2659  return _IMP_algebra.Vector2D_get_unit_vector(self)
2660 
2661  def __truediv__(self, *args):
2662  return _IMP_algebra.Vector2D___truediv__(self, *args)
2663  __div__ = __truediv__
2664 
2665 
2666 
2667  def __neg__(self):
2668  r"""__neg__(Vector2D self) -> Vector2D"""
2669  return _IMP_algebra.Vector2D___neg__(self)
2670 
2671  def __sub__(self, o):
2672  r"""__sub__(Vector2D self, Vector2D o) -> Vector2D"""
2673  return _IMP_algebra.Vector2D___sub__(self, o)
2674 
2675  def __add__(self, ret):
2676  r"""__add__(Vector2D self, Vector2D ret) -> Vector2D"""
2677  return _IMP_algebra.Vector2D___add__(self, ret)
2678 
2679  def __mul__(self, *args):
2680  r"""
2681  __mul__(Vector2D self, double s) -> Vector2D
2682  __mul__(Vector2D self, Vector2D o) -> double
2683  """
2684  return _IMP_algebra.Vector2D___mul__(self, *args)
2685 
2686  def __init__(self, *args):
2687  r"""
2688  __init__(Vector2D self, IMP::Floats const & f) -> Vector2D
2689  __init__(Vector2D self) -> Vector2D
2690  __init__(Vector2D self, double x, double y) -> Vector2D
2691  """
2692  _IMP_algebra.Vector2D_swiginit(self, _IMP_algebra.new_Vector2D(*args))
2693 
2694  def __iadd__(self, *args):
2695  _IMP_algebra.Vector2D___iadd__(self, *args)
2696  return self
2697 
2698 
2699 
2700  def __imul__(self, *args):
2701  _IMP_algebra.Vector2D___imul__(self, *args)
2702  return self
2703 
2704 
2705 
2706  def __idiv__(self, *args):
2707  _IMP_algebra.Vector2D___idiv__(self, *args)
2708  return self
2709 
2710 
2711 
2712  def __isub__(self, *args):
2713  _IMP_algebra.Vector2D___isub__(self, *args)
2714  return self
2715 
2716 
2717 
2718  def __len__(self):
2719  r"""__len__(Vector2D self) -> unsigned int"""
2720  return _IMP_algebra.Vector2D___len__(self)
2721 
2722  def __rmul__(self, f):
2723  r"""__rmul__(Vector2D self, double f) -> Vector2D"""
2724  return _IMP_algebra.Vector2D___rmul__(self, f)
2725 
2726  def __str__(self):
2727  r"""__str__(Vector2D self) -> std::string"""
2728  return _IMP_algebra.Vector2D___str__(self)
2729 
2730  def __repr__(self):
2731  r"""__repr__(Vector2D self) -> std::string"""
2732  return _IMP_algebra.Vector2D___repr__(self)
2733 
2734  def __cmp__(self, arg2):
2735  r"""__cmp__(Vector2D self, Vector2D arg2) -> int"""
2736  return _IMP_algebra.Vector2D___cmp__(self, arg2)
2737 
2738  def __eq__(self, arg2):
2739  r"""__eq__(Vector2D self, Vector2D arg2) -> bool"""
2740  return _IMP_algebra.Vector2D___eq__(self, arg2)
2741 
2742  __truediv__ = __div__
2743  __itruediv__ = __idiv__
2744 
2745 
2746  def _get_as_binary(self):
2747  r"""_get_as_binary(Vector2D self) -> PyObject *"""
2748  return _IMP_algebra.Vector2D__get_as_binary(self)
2749 
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)
2753 
2754  def __getstate__(self):
2755  p = self._get_as_binary()
2756  if len(self.__dict__) > 1:
2757  d = self.__dict__.copy()
2758  del d['this']
2759  p = (d, p)
2760  return p
2761 
2762  def __setstate__(self, p):
2763  if not hasattr(self, 'this'):
2764  self.__init__()
2765  if isinstance(p, tuple):
2766  d, p = p
2767  self.__dict__.update(d)
2768  return self._set_from_binary(p)
2769 
2770 
2771  def __getitem__(self, index):
2772  r"""__getitem__(Vector2D self, int index) -> double"""
2773  return _IMP_algebra.Vector2D___getitem__(self, index)
2774 
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
2779 
2780 # Register Vector2D in _IMP_algebra:
2781 _IMP_algebra.Vector2D_swigregister(Vector2D)
2782 class Vector3D(_VectorBase3D):
2783  r"""Proxy of C++ IMP::algebra::VectorD< 3 > class."""
2784 
2785  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2786 
2787  def get_unit_vector(self):
2788  r"""get_unit_vector(Vector3D self) -> Vector3D"""
2789  return _IMP_algebra.Vector3D_get_unit_vector(self)
2790 
2791  def __truediv__(self, *args):
2792  return _IMP_algebra.Vector3D___truediv__(self, *args)
2793  __div__ = __truediv__
2794 
2795 
2796 
2797  def __neg__(self):
2798  r"""__neg__(Vector3D self) -> Vector3D"""
2799  return _IMP_algebra.Vector3D___neg__(self)
2800 
2801  def __sub__(self, o):
2802  r"""__sub__(Vector3D self, Vector3D o) -> Vector3D"""
2803  return _IMP_algebra.Vector3D___sub__(self, o)
2804 
2805  def __add__(self, ret):
2806  r"""__add__(Vector3D self, Vector3D ret) -> Vector3D"""
2807  return _IMP_algebra.Vector3D___add__(self, ret)
2808 
2809  def __mul__(self, *args):
2810  r"""
2811  __mul__(Vector3D self, double s) -> Vector3D
2812  __mul__(Vector3D self, Vector3D o) -> double
2813  """
2814  return _IMP_algebra.Vector3D___mul__(self, *args)
2815 
2816  def __init__(self, *args):
2817  r"""
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
2821  """
2822  _IMP_algebra.Vector3D_swiginit(self, _IMP_algebra.new_Vector3D(*args))
2823 
2824  def __iadd__(self, *args):
2825  _IMP_algebra.Vector3D___iadd__(self, *args)
2826  return self
2827 
2828 
2829 
2830  def __imul__(self, *args):
2831  _IMP_algebra.Vector3D___imul__(self, *args)
2832  return self
2833 
2834 
2835 
2836  def __idiv__(self, *args):
2837  _IMP_algebra.Vector3D___idiv__(self, *args)
2838  return self
2839 
2840 
2841 
2842  def __isub__(self, *args):
2843  _IMP_algebra.Vector3D___isub__(self, *args)
2844  return self
2845 
2846 
2847 
2848  def __len__(self):
2849  r"""__len__(Vector3D self) -> unsigned int"""
2850  return _IMP_algebra.Vector3D___len__(self)
2851 
2852  def __rmul__(self, f):
2853  r"""__rmul__(Vector3D self, double f) -> Vector3D"""
2854  return _IMP_algebra.Vector3D___rmul__(self, f)
2855 
2856  def __str__(self):
2857  r"""__str__(Vector3D self) -> std::string"""
2858  return _IMP_algebra.Vector3D___str__(self)
2859 
2860  def __repr__(self):
2861  r"""__repr__(Vector3D self) -> std::string"""
2862  return _IMP_algebra.Vector3D___repr__(self)
2863 
2864  def __cmp__(self, arg2):
2865  r"""__cmp__(Vector3D self, Vector3D arg2) -> int"""
2866  return _IMP_algebra.Vector3D___cmp__(self, arg2)
2867 
2868  def __eq__(self, arg2):
2869  r"""__eq__(Vector3D self, Vector3D arg2) -> bool"""
2870  return _IMP_algebra.Vector3D___eq__(self, arg2)
2871 
2872  __truediv__ = __div__
2873  __itruediv__ = __idiv__
2874 
2875 
2876  def _get_as_binary(self):
2877  r"""_get_as_binary(Vector3D self) -> PyObject *"""
2878  return _IMP_algebra.Vector3D__get_as_binary(self)
2879 
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)
2883 
2884  def __getstate__(self):
2885  p = self._get_as_binary()
2886  if len(self.__dict__) > 1:
2887  d = self.__dict__.copy()
2888  del d['this']
2889  p = (d, p)
2890  return p
2891 
2892  def __setstate__(self, p):
2893  if not hasattr(self, 'this'):
2894  self.__init__()
2895  if isinstance(p, tuple):
2896  d, p = p
2897  self.__dict__.update(d)
2898  return self._set_from_binary(p)
2899 
2900 
2901  def __getitem__(self, index):
2902  r"""__getitem__(Vector3D self, int index) -> double"""
2903  return _IMP_algebra.Vector3D___getitem__(self, index)
2904 
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
2909 
2910 # Register Vector3D in _IMP_algebra:
2911 _IMP_algebra.Vector3D_swigregister(Vector3D)
2912 class Vector4D(_VectorBase4D):
2913  r"""Proxy of C++ IMP::algebra::VectorD< 4 > class."""
2914 
2915  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2916 
2917  def get_unit_vector(self):
2918  r"""get_unit_vector(Vector4D self) -> Vector4D"""
2919  return _IMP_algebra.Vector4D_get_unit_vector(self)
2920 
2921  def __truediv__(self, *args):
2922  return _IMP_algebra.Vector4D___truediv__(self, *args)
2923  __div__ = __truediv__
2924 
2925 
2926 
2927  def __neg__(self):
2928  r"""__neg__(Vector4D self) -> Vector4D"""
2929  return _IMP_algebra.Vector4D___neg__(self)
2930 
2931  def __sub__(self, o):
2932  r"""__sub__(Vector4D self, Vector4D o) -> Vector4D"""
2933  return _IMP_algebra.Vector4D___sub__(self, o)
2934 
2935  def __add__(self, ret):
2936  r"""__add__(Vector4D self, Vector4D ret) -> Vector4D"""
2937  return _IMP_algebra.Vector4D___add__(self, ret)
2938 
2939  def __mul__(self, *args):
2940  r"""
2941  __mul__(Vector4D self, double s) -> Vector4D
2942  __mul__(Vector4D self, Vector4D o) -> double
2943  """
2944  return _IMP_algebra.Vector4D___mul__(self, *args)
2945 
2946  def __init__(self, *args):
2947  r"""
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
2951  """
2952  _IMP_algebra.Vector4D_swiginit(self, _IMP_algebra.new_Vector4D(*args))
2953 
2954  def __iadd__(self, *args):
2955  _IMP_algebra.Vector4D___iadd__(self, *args)
2956  return self
2957 
2958 
2959 
2960  def __imul__(self, *args):
2961  _IMP_algebra.Vector4D___imul__(self, *args)
2962  return self
2963 
2964 
2965 
2966  def __idiv__(self, *args):
2967  _IMP_algebra.Vector4D___idiv__(self, *args)
2968  return self
2969 
2970 
2971 
2972  def __isub__(self, *args):
2973  _IMP_algebra.Vector4D___isub__(self, *args)
2974  return self
2975 
2976 
2977 
2978  def __len__(self):
2979  r"""__len__(Vector4D self) -> unsigned int"""
2980  return _IMP_algebra.Vector4D___len__(self)
2981 
2982  def __rmul__(self, f):
2983  r"""__rmul__(Vector4D self, double f) -> Vector4D"""
2984  return _IMP_algebra.Vector4D___rmul__(self, f)
2985 
2986  def __str__(self):
2987  r"""__str__(Vector4D self) -> std::string"""
2988  return _IMP_algebra.Vector4D___str__(self)
2989 
2990  def __repr__(self):
2991  r"""__repr__(Vector4D self) -> std::string"""
2992  return _IMP_algebra.Vector4D___repr__(self)
2993 
2994  def __cmp__(self, arg2):
2995  r"""__cmp__(Vector4D self, Vector4D arg2) -> int"""
2996  return _IMP_algebra.Vector4D___cmp__(self, arg2)
2997 
2998  def __eq__(self, arg2):
2999  r"""__eq__(Vector4D self, Vector4D arg2) -> bool"""
3000  return _IMP_algebra.Vector4D___eq__(self, arg2)
3001 
3002  __truediv__ = __div__
3003  __itruediv__ = __idiv__
3004 
3005 
3006  def _get_as_binary(self):
3007  r"""_get_as_binary(Vector4D self) -> PyObject *"""
3008  return _IMP_algebra.Vector4D__get_as_binary(self)
3009 
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)
3013 
3014  def __getstate__(self):
3015  p = self._get_as_binary()
3016  if len(self.__dict__) > 1:
3017  d = self.__dict__.copy()
3018  del d['this']
3019  p = (d, p)
3020  return p
3021 
3022  def __setstate__(self, p):
3023  if not hasattr(self, 'this'):
3024  self.__init__()
3025  if isinstance(p, tuple):
3026  d, p = p
3027  self.__dict__.update(d)
3028  return self._set_from_binary(p)
3029 
3030 
3031  def __getitem__(self, index):
3032  r"""__getitem__(Vector4D self, int index) -> double"""
3033  return _IMP_algebra.Vector4D___getitem__(self, index)
3034 
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
3039 
3040 # Register Vector4D in _IMP_algebra:
3041 _IMP_algebra.Vector4D_swigregister(Vector4D)
3042 class Vector5D(_VectorBase5D):
3043  r"""Proxy of C++ IMP::algebra::VectorD< 5 > class."""
3044 
3045  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3046 
3047  def get_unit_vector(self):
3048  r"""get_unit_vector(Vector5D self) -> Vector5D"""
3049  return _IMP_algebra.Vector5D_get_unit_vector(self)
3050 
3051  def __truediv__(self, *args):
3052  return _IMP_algebra.Vector5D___truediv__(self, *args)
3053  __div__ = __truediv__
3054 
3055 
3056 
3057  def __neg__(self):
3058  r"""__neg__(Vector5D self) -> Vector5D"""
3059  return _IMP_algebra.Vector5D___neg__(self)
3060 
3061  def __sub__(self, o):
3062  r"""__sub__(Vector5D self, Vector5D o) -> Vector5D"""
3063  return _IMP_algebra.Vector5D___sub__(self, o)
3064 
3065  def __add__(self, ret):
3066  r"""__add__(Vector5D self, Vector5D ret) -> Vector5D"""
3067  return _IMP_algebra.Vector5D___add__(self, ret)
3068 
3069  def __mul__(self, *args):
3070  r"""
3071  __mul__(Vector5D self, double s) -> Vector5D
3072  __mul__(Vector5D self, Vector5D o) -> double
3073  """
3074  return _IMP_algebra.Vector5D___mul__(self, *args)
3075 
3076  def __init__(self, *args):
3077  r"""
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
3081  """
3082  _IMP_algebra.Vector5D_swiginit(self, _IMP_algebra.new_Vector5D(*args))
3083 
3084  def __iadd__(self, *args):
3085  _IMP_algebra.Vector5D___iadd__(self, *args)
3086  return self
3087 
3088 
3089 
3090  def __imul__(self, *args):
3091  _IMP_algebra.Vector5D___imul__(self, *args)
3092  return self
3093 
3094 
3095 
3096  def __idiv__(self, *args):
3097  _IMP_algebra.Vector5D___idiv__(self, *args)
3098  return self
3099 
3100 
3101 
3102  def __isub__(self, *args):
3103  _IMP_algebra.Vector5D___isub__(self, *args)
3104  return self
3105 
3106 
3107 
3108  def __len__(self):
3109  r"""__len__(Vector5D self) -> unsigned int"""
3110  return _IMP_algebra.Vector5D___len__(self)
3111 
3112  def __rmul__(self, f):
3113  r"""__rmul__(Vector5D self, double f) -> Vector5D"""
3114  return _IMP_algebra.Vector5D___rmul__(self, f)
3115 
3116  def __str__(self):
3117  r"""__str__(Vector5D self) -> std::string"""
3118  return _IMP_algebra.Vector5D___str__(self)
3119 
3120  def __repr__(self):
3121  r"""__repr__(Vector5D self) -> std::string"""
3122  return _IMP_algebra.Vector5D___repr__(self)
3123 
3124  def __cmp__(self, arg2):
3125  r"""__cmp__(Vector5D self, Vector5D arg2) -> int"""
3126  return _IMP_algebra.Vector5D___cmp__(self, arg2)
3127 
3128  def __eq__(self, arg2):
3129  r"""__eq__(Vector5D self, Vector5D arg2) -> bool"""
3130  return _IMP_algebra.Vector5D___eq__(self, arg2)
3131 
3132  __truediv__ = __div__
3133  __itruediv__ = __idiv__
3134 
3135 
3136  def _get_as_binary(self):
3137  r"""_get_as_binary(Vector5D self) -> PyObject *"""
3138  return _IMP_algebra.Vector5D__get_as_binary(self)
3139 
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)
3143 
3144  def __getstate__(self):
3145  p = self._get_as_binary()
3146  if len(self.__dict__) > 1:
3147  d = self.__dict__.copy()
3148  del d['this']
3149  p = (d, p)
3150  return p
3151 
3152  def __setstate__(self, p):
3153  if not hasattr(self, 'this'):
3154  self.__init__()
3155  if isinstance(p, tuple):
3156  d, p = p
3157  self.__dict__.update(d)
3158  return self._set_from_binary(p)
3159 
3160 
3161  def __getitem__(self, index):
3162  r"""__getitem__(Vector5D self, int index) -> double"""
3163  return _IMP_algebra.Vector5D___getitem__(self, index)
3164 
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
3169 
3170 # Register Vector5D in _IMP_algebra:
3171 _IMP_algebra.Vector5D_swigregister(Vector5D)
3172 class Vector6D(_VectorBase6D):
3173  r"""Proxy of C++ IMP::algebra::VectorD< 6 > class."""
3174 
3175  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3176 
3177  def get_unit_vector(self):
3178  r"""get_unit_vector(Vector6D self) -> Vector6D"""
3179  return _IMP_algebra.Vector6D_get_unit_vector(self)
3180 
3181  def __truediv__(self, *args):
3182  return _IMP_algebra.Vector6D___truediv__(self, *args)
3183  __div__ = __truediv__
3184 
3185 
3186 
3187  def __neg__(self):
3188  r"""__neg__(Vector6D self) -> Vector6D"""
3189  return _IMP_algebra.Vector6D___neg__(self)
3190 
3191  def __sub__(self, o):
3192  r"""__sub__(Vector6D self, Vector6D o) -> Vector6D"""
3193  return _IMP_algebra.Vector6D___sub__(self, o)
3194 
3195  def __add__(self, ret):
3196  r"""__add__(Vector6D self, Vector6D ret) -> Vector6D"""
3197  return _IMP_algebra.Vector6D___add__(self, ret)
3198 
3199  def __mul__(self, *args):
3200  r"""
3201  __mul__(Vector6D self, double s) -> Vector6D
3202  __mul__(Vector6D self, Vector6D o) -> double
3203  """
3204  return _IMP_algebra.Vector6D___mul__(self, *args)
3205 
3206  def __init__(self, *args):
3207  r"""
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
3211  """
3212  _IMP_algebra.Vector6D_swiginit(self, _IMP_algebra.new_Vector6D(*args))
3213 
3214  def __iadd__(self, *args):
3215  _IMP_algebra.Vector6D___iadd__(self, *args)
3216  return self
3217 
3218 
3219 
3220  def __imul__(self, *args):
3221  _IMP_algebra.Vector6D___imul__(self, *args)
3222  return self
3223 
3224 
3225 
3226  def __idiv__(self, *args):
3227  _IMP_algebra.Vector6D___idiv__(self, *args)
3228  return self
3229 
3230 
3231 
3232  def __isub__(self, *args):
3233  _IMP_algebra.Vector6D___isub__(self, *args)
3234  return self
3235 
3236 
3237 
3238  def __len__(self):
3239  r"""__len__(Vector6D self) -> unsigned int"""
3240  return _IMP_algebra.Vector6D___len__(self)
3241 
3242  def __rmul__(self, f):
3243  r"""__rmul__(Vector6D self, double f) -> Vector6D"""
3244  return _IMP_algebra.Vector6D___rmul__(self, f)
3245 
3246  def __str__(self):
3247  r"""__str__(Vector6D self) -> std::string"""
3248  return _IMP_algebra.Vector6D___str__(self)
3249 
3250  def __repr__(self):
3251  r"""__repr__(Vector6D self) -> std::string"""
3252  return _IMP_algebra.Vector6D___repr__(self)
3253 
3254  def __cmp__(self, arg2):
3255  r"""__cmp__(Vector6D self, Vector6D arg2) -> int"""
3256  return _IMP_algebra.Vector6D___cmp__(self, arg2)
3257 
3258  def __eq__(self, arg2):
3259  r"""__eq__(Vector6D self, Vector6D arg2) -> bool"""
3260  return _IMP_algebra.Vector6D___eq__(self, arg2)
3261 
3262  __truediv__ = __div__
3263  __itruediv__ = __idiv__
3264 
3265 
3266  def _get_as_binary(self):
3267  r"""_get_as_binary(Vector6D self) -> PyObject *"""
3268  return _IMP_algebra.Vector6D__get_as_binary(self)
3269 
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)
3273 
3274  def __getstate__(self):
3275  p = self._get_as_binary()
3276  if len(self.__dict__) > 1:
3277  d = self.__dict__.copy()
3278  del d['this']
3279  p = (d, p)
3280  return p
3281 
3282  def __setstate__(self, p):
3283  if not hasattr(self, 'this'):
3284  self.__init__()
3285  if isinstance(p, tuple):
3286  d, p = p
3287  self.__dict__.update(d)
3288  return self._set_from_binary(p)
3289 
3290 
3291  def __getitem__(self, index):
3292  r"""__getitem__(Vector6D self, int index) -> double"""
3293  return _IMP_algebra.Vector6D___getitem__(self, index)
3294 
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
3299 
3300 # Register Vector6D in _IMP_algebra:
3301 _IMP_algebra.Vector6D_swigregister(Vector6D)
3302 class VectorKD(_VectorBaseKD):
3303  r"""Proxy of C++ IMP::algebra::VectorD< -1 > class."""
3304 
3305  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3306 
3307  def get_unit_vector(self):
3308  r"""get_unit_vector(VectorKD self) -> VectorKD"""
3309  return _IMP_algebra.VectorKD_get_unit_vector(self)
3310 
3311  def __truediv__(self, *args):
3312  return _IMP_algebra.VectorKD___truediv__(self, *args)
3313  __div__ = __truediv__
3314 
3315 
3316 
3317  def __neg__(self):
3318  r"""__neg__(VectorKD self) -> VectorKD"""
3319  return _IMP_algebra.VectorKD___neg__(self)
3320 
3321  def __sub__(self, o):
3322  r"""__sub__(VectorKD self, VectorKD o) -> VectorKD"""
3323  return _IMP_algebra.VectorKD___sub__(self, o)
3324 
3325  def __add__(self, ret):
3326  r"""__add__(VectorKD self, VectorKD ret) -> VectorKD"""
3327  return _IMP_algebra.VectorKD___add__(self, ret)
3328 
3329  def __mul__(self, *args):
3330  r"""
3331  __mul__(VectorKD self, double s) -> VectorKD
3332  __mul__(VectorKD self, VectorKD o) -> double
3333  """
3334  return _IMP_algebra.VectorKD___mul__(self, *args)
3335 
3336  def __init__(self, *args):
3337  r"""
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
3341  """
3342  _IMP_algebra.VectorKD_swiginit(self, _IMP_algebra.new_VectorKD(*args))
3343 
3344  def __iadd__(self, *args):
3345  _IMP_algebra.VectorKD___iadd__(self, *args)
3346  return self
3347 
3348 
3349 
3350  def __imul__(self, *args):
3351  _IMP_algebra.VectorKD___imul__(self, *args)
3352  return self
3353 
3354 
3355 
3356  def __idiv__(self, *args):
3357  _IMP_algebra.VectorKD___idiv__(self, *args)
3358  return self
3359 
3360 
3361 
3362  def __isub__(self, *args):
3363  _IMP_algebra.VectorKD___isub__(self, *args)
3364  return self
3365 
3366 
3367 
3368  def __len__(self):
3369  r"""__len__(VectorKD self) -> unsigned int"""
3370  return _IMP_algebra.VectorKD___len__(self)
3371 
3372  def __rmul__(self, f):
3373  r"""__rmul__(VectorKD self, double f) -> VectorKD"""
3374  return _IMP_algebra.VectorKD___rmul__(self, f)
3375 
3376  def __str__(self):
3377  r"""__str__(VectorKD self) -> std::string"""
3378  return _IMP_algebra.VectorKD___str__(self)
3379 
3380  def __repr__(self):
3381  r"""__repr__(VectorKD self) -> std::string"""
3382  return _IMP_algebra.VectorKD___repr__(self)
3383 
3384  def __cmp__(self, arg2):
3385  r"""__cmp__(VectorKD self, VectorKD arg2) -> int"""
3386  return _IMP_algebra.VectorKD___cmp__(self, arg2)
3387 
3388  def __eq__(self, arg2):
3389  r"""__eq__(VectorKD self, VectorKD arg2) -> bool"""
3390  return _IMP_algebra.VectorKD___eq__(self, arg2)
3391 
3392  __truediv__ = __div__
3393  __itruediv__ = __idiv__
3394 
3395 
3396  def _get_as_binary(self):
3397  r"""_get_as_binary(VectorKD self) -> PyObject *"""
3398  return _IMP_algebra.VectorKD__get_as_binary(self)
3399 
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)
3403 
3404  def __getstate__(self):
3405  p = self._get_as_binary()
3406  if len(self.__dict__) > 1:
3407  d = self.__dict__.copy()
3408  del d['this']
3409  p = (d, p)
3410  return p
3411 
3412  def __setstate__(self, p):
3413  if not hasattr(self, 'this'):
3414  self.__init__()
3415  if isinstance(p, tuple):
3416  d, p = p
3417  self.__dict__.update(d)
3418  return self._set_from_binary(p)
3419 
3420 
3421  def __getitem__(self, index):
3422  r"""__getitem__(VectorKD self, int index) -> double"""
3423  return _IMP_algebra.VectorKD___getitem__(self, index)
3424 
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
3429 
3430 # Register VectorKD in _IMP_algebra:
3431 _IMP_algebra.VectorKD_swigregister(VectorKD)
3432 class BoundingBox1D(object):
3433  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 1 > class."""
3434 
3435  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3436 
3437  def get_dimension(self):
3438  r"""get_dimension(BoundingBox1D self) -> unsigned int"""
3439  return _IMP_algebra.BoundingBox1D_get_dimension(self)
3440 
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)
3444 
3445  def get_contains(self, *args):
3446  r"""
3447  get_contains(BoundingBox1D self, Vector1D o) -> bool
3448  get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
3449  """
3450  return _IMP_algebra.BoundingBox1D_get_contains(self, *args)
3451 
3452  def show(self, *args):
3453  r"""show(BoundingBox1D self, _ostream out=std::cout)"""
3454  return _IMP_algebra.BoundingBox1D_show(self, *args)
3455 
3456  def __str__(self):
3457  r"""__str__(BoundingBox1D self) -> std::string"""
3458  return _IMP_algebra.BoundingBox1D___str__(self)
3459 
3460  def __repr__(self):
3461  r"""__repr__(BoundingBox1D self) -> std::string"""
3462  return _IMP_algebra.BoundingBox1D___repr__(self)
3463 
3464  def __cmp__(self, arg2):
3465  r"""__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
3466  return _IMP_algebra.BoundingBox1D___cmp__(self, arg2)
3467 
3468  def __eq__(self, arg2):
3469  r"""__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
3470  return _IMP_algebra.BoundingBox1D___eq__(self, arg2)
3471 
3472  def __init__(self, *args):
3473  r"""
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
3479  """
3480  _IMP_algebra.BoundingBox1D_swiginit(self, _IMP_algebra.new_BoundingBox1D(*args))
3481 
3482  def __getitem__(self, index):
3483  r"""__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
3484  return _IMP_algebra.BoundingBox1D___getitem__(self, index)
3485 
3486  def __iadd__(self, *args):
3487  _IMP_algebra.BoundingBox1D___iadd__(self, *args)
3488  return self
3489 
3490 
3491 
3492  def __len__(self):
3493  r"""__len__(BoundingBox1D self) -> unsigned int"""
3494  return _IMP_algebra.BoundingBox1D___len__(self)
3495 
3496  def __add__(self, *args):
3497  r"""
3498  __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
3499  __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
3500  __add__(BoundingBox1D self, double o) -> BoundingBox1D
3501  """
3502  return _IMP_algebra.BoundingBox1D___add__(self, *args)
3503 
3504  def _get_as_binary(self):
3505  r"""_get_as_binary(BoundingBox1D self) -> PyObject *"""
3506  return _IMP_algebra.BoundingBox1D__get_as_binary(self)
3507 
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)
3511 
3512  def __getstate__(self):
3513  p = self._get_as_binary()
3514  if len(self.__dict__) > 1:
3515  d = self.__dict__.copy()
3516  del d['this']
3517  p = (d, p)
3518  return p
3519 
3520  def __setstate__(self, p):
3521  if not hasattr(self, 'this'):
3522  self.__init__()
3523  if isinstance(p, tuple):
3524  d, p = p
3525  self.__dict__.update(d)
3526  return self._set_from_binary(p)
3527 
3528  __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
3529 
3530 # Register BoundingBox1D in _IMP_algebra:
3531 _IMP_algebra.BoundingBox1D_swigregister(BoundingBox1D)
3532 class BoundingBox2D(object):
3533  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 2 > class."""
3534 
3535  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3536 
3537  def get_dimension(self):
3538  r"""get_dimension(BoundingBox2D self) -> unsigned int"""
3539  return _IMP_algebra.BoundingBox2D_get_dimension(self)
3540 
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)
3544 
3545  def get_contains(self, *args):
3546  r"""
3547  get_contains(BoundingBox2D self, Vector2D o) -> bool
3548  get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
3549  """
3550  return _IMP_algebra.BoundingBox2D_get_contains(self, *args)
3551 
3552  def show(self, *args):
3553  r"""show(BoundingBox2D self, _ostream out=std::cout)"""
3554  return _IMP_algebra.BoundingBox2D_show(self, *args)
3555 
3556  def __str__(self):
3557  r"""__str__(BoundingBox2D self) -> std::string"""
3558  return _IMP_algebra.BoundingBox2D___str__(self)
3559 
3560  def __repr__(self):
3561  r"""__repr__(BoundingBox2D self) -> std::string"""
3562  return _IMP_algebra.BoundingBox2D___repr__(self)
3563 
3564  def __cmp__(self, arg2):
3565  r"""__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
3566  return _IMP_algebra.BoundingBox2D___cmp__(self, arg2)
3567 
3568  def __eq__(self, arg2):
3569  r"""__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
3570  return _IMP_algebra.BoundingBox2D___eq__(self, arg2)
3571 
3572  def __init__(self, *args):
3573  r"""
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
3579  """
3580  _IMP_algebra.BoundingBox2D_swiginit(self, _IMP_algebra.new_BoundingBox2D(*args))
3581 
3582  def __getitem__(self, index):
3583  r"""__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
3584  return _IMP_algebra.BoundingBox2D___getitem__(self, index)
3585 
3586  def __iadd__(self, *args):
3587  _IMP_algebra.BoundingBox2D___iadd__(self, *args)
3588  return self
3589 
3590 
3591 
3592  def __len__(self):
3593  r"""__len__(BoundingBox2D self) -> unsigned int"""
3594  return _IMP_algebra.BoundingBox2D___len__(self)
3595 
3596  def __add__(self, *args):
3597  r"""
3598  __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
3599  __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
3600  __add__(BoundingBox2D self, double o) -> BoundingBox2D
3601  """
3602  return _IMP_algebra.BoundingBox2D___add__(self, *args)
3603 
3604  def _get_as_binary(self):
3605  r"""_get_as_binary(BoundingBox2D self) -> PyObject *"""
3606  return _IMP_algebra.BoundingBox2D__get_as_binary(self)
3607 
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)
3611 
3612  def __getstate__(self):
3613  p = self._get_as_binary()
3614  if len(self.__dict__) > 1:
3615  d = self.__dict__.copy()
3616  del d['this']
3617  p = (d, p)
3618  return p
3619 
3620  def __setstate__(self, p):
3621  if not hasattr(self, 'this'):
3622  self.__init__()
3623  if isinstance(p, tuple):
3624  d, p = p
3625  self.__dict__.update(d)
3626  return self._set_from_binary(p)
3627 
3628  __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
3629 
3630 # Register BoundingBox2D in _IMP_algebra:
3631 _IMP_algebra.BoundingBox2D_swigregister(BoundingBox2D)
3632 class BoundingBox3D(object):
3633  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 3 > class."""
3634 
3635  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3636 
3637  def get_dimension(self):
3638  r"""get_dimension(BoundingBox3D self) -> unsigned int"""
3639  return _IMP_algebra.BoundingBox3D_get_dimension(self)
3640 
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)
3644 
3645  def get_contains(self, *args):
3646  r"""
3647  get_contains(BoundingBox3D self, Vector3D o) -> bool
3648  get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
3649  """
3650  return _IMP_algebra.BoundingBox3D_get_contains(self, *args)
3651 
3652  def show(self, *args):
3653  r"""show(BoundingBox3D self, _ostream out=std::cout)"""
3654  return _IMP_algebra.BoundingBox3D_show(self, *args)
3655 
3656  def __str__(self):
3657  r"""__str__(BoundingBox3D self) -> std::string"""
3658  return _IMP_algebra.BoundingBox3D___str__(self)
3659 
3660  def __repr__(self):
3661  r"""__repr__(BoundingBox3D self) -> std::string"""
3662  return _IMP_algebra.BoundingBox3D___repr__(self)
3663 
3664  def __cmp__(self, arg2):
3665  r"""__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
3666  return _IMP_algebra.BoundingBox3D___cmp__(self, arg2)
3667 
3668  def __eq__(self, arg2):
3669  r"""__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
3670  return _IMP_algebra.BoundingBox3D___eq__(self, arg2)
3671 
3672  def __init__(self, *args):
3673  r"""
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
3679  """
3680  _IMP_algebra.BoundingBox3D_swiginit(self, _IMP_algebra.new_BoundingBox3D(*args))
3681 
3682  def __getitem__(self, index):
3683  r"""__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
3684  return _IMP_algebra.BoundingBox3D___getitem__(self, index)
3685 
3686  def __iadd__(self, *args):
3687  _IMP_algebra.BoundingBox3D___iadd__(self, *args)
3688  return self
3689 
3690 
3691 
3692  def __len__(self):
3693  r"""__len__(BoundingBox3D self) -> unsigned int"""
3694  return _IMP_algebra.BoundingBox3D___len__(self)
3695 
3696  def __add__(self, *args):
3697  r"""
3698  __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
3699  __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
3700  __add__(BoundingBox3D self, double o) -> BoundingBox3D
3701  """
3702  return _IMP_algebra.BoundingBox3D___add__(self, *args)
3703 
3704  def _get_as_binary(self):
3705  r"""_get_as_binary(BoundingBox3D self) -> PyObject *"""
3706  return _IMP_algebra.BoundingBox3D__get_as_binary(self)
3707 
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)
3711 
3712  def __getstate__(self):
3713  p = self._get_as_binary()
3714  if len(self.__dict__) > 1:
3715  d = self.__dict__.copy()
3716  del d['this']
3717  p = (d, p)
3718  return p
3719 
3720  def __setstate__(self, p):
3721  if not hasattr(self, 'this'):
3722  self.__init__()
3723  if isinstance(p, tuple):
3724  d, p = p
3725  self.__dict__.update(d)
3726  return self._set_from_binary(p)
3727 
3728  __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
3729 
3730 # Register BoundingBox3D in _IMP_algebra:
3731 _IMP_algebra.BoundingBox3D_swigregister(BoundingBox3D)
3732 class BoundingBox4D(object):
3733  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 4 > class."""
3734 
3735  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3736 
3737  def get_dimension(self):
3738  r"""get_dimension(BoundingBox4D self) -> unsigned int"""
3739  return _IMP_algebra.BoundingBox4D_get_dimension(self)
3740 
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)
3744 
3745  def get_contains(self, *args):
3746  r"""
3747  get_contains(BoundingBox4D self, Vector4D o) -> bool
3748  get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
3749  """
3750  return _IMP_algebra.BoundingBox4D_get_contains(self, *args)
3751 
3752  def show(self, *args):
3753  r"""show(BoundingBox4D self, _ostream out=std::cout)"""
3754  return _IMP_algebra.BoundingBox4D_show(self, *args)
3755 
3756  def __str__(self):
3757  r"""__str__(BoundingBox4D self) -> std::string"""
3758  return _IMP_algebra.BoundingBox4D___str__(self)
3759 
3760  def __repr__(self):
3761  r"""__repr__(BoundingBox4D self) -> std::string"""
3762  return _IMP_algebra.BoundingBox4D___repr__(self)
3763 
3764  def __cmp__(self, arg2):
3765  r"""__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
3766  return _IMP_algebra.BoundingBox4D___cmp__(self, arg2)
3767 
3768  def __eq__(self, arg2):
3769  r"""__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
3770  return _IMP_algebra.BoundingBox4D___eq__(self, arg2)
3771 
3772  def __init__(self, *args):
3773  r"""
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
3779  """
3780  _IMP_algebra.BoundingBox4D_swiginit(self, _IMP_algebra.new_BoundingBox4D(*args))
3781 
3782  def __getitem__(self, index):
3783  r"""__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
3784  return _IMP_algebra.BoundingBox4D___getitem__(self, index)
3785 
3786  def __iadd__(self, *args):
3787  _IMP_algebra.BoundingBox4D___iadd__(self, *args)
3788  return self
3789 
3790 
3791 
3792  def __len__(self):
3793  r"""__len__(BoundingBox4D self) -> unsigned int"""
3794  return _IMP_algebra.BoundingBox4D___len__(self)
3795 
3796  def __add__(self, *args):
3797  r"""
3798  __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
3799  __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
3800  __add__(BoundingBox4D self, double o) -> BoundingBox4D
3801  """
3802  return _IMP_algebra.BoundingBox4D___add__(self, *args)
3803 
3804  def _get_as_binary(self):
3805  r"""_get_as_binary(BoundingBox4D self) -> PyObject *"""
3806  return _IMP_algebra.BoundingBox4D__get_as_binary(self)
3807 
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)
3811 
3812  def __getstate__(self):
3813  p = self._get_as_binary()
3814  if len(self.__dict__) > 1:
3815  d = self.__dict__.copy()
3816  del d['this']
3817  p = (d, p)
3818  return p
3819 
3820  def __setstate__(self, p):
3821  if not hasattr(self, 'this'):
3822  self.__init__()
3823  if isinstance(p, tuple):
3824  d, p = p
3825  self.__dict__.update(d)
3826  return self._set_from_binary(p)
3827 
3828  __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
3829 
3830 # Register BoundingBox4D in _IMP_algebra:
3831 _IMP_algebra.BoundingBox4D_swigregister(BoundingBox4D)
3832 class BoundingBox5D(object):
3833  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 5 > class."""
3834 
3835  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3836 
3837  def get_dimension(self):
3838  r"""get_dimension(BoundingBox5D self) -> unsigned int"""
3839  return _IMP_algebra.BoundingBox5D_get_dimension(self)
3840 
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)
3844 
3845  def get_contains(self, *args):
3846  r"""
3847  get_contains(BoundingBox5D self, Vector5D o) -> bool
3848  get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
3849  """
3850  return _IMP_algebra.BoundingBox5D_get_contains(self, *args)
3851 
3852  def show(self, *args):
3853  r"""show(BoundingBox5D self, _ostream out=std::cout)"""
3854  return _IMP_algebra.BoundingBox5D_show(self, *args)
3855 
3856  def __str__(self):
3857  r"""__str__(BoundingBox5D self) -> std::string"""
3858  return _IMP_algebra.BoundingBox5D___str__(self)
3859 
3860  def __repr__(self):
3861  r"""__repr__(BoundingBox5D self) -> std::string"""
3862  return _IMP_algebra.BoundingBox5D___repr__(self)
3863 
3864  def __cmp__(self, arg2):
3865  r"""__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
3866  return _IMP_algebra.BoundingBox5D___cmp__(self, arg2)
3867 
3868  def __eq__(self, arg2):
3869  r"""__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
3870  return _IMP_algebra.BoundingBox5D___eq__(self, arg2)
3871 
3872  def __init__(self, *args):
3873  r"""
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
3879  """
3880  _IMP_algebra.BoundingBox5D_swiginit(self, _IMP_algebra.new_BoundingBox5D(*args))
3881 
3882  def __getitem__(self, index):
3883  r"""__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
3884  return _IMP_algebra.BoundingBox5D___getitem__(self, index)
3885 
3886  def __iadd__(self, *args):
3887  _IMP_algebra.BoundingBox5D___iadd__(self, *args)
3888  return self
3889 
3890 
3891 
3892  def __len__(self):
3893  r"""__len__(BoundingBox5D self) -> unsigned int"""
3894  return _IMP_algebra.BoundingBox5D___len__(self)
3895 
3896  def __add__(self, *args):
3897  r"""
3898  __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
3899  __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
3900  __add__(BoundingBox5D self, double o) -> BoundingBox5D
3901  """
3902  return _IMP_algebra.BoundingBox5D___add__(self, *args)
3903 
3904  def _get_as_binary(self):
3905  r"""_get_as_binary(BoundingBox5D self) -> PyObject *"""
3906  return _IMP_algebra.BoundingBox5D__get_as_binary(self)
3907 
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)
3911 
3912  def __getstate__(self):
3913  p = self._get_as_binary()
3914  if len(self.__dict__) > 1:
3915  d = self.__dict__.copy()
3916  del d['this']
3917  p = (d, p)
3918  return p
3919 
3920  def __setstate__(self, p):
3921  if not hasattr(self, 'this'):
3922  self.__init__()
3923  if isinstance(p, tuple):
3924  d, p = p
3925  self.__dict__.update(d)
3926  return self._set_from_binary(p)
3927 
3928  __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D
3929 
3930 # Register BoundingBox5D in _IMP_algebra:
3931 _IMP_algebra.BoundingBox5D_swigregister(BoundingBox5D)
3932 class BoundingBox6D(object):
3933  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 6 > class."""
3934 
3935  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3936 
3937  def get_dimension(self):
3938  r"""get_dimension(BoundingBox6D self) -> unsigned int"""
3939  return _IMP_algebra.BoundingBox6D_get_dimension(self)
3940 
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)
3944 
3945  def get_contains(self, *args):
3946  r"""
3947  get_contains(BoundingBox6D self, Vector6D o) -> bool
3948  get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
3949  """
3950  return _IMP_algebra.BoundingBox6D_get_contains(self, *args)
3951 
3952  def show(self, *args):
3953  r"""show(BoundingBox6D self, _ostream out=std::cout)"""
3954  return _IMP_algebra.BoundingBox6D_show(self, *args)
3955 
3956  def __str__(self):
3957  r"""__str__(BoundingBox6D self) -> std::string"""
3958  return _IMP_algebra.BoundingBox6D___str__(self)
3959 
3960  def __repr__(self):
3961  r"""__repr__(BoundingBox6D self) -> std::string"""
3962  return _IMP_algebra.BoundingBox6D___repr__(self)
3963 
3964  def __cmp__(self, arg2):
3965  r"""__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
3966  return _IMP_algebra.BoundingBox6D___cmp__(self, arg2)
3967 
3968  def __eq__(self, arg2):
3969  r"""__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
3970  return _IMP_algebra.BoundingBox6D___eq__(self, arg2)
3971 
3972  def __init__(self, *args):
3973  r"""
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
3979  """
3980  _IMP_algebra.BoundingBox6D_swiginit(self, _IMP_algebra.new_BoundingBox6D(*args))
3981 
3982  def __getitem__(self, index):
3983  r"""__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
3984  return _IMP_algebra.BoundingBox6D___getitem__(self, index)
3985 
3986  def __iadd__(self, *args):
3987  _IMP_algebra.BoundingBox6D___iadd__(self, *args)
3988  return self
3989 
3990 
3991 
3992  def __len__(self):
3993  r"""__len__(BoundingBox6D self) -> unsigned int"""
3994  return _IMP_algebra.BoundingBox6D___len__(self)
3995 
3996  def __add__(self, *args):
3997  r"""
3998  __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
3999  __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
4000  __add__(BoundingBox6D self, double o) -> BoundingBox6D
4001  """
4002  return _IMP_algebra.BoundingBox6D___add__(self, *args)
4003 
4004  def _get_as_binary(self):
4005  r"""_get_as_binary(BoundingBox6D self) -> PyObject *"""
4006  return _IMP_algebra.BoundingBox6D__get_as_binary(self)
4007 
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)
4011 
4012  def __getstate__(self):
4013  p = self._get_as_binary()
4014  if len(self.__dict__) > 1:
4015  d = self.__dict__.copy()
4016  del d['this']
4017  p = (d, p)
4018  return p
4019 
4020  def __setstate__(self, p):
4021  if not hasattr(self, 'this'):
4022  self.__init__()
4023  if isinstance(p, tuple):
4024  d, p = p
4025  self.__dict__.update(d)
4026  return self._set_from_binary(p)
4027 
4028  __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
4029 
4030 # Register BoundingBox6D in _IMP_algebra:
4031 _IMP_algebra.BoundingBox6D_swigregister(BoundingBox6D)
4032 class BoundingBoxKD(object):
4033  r"""Proxy of C++ IMP::algebra::BoundingBoxD< -1 > class."""
4034 
4035  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4036 
4037  def get_dimension(self):
4038  r"""get_dimension(BoundingBoxKD self) -> unsigned int"""
4039  return _IMP_algebra.BoundingBoxKD_get_dimension(self)
4040 
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)
4044 
4045  def get_contains(self, *args):
4046  r"""
4047  get_contains(BoundingBoxKD self, VectorKD o) -> bool
4048  get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
4049  """
4050  return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)
4051 
4052  def show(self, *args):
4053  r"""show(BoundingBoxKD self, _ostream out=std::cout)"""
4054  return _IMP_algebra.BoundingBoxKD_show(self, *args)
4055 
4056  def __str__(self):
4057  r"""__str__(BoundingBoxKD self) -> std::string"""
4058  return _IMP_algebra.BoundingBoxKD___str__(self)
4059 
4060  def __repr__(self):
4061  r"""__repr__(BoundingBoxKD self) -> std::string"""
4062  return _IMP_algebra.BoundingBoxKD___repr__(self)
4063 
4064  def __cmp__(self, arg2):
4065  r"""__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
4066  return _IMP_algebra.BoundingBoxKD___cmp__(self, arg2)
4067 
4068  def __eq__(self, arg2):
4069  r"""__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
4070  return _IMP_algebra.BoundingBoxKD___eq__(self, arg2)
4071 
4072  def __init__(self, *args):
4073  r"""
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
4079  """
4080  _IMP_algebra.BoundingBoxKD_swiginit(self, _IMP_algebra.new_BoundingBoxKD(*args))
4081 
4082  def __getitem__(self, index):
4083  r"""__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
4084  return _IMP_algebra.BoundingBoxKD___getitem__(self, index)
4085 
4086  def __iadd__(self, *args):
4087  _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
4088  return self
4089 
4090 
4091 
4092  def __len__(self):
4093  r"""__len__(BoundingBoxKD self) -> unsigned int"""
4094  return _IMP_algebra.BoundingBoxKD___len__(self)
4095 
4096  def __add__(self, *args):
4097  r"""
4098  __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
4099  __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
4100  __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
4101  """
4102  return _IMP_algebra.BoundingBoxKD___add__(self, *args)
4103 
4104  def _get_as_binary(self):
4105  r"""_get_as_binary(BoundingBoxKD self) -> PyObject *"""
4106  return _IMP_algebra.BoundingBoxKD__get_as_binary(self)
4107 
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)
4111 
4112  def __getstate__(self):
4113  p = self._get_as_binary()
4114  if len(self.__dict__) > 1:
4115  d = self.__dict__.copy()
4116  del d['this']
4117  p = (d, p)
4118  return p
4119 
4120  def __setstate__(self, p):
4121  if not hasattr(self, 'this'):
4122  self.__init__()
4123  if isinstance(p, tuple):
4124  d, p = p
4125  self.__dict__.update(d)
4126  return self._set_from_binary(p)
4127 
4128  __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
4129 
4130 # Register BoundingBoxKD in _IMP_algebra:
4131 _IMP_algebra.BoundingBoxKD_swigregister(BoundingBoxKD)
4132 class Sphere1D(_GeometricPrimitive1D):
4133  r"""Proxy of C++ IMP::algebra::SphereD< 1 > class."""
4134 
4135  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4136 
4137  def __init__(self, *args):
4138  r"""
4139  __init__(Sphere1D self) -> Sphere1D
4140  __init__(Sphere1D self, Vector1D center, double radius) -> Sphere1D
4141  """
4142  _IMP_algebra.Sphere1D_swiginit(self, _IMP_algebra.new_Sphere1D(*args))
4143 
4144  def get_radius(self):
4145  r"""get_radius(Sphere1D self) -> double"""
4146  return _IMP_algebra.Sphere1D_get_radius(self)
4147 
4148  def get_center(self):
4149  r"""get_center(Sphere1D self) -> Vector1D"""
4150  return _IMP_algebra.Sphere1D_get_center(self)
4151 
4152  def get_contains(self, *args):
4153  r"""
4154  get_contains(Sphere1D self, Sphere1D o) -> bool
4155  get_contains(Sphere1D self, Vector1D p) -> bool
4156  """
4157  return _IMP_algebra.Sphere1D_get_contains(self, *args)
4158 
4159  def show(self, *args):
4160  r"""show(Sphere1D self, _ostream out=std::cout)"""
4161  return _IMP_algebra.Sphere1D_show(self, *args)
4162 
4163  def get_dimension(self):
4164  r"""get_dimension(Sphere1D self) -> unsigned int"""
4165  return _IMP_algebra.Sphere1D_get_dimension(self)
4166 
4167  def __str__(self):
4168  r"""__str__(Sphere1D self) -> std::string"""
4169  return _IMP_algebra.Sphere1D___str__(self)
4170 
4171  def __repr__(self):
4172  r"""__repr__(Sphere1D self) -> std::string"""
4173  return _IMP_algebra.Sphere1D___repr__(self)
4174 
4175  def __cmp__(self, arg2):
4176  r"""__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
4177  return _IMP_algebra.Sphere1D___cmp__(self, arg2)
4178 
4179  def __eq__(self, arg2):
4180  r"""__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
4181  return _IMP_algebra.Sphere1D___eq__(self, arg2)
4182 
4183  def _get_as_binary(self):
4184  r"""_get_as_binary(Sphere1D self) -> PyObject *"""
4185  return _IMP_algebra.Sphere1D__get_as_binary(self)
4186 
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)
4190 
4191  def __getstate__(self):
4192  p = self._get_as_binary()
4193  if len(self.__dict__) > 1:
4194  d = self.__dict__.copy()
4195  del d['this']
4196  p = (d, p)
4197  return p
4198 
4199  def __setstate__(self, p):
4200  if not hasattr(self, 'this'):
4201  self.__init__()
4202  if isinstance(p, tuple):
4203  d, p = p
4204  self.__dict__.update(d)
4205  return self._set_from_binary(p)
4206 
4207  __swig_destroy__ = _IMP_algebra.delete_Sphere1D
4208 
4209 # Register Sphere1D in _IMP_algebra:
4210 _IMP_algebra.Sphere1D_swigregister(Sphere1D)
4211 class Sphere2D(_GeometricPrimitive2D):
4212  r"""Proxy of C++ IMP::algebra::SphereD< 2 > class."""
4213 
4214  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4215 
4216  def __init__(self, *args):
4217  r"""
4218  __init__(Sphere2D self) -> Sphere2D
4219  __init__(Sphere2D self, Vector2D center, double radius) -> Sphere2D
4220  """
4221  _IMP_algebra.Sphere2D_swiginit(self, _IMP_algebra.new_Sphere2D(*args))
4222 
4223  def get_radius(self):
4224  r"""get_radius(Sphere2D self) -> double"""
4225  return _IMP_algebra.Sphere2D_get_radius(self)
4226 
4227  def get_center(self):
4228  r"""get_center(Sphere2D self) -> Vector2D"""
4229  return _IMP_algebra.Sphere2D_get_center(self)
4230 
4231  def get_contains(self, *args):
4232  r"""
4233  get_contains(Sphere2D self, Sphere2D o) -> bool
4234  get_contains(Sphere2D self, Vector2D p) -> bool
4235  """
4236  return _IMP_algebra.Sphere2D_get_contains(self, *args)
4237 
4238  def show(self, *args):
4239  r"""show(Sphere2D self, _ostream out=std::cout)"""
4240  return _IMP_algebra.Sphere2D_show(self, *args)
4241 
4242  def get_dimension(self):
4243  r"""get_dimension(Sphere2D self) -> unsigned int"""
4244  return _IMP_algebra.Sphere2D_get_dimension(self)
4245 
4246  def __str__(self):
4247  r"""__str__(Sphere2D self) -> std::string"""
4248  return _IMP_algebra.Sphere2D___str__(self)
4249 
4250  def __repr__(self):
4251  r"""__repr__(Sphere2D self) -> std::string"""
4252  return _IMP_algebra.Sphere2D___repr__(self)
4253 
4254  def __cmp__(self, arg2):
4255  r"""__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
4256  return _IMP_algebra.Sphere2D___cmp__(self, arg2)
4257 
4258  def __eq__(self, arg2):
4259  r"""__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
4260  return _IMP_algebra.Sphere2D___eq__(self, arg2)
4261 
4262  def _get_as_binary(self):
4263  r"""_get_as_binary(Sphere2D self) -> PyObject *"""
4264  return _IMP_algebra.Sphere2D__get_as_binary(self)
4265 
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)
4269 
4270  def __getstate__(self):
4271  p = self._get_as_binary()
4272  if len(self.__dict__) > 1:
4273  d = self.__dict__.copy()
4274  del d['this']
4275  p = (d, p)
4276  return p
4277 
4278  def __setstate__(self, p):
4279  if not hasattr(self, 'this'):
4280  self.__init__()
4281  if isinstance(p, tuple):
4282  d, p = p
4283  self.__dict__.update(d)
4284  return self._set_from_binary(p)
4285 
4286  __swig_destroy__ = _IMP_algebra.delete_Sphere2D
4287 
4288 # Register Sphere2D in _IMP_algebra:
4289 _IMP_algebra.Sphere2D_swigregister(Sphere2D)
4290 class Sphere3D(_GeometricPrimitive3D):
4291  r"""Proxy of C++ IMP::algebra::SphereD< 3 > class."""
4292 
4293  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4294 
4295  def __init__(self, *args):
4296  r"""
4297  __init__(Sphere3D self) -> Sphere3D
4298  __init__(Sphere3D self, Vector3D center, double radius) -> Sphere3D
4299  """
4300  _IMP_algebra.Sphere3D_swiginit(self, _IMP_algebra.new_Sphere3D(*args))
4301 
4302  def get_radius(self):
4303  r"""get_radius(Sphere3D self) -> double"""
4304  return _IMP_algebra.Sphere3D_get_radius(self)
4305 
4306  def get_center(self):
4307  r"""get_center(Sphere3D self) -> Vector3D"""
4308  return _IMP_algebra.Sphere3D_get_center(self)
4309 
4310  def get_contains(self, *args):
4311  r"""
4312  get_contains(Sphere3D self, Sphere3D o) -> bool
4313  get_contains(Sphere3D self, Vector3D p) -> bool
4314  """
4315  return _IMP_algebra.Sphere3D_get_contains(self, *args)
4316 
4317  def show(self, *args):
4318  r"""show(Sphere3D self, _ostream out=std::cout)"""
4319  return _IMP_algebra.Sphere3D_show(self, *args)
4320 
4321  def get_dimension(self):
4322  r"""get_dimension(Sphere3D self) -> unsigned int"""
4323  return _IMP_algebra.Sphere3D_get_dimension(self)
4324 
4325  def __str__(self):
4326  r"""__str__(Sphere3D self) -> std::string"""
4327  return _IMP_algebra.Sphere3D___str__(self)
4328 
4329  def __repr__(self):
4330  r"""__repr__(Sphere3D self) -> std::string"""
4331  return _IMP_algebra.Sphere3D___repr__(self)
4332 
4333  def __cmp__(self, arg2):
4334  r"""__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
4335  return _IMP_algebra.Sphere3D___cmp__(self, arg2)
4336 
4337  def __eq__(self, arg2):
4338  r"""__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
4339  return _IMP_algebra.Sphere3D___eq__(self, arg2)
4340 
4341  def _get_as_binary(self):
4342  r"""_get_as_binary(Sphere3D self) -> PyObject *"""
4343  return _IMP_algebra.Sphere3D__get_as_binary(self)
4344 
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)
4348 
4349  def __getstate__(self):
4350  p = self._get_as_binary()
4351  if len(self.__dict__) > 1:
4352  d = self.__dict__.copy()
4353  del d['this']
4354  p = (d, p)
4355  return p
4356 
4357  def __setstate__(self, p):
4358  if not hasattr(self, 'this'):
4359  self.__init__()
4360  if isinstance(p, tuple):
4361  d, p = p
4362  self.__dict__.update(d)
4363  return self._set_from_binary(p)
4364 
4365  __swig_destroy__ = _IMP_algebra.delete_Sphere3D
4366 
4367 # Register Sphere3D in _IMP_algebra:
4368 _IMP_algebra.Sphere3D_swigregister(Sphere3D)
4369 class Sphere4D(_GeometricPrimitive4D):
4370  r"""Proxy of C++ IMP::algebra::SphereD< 4 > class."""
4371 
4372  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4373 
4374  def __init__(self, *args):
4375  r"""
4376  __init__(Sphere4D self) -> Sphere4D
4377  __init__(Sphere4D self, Vector4D center, double radius) -> Sphere4D
4378  """
4379  _IMP_algebra.Sphere4D_swiginit(self, _IMP_algebra.new_Sphere4D(*args))
4380 
4381  def get_radius(self):
4382  r"""get_radius(Sphere4D self) -> double"""
4383  return _IMP_algebra.Sphere4D_get_radius(self)
4384 
4385  def get_center(self):
4386  r"""get_center(Sphere4D self) -> Vector4D"""
4387  return _IMP_algebra.Sphere4D_get_center(self)
4388 
4389  def get_contains(self, *args):
4390  r"""
4391  get_contains(Sphere4D self, Sphere4D o) -> bool
4392  get_contains(Sphere4D self, Vector4D p) -> bool
4393  """
4394  return _IMP_algebra.Sphere4D_get_contains(self, *args)
4395 
4396  def show(self, *args):
4397  r"""show(Sphere4D self, _ostream out=std::cout)"""
4398  return _IMP_algebra.Sphere4D_show(self, *args)
4399 
4400  def get_dimension(self):
4401  r"""get_dimension(Sphere4D self) -> unsigned int"""
4402  return _IMP_algebra.Sphere4D_get_dimension(self)
4403 
4404  def __str__(self):
4405  r"""__str__(Sphere4D self) -> std::string"""
4406  return _IMP_algebra.Sphere4D___str__(self)
4407 
4408  def __repr__(self):
4409  r"""__repr__(Sphere4D self) -> std::string"""
4410  return _IMP_algebra.Sphere4D___repr__(self)
4411 
4412  def __cmp__(self, arg2):
4413  r"""__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
4414  return _IMP_algebra.Sphere4D___cmp__(self, arg2)
4415 
4416  def __eq__(self, arg2):
4417  r"""__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
4418  return _IMP_algebra.Sphere4D___eq__(self, arg2)
4419 
4420  def _get_as_binary(self):
4421  r"""_get_as_binary(Sphere4D self) -> PyObject *"""
4422  return _IMP_algebra.Sphere4D__get_as_binary(self)
4423 
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)
4427 
4428  def __getstate__(self):
4429  p = self._get_as_binary()
4430  if len(self.__dict__) > 1:
4431  d = self.__dict__.copy()
4432  del d['this']
4433  p = (d, p)
4434  return p
4435 
4436  def __setstate__(self, p):
4437  if not hasattr(self, 'this'):
4438  self.__init__()
4439  if isinstance(p, tuple):
4440  d, p = p
4441  self.__dict__.update(d)
4442  return self._set_from_binary(p)
4443 
4444  __swig_destroy__ = _IMP_algebra.delete_Sphere4D
4445 
4446 # Register Sphere4D in _IMP_algebra:
4447 _IMP_algebra.Sphere4D_swigregister(Sphere4D)
4448 class Sphere5D(_GeometricPrimitive5D):
4449  r"""Proxy of C++ IMP::algebra::SphereD< 5 > class."""
4450 
4451  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4452 
4453  def __init__(self, *args):
4454  r"""
4455  __init__(Sphere5D self) -> Sphere5D
4456  __init__(Sphere5D self, Vector5D center, double radius) -> Sphere5D
4457  """
4458  _IMP_algebra.Sphere5D_swiginit(self, _IMP_algebra.new_Sphere5D(*args))
4459 
4460  def get_radius(self):
4461  r"""get_radius(Sphere5D self) -> double"""
4462  return _IMP_algebra.Sphere5D_get_radius(self)
4463 
4464  def get_center(self):
4465  r"""get_center(Sphere5D self) -> Vector5D"""
4466  return _IMP_algebra.Sphere5D_get_center(self)
4467 
4468  def get_contains(self, *args):
4469  r"""
4470  get_contains(Sphere5D self, Sphere5D o) -> bool
4471  get_contains(Sphere5D self, Vector5D p) -> bool
4472  """
4473  return _IMP_algebra.Sphere5D_get_contains(self, *args)
4474 
4475  def show(self, *args):
4476  r"""show(Sphere5D self, _ostream out=std::cout)"""
4477  return _IMP_algebra.Sphere5D_show(self, *args)
4478 
4479  def get_dimension(self):
4480  r"""get_dimension(Sphere5D self) -> unsigned int"""
4481  return _IMP_algebra.Sphere5D_get_dimension(self)
4482 
4483  def __str__(self):
4484  r"""__str__(Sphere5D self) -> std::string"""
4485  return _IMP_algebra.Sphere5D___str__(self)
4486 
4487  def __repr__(self):
4488  r"""__repr__(Sphere5D self) -> std::string"""
4489  return _IMP_algebra.Sphere5D___repr__(self)
4490 
4491  def __cmp__(self, arg2):
4492  r"""__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
4493  return _IMP_algebra.Sphere5D___cmp__(self, arg2)
4494 
4495  def __eq__(self, arg2):
4496  r"""__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
4497  return _IMP_algebra.Sphere5D___eq__(self, arg2)
4498 
4499  def _get_as_binary(self):
4500  r"""_get_as_binary(Sphere5D self) -> PyObject *"""
4501  return _IMP_algebra.Sphere5D__get_as_binary(self)
4502 
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)
4506 
4507  def __getstate__(self):
4508  p = self._get_as_binary()
4509  if len(self.__dict__) > 1:
4510  d = self.__dict__.copy()
4511  del d['this']
4512  p = (d, p)
4513  return p
4514 
4515  def __setstate__(self, p):
4516  if not hasattr(self, 'this'):
4517  self.__init__()
4518  if isinstance(p, tuple):
4519  d, p = p
4520  self.__dict__.update(d)
4521  return self._set_from_binary(p)
4522 
4523  __swig_destroy__ = _IMP_algebra.delete_Sphere5D
4524 
4525 # Register Sphere5D in _IMP_algebra:
4526 _IMP_algebra.Sphere5D_swigregister(Sphere5D)
4527 class Sphere6D(_GeometricPrimitive6D):
4528  r"""Proxy of C++ IMP::algebra::SphereD< 6 > class."""
4529 
4530  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4531 
4532  def __init__(self, *args):
4533  r"""
4534  __init__(Sphere6D self) -> Sphere6D
4535  __init__(Sphere6D self, Vector6D center, double radius) -> Sphere6D
4536  """
4537  _IMP_algebra.Sphere6D_swiginit(self, _IMP_algebra.new_Sphere6D(*args))
4538 
4539  def get_radius(self):
4540  r"""get_radius(Sphere6D self) -> double"""
4541  return _IMP_algebra.Sphere6D_get_radius(self)
4542 
4543  def get_center(self):
4544  r"""get_center(Sphere6D self) -> Vector6D"""
4545  return _IMP_algebra.Sphere6D_get_center(self)
4546 
4547  def get_contains(self, *args):
4548  r"""
4549  get_contains(Sphere6D self, Sphere6D o) -> bool
4550  get_contains(Sphere6D self, Vector6D p) -> bool
4551  """
4552  return _IMP_algebra.Sphere6D_get_contains(self, *args)
4553 
4554  def show(self, *args):
4555  r"""show(Sphere6D self, _ostream out=std::cout)"""
4556  return _IMP_algebra.Sphere6D_show(self, *args)
4557 
4558  def get_dimension(self):
4559  r"""get_dimension(Sphere6D self) -> unsigned int"""
4560  return _IMP_algebra.Sphere6D_get_dimension(self)
4561 
4562  def __str__(self):
4563  r"""__str__(Sphere6D self) -> std::string"""
4564  return _IMP_algebra.Sphere6D___str__(self)
4565 
4566  def __repr__(self):
4567  r"""__repr__(Sphere6D self) -> std::string"""
4568  return _IMP_algebra.Sphere6D___repr__(self)
4569 
4570  def __cmp__(self, arg2):
4571  r"""__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
4572  return _IMP_algebra.Sphere6D___cmp__(self, arg2)
4573 
4574  def __eq__(self, arg2):
4575  r"""__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
4576  return _IMP_algebra.Sphere6D___eq__(self, arg2)
4577 
4578  def _get_as_binary(self):
4579  r"""_get_as_binary(Sphere6D self) -> PyObject *"""
4580  return _IMP_algebra.Sphere6D__get_as_binary(self)
4581 
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)
4585 
4586  def __getstate__(self):
4587  p = self._get_as_binary()
4588  if len(self.__dict__) > 1:
4589  d = self.__dict__.copy()
4590  del d['this']
4591  p = (d, p)
4592  return p
4593 
4594  def __setstate__(self, p):
4595  if not hasattr(self, 'this'):
4596  self.__init__()
4597  if isinstance(p, tuple):
4598  d, p = p
4599  self.__dict__.update(d)
4600  return self._set_from_binary(p)
4601 
4602  __swig_destroy__ = _IMP_algebra.delete_Sphere6D
4603 
4604 # Register Sphere6D in _IMP_algebra:
4605 _IMP_algebra.Sphere6D_swigregister(Sphere6D)
4606 class SphereKD(_GeometricPrimitiveKD):
4607  r"""Proxy of C++ IMP::algebra::SphereD< -1 > class."""
4608 
4609  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4610 
4611  def __init__(self, *args):
4612  r"""
4613  __init__(SphereKD self) -> SphereKD
4614  __init__(SphereKD self, VectorKD center, double radius) -> SphereKD
4615  """
4616  _IMP_algebra.SphereKD_swiginit(self, _IMP_algebra.new_SphereKD(*args))
4617 
4618  def get_radius(self):
4619  r"""get_radius(SphereKD self) -> double"""
4620  return _IMP_algebra.SphereKD_get_radius(self)
4621 
4622  def get_center(self):
4623  r"""get_center(SphereKD self) -> VectorKD"""
4624  return _IMP_algebra.SphereKD_get_center(self)
4625 
4626  def get_contains(self, *args):
4627  r"""
4628  get_contains(SphereKD self, SphereKD o) -> bool
4629  get_contains(SphereKD self, VectorKD p) -> bool
4630  """
4631  return _IMP_algebra.SphereKD_get_contains(self, *args)
4632 
4633  def show(self, *args):
4634  r"""show(SphereKD self, _ostream out=std::cout)"""
4635  return _IMP_algebra.SphereKD_show(self, *args)
4636 
4637  def get_dimension(self):
4638  r"""get_dimension(SphereKD self) -> unsigned int"""
4639  return _IMP_algebra.SphereKD_get_dimension(self)
4640 
4641  def __str__(self):
4642  r"""__str__(SphereKD self) -> std::string"""
4643  return _IMP_algebra.SphereKD___str__(self)
4644 
4645  def __repr__(self):
4646  r"""__repr__(SphereKD self) -> std::string"""
4647  return _IMP_algebra.SphereKD___repr__(self)
4648 
4649  def __cmp__(self, arg2):
4650  r"""__cmp__(SphereKD self, SphereKD arg2) -> int"""
4651  return _IMP_algebra.SphereKD___cmp__(self, arg2)
4652 
4653  def __eq__(self, arg2):
4654  r"""__eq__(SphereKD self, SphereKD arg2) -> bool"""
4655  return _IMP_algebra.SphereKD___eq__(self, arg2)
4656 
4657  def _get_as_binary(self):
4658  r"""_get_as_binary(SphereKD self) -> PyObject *"""
4659  return _IMP_algebra.SphereKD__get_as_binary(self)
4660 
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)
4664 
4665  def __getstate__(self):
4666  p = self._get_as_binary()
4667  if len(self.__dict__) > 1:
4668  d = self.__dict__.copy()
4669  del d['this']
4670  p = (d, p)
4671  return p
4672 
4673  def __setstate__(self, p):
4674  if not hasattr(self, 'this'):
4675  self.__init__()
4676  if isinstance(p, tuple):
4677  d, p = p
4678  self.__dict__.update(d)
4679  return self._set_from_binary(p)
4680 
4681  __swig_destroy__ = _IMP_algebra.delete_SphereKD
4682 
4683 # Register SphereKD in _IMP_algebra:
4684 _IMP_algebra.SphereKD_swigregister(SphereKD)
4685 class UnitSimplex1D(_UnitSimplexBase1D):
4686  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 1 > class."""
4687 
4688  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4689 
4690  def __init__(self):
4691  r"""__init__(UnitSimplex1D self) -> UnitSimplex1D"""
4692  _IMP_algebra.UnitSimplex1D_swiginit(self, _IMP_algebra.new_UnitSimplex1D())
4693 
4694  def show(self, *args):
4695  r"""show(UnitSimplex1D self, _ostream out=std::cout)"""
4696  return _IMP_algebra.UnitSimplex1D_show(self, *args)
4697 
4698  def __str__(self):
4699  r"""__str__(UnitSimplex1D self) -> std::string"""
4700  return _IMP_algebra.UnitSimplex1D___str__(self)
4701 
4702  def __repr__(self):
4703  r"""__repr__(UnitSimplex1D self) -> std::string"""
4704  return _IMP_algebra.UnitSimplex1D___repr__(self)
4705 
4706  def __cmp__(self, arg2):
4707  r"""__cmp__(UnitSimplex1D self, UnitSimplex1D arg2) -> int"""
4708  return _IMP_algebra.UnitSimplex1D___cmp__(self, arg2)
4709 
4710  def __eq__(self, arg2):
4711  r"""__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
4712  return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)
4713 
4714  def _get_as_binary(self):
4715  r"""_get_as_binary(UnitSimplex1D self) -> PyObject *"""
4716  return _IMP_algebra.UnitSimplex1D__get_as_binary(self)
4717 
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)
4721 
4722  def __getstate__(self):
4723  p = self._get_as_binary()
4724  if len(self.__dict__) > 1:
4725  d = self.__dict__.copy()
4726  del d['this']
4727  p = (d, p)
4728  return p
4729 
4730  def __setstate__(self, p):
4731  if not hasattr(self, 'this'):
4732  self.__init__()
4733  if isinstance(p, tuple):
4734  d, p = p
4735  self.__dict__.update(d)
4736  return self._set_from_binary(p)
4737 
4738  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D
4739 
4740 # Register UnitSimplex1D in _IMP_algebra:
4741 _IMP_algebra.UnitSimplex1D_swigregister(UnitSimplex1D)
4742 class UnitSimplex2D(_UnitSimplexBase2D):
4743  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 2 > class."""
4744 
4745  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4746 
4747  def __init__(self):
4748  r"""__init__(UnitSimplex2D self) -> UnitSimplex2D"""
4749  _IMP_algebra.UnitSimplex2D_swiginit(self, _IMP_algebra.new_UnitSimplex2D())
4750 
4751  def show(self, *args):
4752  r"""show(UnitSimplex2D self, _ostream out=std::cout)"""
4753  return _IMP_algebra.UnitSimplex2D_show(self, *args)
4754 
4755  def __str__(self):
4756  r"""__str__(UnitSimplex2D self) -> std::string"""
4757  return _IMP_algebra.UnitSimplex2D___str__(self)
4758 
4759  def __repr__(self):
4760  r"""__repr__(UnitSimplex2D self) -> std::string"""
4761  return _IMP_algebra.UnitSimplex2D___repr__(self)
4762 
4763  def __cmp__(self, arg2):
4764  r"""__cmp__(UnitSimplex2D self, UnitSimplex2D arg2) -> int"""
4765  return _IMP_algebra.UnitSimplex2D___cmp__(self, arg2)
4766 
4767  def __eq__(self, arg2):
4768  r"""__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
4769  return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)
4770 
4771  def _get_as_binary(self):
4772  r"""_get_as_binary(UnitSimplex2D self) -> PyObject *"""
4773  return _IMP_algebra.UnitSimplex2D__get_as_binary(self)
4774 
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)
4778 
4779  def __getstate__(self):
4780  p = self._get_as_binary()
4781  if len(self.__dict__) > 1:
4782  d = self.__dict__.copy()
4783  del d['this']
4784  p = (d, p)
4785  return p
4786 
4787  def __setstate__(self, p):
4788  if not hasattr(self, 'this'):
4789  self.__init__()
4790  if isinstance(p, tuple):
4791  d, p = p
4792  self.__dict__.update(d)
4793  return self._set_from_binary(p)
4794 
4795  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D
4796 
4797 # Register UnitSimplex2D in _IMP_algebra:
4798 _IMP_algebra.UnitSimplex2D_swigregister(UnitSimplex2D)
4799 class UnitSimplex3D(_UnitSimplexBase3D):
4800  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 3 > class."""
4801 
4802  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4803 
4804  def __init__(self):
4805  r"""__init__(UnitSimplex3D self) -> UnitSimplex3D"""
4806  _IMP_algebra.UnitSimplex3D_swiginit(self, _IMP_algebra.new_UnitSimplex3D())
4807 
4808  def show(self, *args):
4809  r"""show(UnitSimplex3D self, _ostream out=std::cout)"""
4810  return _IMP_algebra.UnitSimplex3D_show(self, *args)
4811 
4812  def __str__(self):
4813  r"""__str__(UnitSimplex3D self) -> std::string"""
4814  return _IMP_algebra.UnitSimplex3D___str__(self)
4815 
4816  def __repr__(self):
4817  r"""__repr__(UnitSimplex3D self) -> std::string"""
4818  return _IMP_algebra.UnitSimplex3D___repr__(self)
4819 
4820  def __cmp__(self, arg2):
4821  r"""__cmp__(UnitSimplex3D self, UnitSimplex3D arg2) -> int"""
4822  return _IMP_algebra.UnitSimplex3D___cmp__(self, arg2)
4823 
4824  def __eq__(self, arg2):
4825  r"""__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
4826  return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)
4827 
4828  def _get_as_binary(self):
4829  r"""_get_as_binary(UnitSimplex3D self) -> PyObject *"""
4830  return _IMP_algebra.UnitSimplex3D__get_as_binary(self)
4831 
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)
4835 
4836  def __getstate__(self):
4837  p = self._get_as_binary()
4838  if len(self.__dict__) > 1:
4839  d = self.__dict__.copy()
4840  del d['this']
4841  p = (d, p)
4842  return p
4843 
4844  def __setstate__(self, p):
4845  if not hasattr(self, 'this'):
4846  self.__init__()
4847  if isinstance(p, tuple):
4848  d, p = p
4849  self.__dict__.update(d)
4850  return self._set_from_binary(p)
4851 
4852  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D
4853 
4854 # Register UnitSimplex3D in _IMP_algebra:
4855 _IMP_algebra.UnitSimplex3D_swigregister(UnitSimplex3D)
4856 class UnitSimplex4D(_UnitSimplexBase4D):
4857  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 4 > class."""
4858 
4859  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4860 
4861  def __init__(self):
4862  r"""__init__(UnitSimplex4D self) -> UnitSimplex4D"""
4863  _IMP_algebra.UnitSimplex4D_swiginit(self, _IMP_algebra.new_UnitSimplex4D())
4864 
4865  def show(self, *args):
4866  r"""show(UnitSimplex4D self, _ostream out=std::cout)"""
4867  return _IMP_algebra.UnitSimplex4D_show(self, *args)
4868 
4869  def __str__(self):
4870  r"""__str__(UnitSimplex4D self) -> std::string"""
4871  return _IMP_algebra.UnitSimplex4D___str__(self)
4872 
4873  def __repr__(self):
4874  r"""__repr__(UnitSimplex4D self) -> std::string"""
4875  return _IMP_algebra.UnitSimplex4D___repr__(self)
4876 
4877  def __cmp__(self, arg2):
4878  r"""__cmp__(UnitSimplex4D self, UnitSimplex4D arg2) -> int"""
4879  return _IMP_algebra.UnitSimplex4D___cmp__(self, arg2)
4880 
4881  def __eq__(self, arg2):
4882  r"""__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
4883  return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)
4884 
4885  def _get_as_binary(self):
4886  r"""_get_as_binary(UnitSimplex4D self) -> PyObject *"""
4887  return _IMP_algebra.UnitSimplex4D__get_as_binary(self)
4888 
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)
4892 
4893  def __getstate__(self):
4894  p = self._get_as_binary()
4895  if len(self.__dict__) > 1:
4896  d = self.__dict__.copy()
4897  del d['this']
4898  p = (d, p)
4899  return p
4900 
4901  def __setstate__(self, p):
4902  if not hasattr(self, 'this'):
4903  self.__init__()
4904  if isinstance(p, tuple):
4905  d, p = p
4906  self.__dict__.update(d)
4907  return self._set_from_binary(p)
4908 
4909  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D
4910 
4911 # Register UnitSimplex4D in _IMP_algebra:
4912 _IMP_algebra.UnitSimplex4D_swigregister(UnitSimplex4D)
4913 class UnitSimplex5D(_UnitSimplexBase5D):
4914  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 5 > class."""
4915 
4916  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4917 
4918  def __init__(self):
4919  r"""__init__(UnitSimplex5D self) -> UnitSimplex5D"""
4920  _IMP_algebra.UnitSimplex5D_swiginit(self, _IMP_algebra.new_UnitSimplex5D())
4921 
4922  def show(self, *args):
4923  r"""show(UnitSimplex5D self, _ostream out=std::cout)"""
4924  return _IMP_algebra.UnitSimplex5D_show(self, *args)
4925 
4926  def __str__(self):
4927  r"""__str__(UnitSimplex5D self) -> std::string"""
4928  return _IMP_algebra.UnitSimplex5D___str__(self)
4929 
4930  def __repr__(self):
4931  r"""__repr__(UnitSimplex5D self) -> std::string"""
4932  return _IMP_algebra.UnitSimplex5D___repr__(self)
4933 
4934  def __cmp__(self, arg2):
4935  r"""__cmp__(UnitSimplex5D self, UnitSimplex5D arg2) -> int"""
4936  return _IMP_algebra.UnitSimplex5D___cmp__(self, arg2)
4937 
4938  def __eq__(self, arg2):
4939  r"""__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
4940  return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)
4941 
4942  def _get_as_binary(self):
4943  r"""_get_as_binary(UnitSimplex5D self) -> PyObject *"""
4944  return _IMP_algebra.UnitSimplex5D__get_as_binary(self)
4945 
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)
4949 
4950  def __getstate__(self):
4951  p = self._get_as_binary()
4952  if len(self.__dict__) > 1:
4953  d = self.__dict__.copy()
4954  del d['this']
4955  p = (d, p)
4956  return p
4957 
4958  def __setstate__(self, p):
4959  if not hasattr(self, 'this'):
4960  self.__init__()
4961  if isinstance(p, tuple):
4962  d, p = p
4963  self.__dict__.update(d)
4964  return self._set_from_binary(p)
4965 
4966  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D
4967 
4968 # Register UnitSimplex5D in _IMP_algebra:
4969 _IMP_algebra.UnitSimplex5D_swigregister(UnitSimplex5D)
4970 class UnitSimplex6D(_UnitSimplexBase6D):
4971  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 6 > class."""
4972 
4973  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4974 
4975  def __init__(self):
4976  r"""__init__(UnitSimplex6D self) -> UnitSimplex6D"""
4977  _IMP_algebra.UnitSimplex6D_swiginit(self, _IMP_algebra.new_UnitSimplex6D())
4978 
4979  def show(self, *args):
4980  r"""show(UnitSimplex6D self, _ostream out=std::cout)"""
4981  return _IMP_algebra.UnitSimplex6D_show(self, *args)
4982 
4983  def __str__(self):
4984  r"""__str__(UnitSimplex6D self) -> std::string"""
4985  return _IMP_algebra.UnitSimplex6D___str__(self)
4986 
4987  def __repr__(self):
4988  r"""__repr__(UnitSimplex6D self) -> std::string"""
4989  return _IMP_algebra.UnitSimplex6D___repr__(self)
4990 
4991  def __cmp__(self, arg2):
4992  r"""__cmp__(UnitSimplex6D self, UnitSimplex6D arg2) -> int"""
4993  return _IMP_algebra.UnitSimplex6D___cmp__(self, arg2)
4994 
4995  def __eq__(self, arg2):
4996  r"""__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
4997  return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)
4998 
4999  def _get_as_binary(self):
5000  r"""_get_as_binary(UnitSimplex6D self) -> PyObject *"""
5001  return _IMP_algebra.UnitSimplex6D__get_as_binary(self)
5002 
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)
5006 
5007  def __getstate__(self):
5008  p = self._get_as_binary()
5009  if len(self.__dict__) > 1:
5010  d = self.__dict__.copy()
5011  del d['this']
5012  p = (d, p)
5013  return p
5014 
5015  def __setstate__(self, p):
5016  if not hasattr(self, 'this'):
5017  self.__init__()
5018  if isinstance(p, tuple):
5019  d, p = p
5020  self.__dict__.update(d)
5021  return self._set_from_binary(p)
5022 
5023  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D
5024 
5025 # Register UnitSimplex6D in _IMP_algebra:
5026 _IMP_algebra.UnitSimplex6D_swigregister(UnitSimplex6D)
5027 class UnitSimplexKD(_UnitSimplexBaseKD):
5028  r"""Proxy of C++ IMP::algebra::UnitSimplexD< -1 > class."""
5029 
5030  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5031  __repr__ = _swig_repr
5032 
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))
5036 
5037  def show(self, *args):
5038  r"""show(UnitSimplexKD self, _ostream out=std::cout)"""
5039  return _IMP_algebra.UnitSimplexKD_show(self, *args)
5040 
5041  def _get_as_binary(self):
5042  r"""_get_as_binary(UnitSimplexKD self) -> PyObject *"""
5043  return _IMP_algebra.UnitSimplexKD__get_as_binary(self)
5044 
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)
5048 
5049  def __getstate__(self):
5050  p = self._get_as_binary()
5051  if len(self.__dict__) > 1:
5052  d = self.__dict__.copy()
5053  del d['this']
5054  p = (d, p)
5055  return p
5056 
5057  def __setstate__(self, p):
5058  if not hasattr(self, 'this'):
5059  self.__init__()
5060  if isinstance(p, tuple):
5061  d, p = p
5062  self.__dict__.update(d)
5063  return self._set_from_binary(p)
5064 
5065  __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD
5066 
5067 # Register UnitSimplexKD in _IMP_algebra:
5068 _IMP_algebra.UnitSimplexKD_swigregister(UnitSimplexKD)
5069 class ReferenceFrame3D(object):
5070  r"""Proxy of C++ IMP::algebra::ReferenceFrame3D class."""
5071 
5072  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5073 
5074  def __init__(self, *args):
5075  r"""
5076  __init__(ReferenceFrame3D self, ReferenceFrame3D arg2) -> ReferenceFrame3D
5077  __init__(ReferenceFrame3D self) -> ReferenceFrame3D
5078  __init__(ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
5079  """
5080  _IMP_algebra.ReferenceFrame3D_swiginit(self, _IMP_algebra.new_ReferenceFrame3D(*args))
5081  __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
5082 
5083  def get_transformation_to(self):
5084  r"""get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
5085  return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)
5086 
5087  def get_transformation_from(self):
5088  r"""get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
5089  return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)
5090 
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)
5094 
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)
5098 
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)
5102 
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)
5106 
5107  def show(self, *args):
5108  r"""show(ReferenceFrame3D self, _ostream out=std::cout)"""
5109  return _IMP_algebra.ReferenceFrame3D_show(self, *args)
5110 
5111  def __str__(self):
5112  r"""__str__(ReferenceFrame3D self) -> std::string"""
5113  return _IMP_algebra.ReferenceFrame3D___str__(self)
5114 
5115  def __repr__(self):
5116  r"""__repr__(ReferenceFrame3D self) -> std::string"""
5117  return _IMP_algebra.ReferenceFrame3D___repr__(self)
5118 
5119  def _get_as_binary(self):
5120  r"""_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
5121  return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)
5122 
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)
5126 
5127  def __getstate__(self):
5128  p = self._get_as_binary()
5129  if len(self.__dict__) > 1:
5130  d = self.__dict__.copy()
5131  del d['this']
5132  p = (d, p)
5133  return p
5134 
5135  def __setstate__(self, p):
5136  if not hasattr(self, 'this'):
5137  self.__init__()
5138  if isinstance(p, tuple):
5139  d, p = p
5140  self.__dict__.update(d)
5141  return self._set_from_binary(p)
5142 
5143 
5144 # Register ReferenceFrame3D in _IMP_algebra:
5145 _IMP_algebra.ReferenceFrame3D_swigregister(ReferenceFrame3D)
5146 
5147 def get_transformed(*args):
5148  r"""
5149  get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
5150  get_transformed(Line3D l, Transformation3D tr) -> Line3D
5151  get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
5152  """
5153  return _IMP_algebra.get_transformed(*args)
5154 
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."""
5160 
5161  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5162 
5163  def __init__(self, *args):
5164  r"""
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
5168  """
5169  _IMP_algebra.SphericalVector3D_swiginit(self, _IMP_algebra.new_SphericalVector3D(*args))
5170 
5171  def get_cartesian_coordinates(self):
5172  r"""get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
5173  return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)
5174 
5175  def show(self, *args):
5176  r"""show(SphericalVector3D self, _ostream out=std::cout)"""
5177  return _IMP_algebra.SphericalVector3D_show(self, *args)
5178 
5179  def __str__(self):
5180  r"""__str__(SphericalVector3D self) -> std::string"""
5181  return _IMP_algebra.SphericalVector3D___str__(self)
5182 
5183  def __repr__(self):
5184  r"""__repr__(SphericalVector3D self) -> std::string"""
5185  return _IMP_algebra.SphericalVector3D___repr__(self)
5186 
5187  def _get_as_binary(self):
5188  r"""_get_as_binary(SphericalVector3D self) -> PyObject *"""
5189  return _IMP_algebra.SphericalVector3D__get_as_binary(self)
5190 
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)
5194 
5195  def __getstate__(self):
5196  p = self._get_as_binary()
5197  if len(self.__dict__) > 1:
5198  d = self.__dict__.copy()
5199  del d['this']
5200  p = (d, p)
5201  return p
5202 
5203  def __setstate__(self, p):
5204  if not hasattr(self, 'this'):
5205  self.__init__()
5206  if isinstance(p, tuple):
5207  d, p = p
5208  self.__dict__.update(d)
5209  return self._set_from_binary(p)
5210 
5211 
5212  def __getitem__(self, index):
5213  r"""__getitem__(SphericalVector3D self, unsigned int index) -> double"""
5214  return _IMP_algebra.SphericalVector3D___getitem__(self, index)
5215 
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
5220 
5221 # Register SphericalVector3D in _IMP_algebra:
5222 _IMP_algebra.SphericalVector3D_swigregister(SphericalVector3D)
5223 
5224 def get_alignments_from_first_to_second(pca1, pca2):
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."""
5229 
5230  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5231 
5232  def __init__(self, *args):
5233  r"""
5234  __init__(Line3D self) -> Line3D
5235  __init__(Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
5236  __init__(Line3D self, Segment3D s) -> Line3D
5237  """
5238  _IMP_algebra.Line3D_swiginit(self, _IMP_algebra.new_Line3D(*args))
5239 
5240  def get_direction(self):
5241  r"""get_direction(Line3D self) -> Vector3D"""
5242  return _IMP_algebra.Line3D_get_direction(self)
5243 
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)
5247 
5248  def get_moment(self, *args):
5249  r"""
5250  get_moment(Line3D self) -> Vector3D
5251  get_moment(Line3D self, Vector3D v) -> Vector3D
5252  """
5253  return _IMP_algebra.Line3D_get_moment(self, *args)
5254 
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)
5258 
5259  def get_opposite(self):
5260  r"""get_opposite(Line3D self) -> Line3D"""
5261  return _IMP_algebra.Line3D_get_opposite(self)
5262 
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)
5266 
5267  def show(self, *args):
5268  r"""show(Line3D self, _ostream out=std::cout)"""
5269  return _IMP_algebra.Line3D_show(self, *args)
5270 
5271  def __str__(self):
5272  r"""__str__(Line3D self) -> std::string"""
5273  return _IMP_algebra.Line3D___str__(self)
5274 
5275  def __repr__(self):
5276  r"""__repr__(Line3D self) -> std::string"""
5277  return _IMP_algebra.Line3D___repr__(self)
5278 
5279  def _get_as_binary(self):
5280  r"""_get_as_binary(Line3D self) -> PyObject *"""
5281  return _IMP_algebra.Line3D__get_as_binary(self)
5282 
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)
5286 
5287  def __getstate__(self):
5288  p = self._get_as_binary()
5289  if len(self.__dict__) > 1:
5290  d = self.__dict__.copy()
5291  del d['this']
5292  p = (d, p)
5293  return p
5294 
5295  def __setstate__(self, p):
5296  if not hasattr(self, 'this'):
5297  self.__init__()
5298  if isinstance(p, tuple):
5299  d, p = p
5300  self.__dict__.update(d)
5301  return self._set_from_binary(p)
5302 
5303  __swig_destroy__ = _IMP_algebra.delete_Line3D
5304 
5305 # Register Line3D in _IMP_algebra:
5306 _IMP_algebra.Line3D_swigregister(Line3D)
5307 
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)
5311 
5312 def get_angle(a, b):
5313  r"""get_angle(Line3D a, Line3D b) -> double"""
5314  return _IMP_algebra.get_angle(a, b)
5315 
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."""
5321 
5322  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5323 
5324  def __init__(self, *args):
5325  r"""
5326  __init__(Segment3D self) -> Segment3D
5327  __init__(Segment3D self, Vector3D start, Vector3D end) -> Segment3D
5328  """
5329  _IMP_algebra.Segment3D_swiginit(self, _IMP_algebra.new_Segment3D(*args))
5330 
5331  def get_point(self, i):
5332  if i < 0 or i >= 2:
5333  raise IMP.UsageException("Invalid point index")
5334  return _IMP_algebra.Segment3D_get_point(self, i)
5335 
5336 
5337 
5338  def get_middle_point(self):
5339  r"""get_middle_point(Segment3D self) -> Vector3D"""
5340  return _IMP_algebra.Segment3D_get_middle_point(self)
5341 
5342  def get_direction(self):
5343  r"""get_direction(Segment3D self) -> Vector3D"""
5344  return _IMP_algebra.Segment3D_get_direction(self)
5345 
5346  def get_length(self):
5347  r"""get_length(Segment3D self) -> double"""
5348  return _IMP_algebra.Segment3D_get_length(self)
5349 
5350  def show(self, *args):
5351  r"""show(Segment3D self, _ostream out=std::cout)"""
5352  return _IMP_algebra.Segment3D_show(self, *args)
5353 
5354  def __str__(self):
5355  r"""__str__(Segment3D self) -> std::string"""
5356  return _IMP_algebra.Segment3D___str__(self)
5357 
5358  def __repr__(self):
5359  r"""__repr__(Segment3D self) -> std::string"""
5360  return _IMP_algebra.Segment3D___repr__(self)
5361 
5362  def _get_as_binary(self):
5363  r"""_get_as_binary(Segment3D self) -> PyObject *"""
5364  return _IMP_algebra.Segment3D__get_as_binary(self)
5365 
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)
5369 
5370  def __getstate__(self):
5371  p = self._get_as_binary()
5372  if len(self.__dict__) > 1:
5373  d = self.__dict__.copy()
5374  del d['this']
5375  p = (d, p)
5376  return p
5377 
5378  def __setstate__(self, p):
5379  if not hasattr(self, 'this'):
5380  self.__init__()
5381  if isinstance(p, tuple):
5382  d, p = p
5383  self.__dict__.update(d)
5384  return self._set_from_binary(p)
5385 
5386  __swig_destroy__ = _IMP_algebra.delete_Segment3D
5387 
5388 # Register Segment3D in _IMP_algebra:
5389 _IMP_algebra.Segment3D_swigregister(Segment3D)
5390 
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)
5394 
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."""
5400 
5401  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5402 
5403  def __init__(self, *args):
5404  r"""
5405  __init__(Triangle3D self) -> Triangle3D
5406  __init__(Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
5407  """
5408  _IMP_algebra.Triangle3D_swiginit(self, _IMP_algebra.new_Triangle3D(*args))
5409 
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)
5413 
5414  def show(self, *args):
5415  r"""show(Triangle3D self, _ostream out=std::cout)"""
5416  return _IMP_algebra.Triangle3D_show(self, *args)
5417 
5418  def get_edge_lengths(self):
5419  r"""get_edge_lengths(Triangle3D self) -> IMP::Floats"""
5420  return _IMP_algebra.Triangle3D_get_edge_lengths(self)
5421 
5422  def __str__(self):
5423  r"""__str__(Triangle3D self) -> std::string"""
5424  return _IMP_algebra.Triangle3D___str__(self)
5425 
5426  def __repr__(self):
5427  r"""__repr__(Triangle3D self) -> std::string"""
5428  return _IMP_algebra.Triangle3D___repr__(self)
5429 
5430  def _get_as_binary(self):
5431  r"""_get_as_binary(Triangle3D self) -> PyObject *"""
5432  return _IMP_algebra.Triangle3D__get_as_binary(self)
5433 
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)
5437 
5438  def __getstate__(self):
5439  p = self._get_as_binary()
5440  if len(self.__dict__) > 1:
5441  d = self.__dict__.copy()
5442  del d['this']
5443  p = (d, p)
5444  return p
5445 
5446  def __setstate__(self, p):
5447  if not hasattr(self, 'this'):
5448  self.__init__()
5449  if isinstance(p, tuple):
5450  d, p = p
5451  self.__dict__.update(d)
5452  return self._set_from_binary(p)
5453 
5454  __swig_destroy__ = _IMP_algebra.delete_Triangle3D
5455 
5456 # Register Triangle3D in _IMP_algebra:
5457 _IMP_algebra.Triangle3D_swigregister(Triangle3D)
5458 
5459 def get_largest_triangle(points):
5460  r"""get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
5461  return _IMP_algebra.get_largest_triangle(points)
5462 
5463 def get_transformation_from_first_triangle_to_second(first_tri, second_tri):
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)
5466 
5467 def get_are_colinear(p1, p2, p3):
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."""
5472 
5473  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5474 
5475  def __init__(self, *args):
5476  r"""
5477  __init__(LinearFit2D self) -> LinearFit2D
5478  __init__(LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
5479  """
5480  _IMP_algebra.LinearFit2D_swiginit(self, _IMP_algebra.new_LinearFit2D(*args))
5481 
5482  def get_fit_error(self):
5483  r"""get_fit_error(LinearFit2D self) -> double"""
5484  return _IMP_algebra.LinearFit2D_get_fit_error(self)
5485 
5486  def get_a(self):
5487  r"""get_a(LinearFit2D self) -> double"""
5488  return _IMP_algebra.LinearFit2D_get_a(self)
5489 
5490  def get_b(self):
5491  r"""get_b(LinearFit2D self) -> double"""
5492  return _IMP_algebra.LinearFit2D_get_b(self)
5493 
5494  def show(self, *args):
5495  r"""show(LinearFit2D self, _ostream out=std::cout)"""
5496  return _IMP_algebra.LinearFit2D_show(self, *args)
5497 
5498  def __str__(self):
5499  r"""__str__(LinearFit2D self) -> std::string"""
5500  return _IMP_algebra.LinearFit2D___str__(self)
5501 
5502  def __repr__(self):
5503  r"""__repr__(LinearFit2D self) -> std::string"""
5504  return _IMP_algebra.LinearFit2D___repr__(self)
5505 
5506  def _get_as_binary(self):
5507  r"""_get_as_binary(LinearFit2D self) -> PyObject *"""
5508  return _IMP_algebra.LinearFit2D__get_as_binary(self)
5509 
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)
5513 
5514  def __getstate__(self):
5515  p = self._get_as_binary()
5516  if len(self.__dict__) > 1:
5517  d = self.__dict__.copy()
5518  del d['this']
5519  p = (d, p)
5520  return p
5521 
5522  def __setstate__(self, p):
5523  if not hasattr(self, 'this'):
5524  self.__init__()
5525  if isinstance(p, tuple):
5526  d, p = p
5527  self.__dict__.update(d)
5528  return self._set_from_binary(p)
5529 
5530  __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
5531 
5532 # Register LinearFit2D in _IMP_algebra:
5533 _IMP_algebra.LinearFit2D_swigregister(LinearFit2D)
5534 class ParabolicFit2D(_GeometricPrimitive2D):
5535  r"""Proxy of C++ IMP::algebra::ParabolicFit2D class."""
5536 
5537  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5538 
5539  def __init__(self, *args):
5540  r"""
5541  __init__(ParabolicFit2D self) -> ParabolicFit2D
5542  __init__(ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
5543  """
5544  _IMP_algebra.ParabolicFit2D_swiginit(self, _IMP_algebra.new_ParabolicFit2D(*args))
5545 
5546  def get_fit_error(self):
5547  r"""get_fit_error(ParabolicFit2D self) -> double"""
5548  return _IMP_algebra.ParabolicFit2D_get_fit_error(self)
5549 
5550  def get_a(self):
5551  r"""get_a(ParabolicFit2D self) -> double"""
5552  return _IMP_algebra.ParabolicFit2D_get_a(self)
5553 
5554  def get_b(self):
5555  r"""get_b(ParabolicFit2D self) -> double"""
5556  return _IMP_algebra.ParabolicFit2D_get_b(self)
5557 
5558  def get_c(self):
5559  r"""get_c(ParabolicFit2D self) -> double"""
5560  return _IMP_algebra.ParabolicFit2D_get_c(self)
5561 
5562  def show(self, *args):
5563  r"""show(ParabolicFit2D self, _ostream out=std::cout)"""
5564  return _IMP_algebra.ParabolicFit2D_show(self, *args)
5565 
5566  def __str__(self):
5567  r"""__str__(ParabolicFit2D self) -> std::string"""
5568  return _IMP_algebra.ParabolicFit2D___str__(self)
5569 
5570  def __repr__(self):
5571  r"""__repr__(ParabolicFit2D self) -> std::string"""
5572  return _IMP_algebra.ParabolicFit2D___repr__(self)
5573 
5574  def _get_as_binary(self):
5575  r"""_get_as_binary(ParabolicFit2D self) -> PyObject *"""
5576  return _IMP_algebra.ParabolicFit2D__get_as_binary(self)
5577 
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)
5581 
5582  def __getstate__(self):
5583  p = self._get_as_binary()
5584  if len(self.__dict__) > 1:
5585  d = self.__dict__.copy()
5586  del d['this']
5587  p = (d, p)
5588  return p
5589 
5590  def __setstate__(self, p):
5591  if not hasattr(self, 'this'):
5592  self.__init__()
5593  if isinstance(p, tuple):
5594  d, p = p
5595  self.__dict__.update(d)
5596  return self._set_from_binary(p)
5597 
5598  __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
5599 
5600 # Register ParabolicFit2D in _IMP_algebra:
5601 _IMP_algebra.ParabolicFit2D_swigregister(ParabolicFit2D)
5602 class Plane3D(_GeometricPrimitive3D):
5603  r"""Proxy of C++ IMP::algebra::Plane3D class."""
5604 
5605  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5606 
5607  def __init__(self, *args):
5608  r"""
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
5612  """
5613  _IMP_algebra.Plane3D_swiginit(self, _IMP_algebra.new_Plane3D(*args))
5614 
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)
5618 
5619  def get_normal(self):
5620  r"""get_normal(Plane3D self) -> Vector3D"""
5621  return _IMP_algebra.Plane3D_get_normal(self)
5622 
5623  def get_projected(self, p):
5624  r"""get_projected(Plane3D self, Vector3D p) -> Vector3D"""
5625  return _IMP_algebra.Plane3D_get_projected(self, p)
5626 
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)
5630 
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)
5634 
5635  def get_height(self, p):
5636  r"""get_height(Plane3D self, Vector3D p) -> double"""
5637  return _IMP_algebra.Plane3D_get_height(self, p)
5638 
5639  def show(self, *args):
5640  r"""show(Plane3D self, _ostream out=std::cout)"""
5641  return _IMP_algebra.Plane3D_show(self, *args)
5642 
5643  def get_opposite(self):
5644  r"""get_opposite(Plane3D self) -> Plane3D"""
5645  return _IMP_algebra.Plane3D_get_opposite(self)
5646 
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)
5650 
5651  def __str__(self):
5652  r"""__str__(Plane3D self) -> std::string"""
5653  return _IMP_algebra.Plane3D___str__(self)
5654 
5655  def __repr__(self):
5656  r"""__repr__(Plane3D self) -> std::string"""
5657  return _IMP_algebra.Plane3D___repr__(self)
5658 
5659  def _get_as_binary(self):
5660  r"""_get_as_binary(Plane3D self) -> PyObject *"""
5661  return _IMP_algebra.Plane3D__get_as_binary(self)
5662 
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)
5666 
5667  def __getstate__(self):
5668  p = self._get_as_binary()
5669  if len(self.__dict__) > 1:
5670  d = self.__dict__.copy()
5671  del d['this']
5672  p = (d, p)
5673  return p
5674 
5675  def __setstate__(self, p):
5676  if not hasattr(self, 'this'):
5677  self.__init__()
5678  if isinstance(p, tuple):
5679  d, p = p
5680  self.__dict__.update(d)
5681  return self._set_from_binary(p)
5682 
5683  __swig_destroy__ = _IMP_algebra.delete_Plane3D
5684 
5685 # Register Plane3D in _IMP_algebra:
5686 _IMP_algebra.Plane3D_swigregister(Plane3D)
5687 
5688 def get_reflected(pln, p):
5689  r"""get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
5690  return _IMP_algebra.get_reflected(pln, p)
5691 
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."""
5697 
5698  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5699 
5700  def __init__(self, *args):
5701  r"""
5702  __init__(Reflection3D self) -> Reflection3D
5703  __init__(Reflection3D self, Plane3D pl) -> Reflection3D
5704  """
5705  _IMP_algebra.Reflection3D_swiginit(self, _IMP_algebra.new_Reflection3D(*args))
5706 
5707  def get_reflected(self, v):
5708  r"""get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
5709  return _IMP_algebra.Reflection3D_get_reflected(self, v)
5710 
5711  def show(self, *args):
5712  r"""show(Reflection3D self, _ostream out=std::cout)"""
5713  return _IMP_algebra.Reflection3D_show(self, *args)
5714 
5715  def __str__(self):
5716  r"""__str__(Reflection3D self) -> std::string"""
5717  return _IMP_algebra.Reflection3D___str__(self)
5718 
5719  def __repr__(self):
5720  r"""__repr__(Reflection3D self) -> std::string"""
5721  return _IMP_algebra.Reflection3D___repr__(self)
5722 
5723  def _get_as_binary(self):
5724  r"""_get_as_binary(Reflection3D self) -> PyObject *"""
5725  return _IMP_algebra.Reflection3D__get_as_binary(self)
5726 
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)
5730 
5731  def __getstate__(self):
5732  p = self._get_as_binary()
5733  if len(self.__dict__) > 1:
5734  d = self.__dict__.copy()
5735  del d['this']
5736  p = (d, p)
5737  return p
5738 
5739  def __setstate__(self, p):
5740  if not hasattr(self, 'this'):
5741  self.__init__()
5742  if isinstance(p, tuple):
5743  d, p = p
5744  self.__dict__.update(d)
5745  return self._set_from_binary(p)
5746 
5747  __swig_destroy__ = _IMP_algebra.delete_Reflection3D
5748 
5749 # Register Reflection3D in _IMP_algebra:
5750 _IMP_algebra.Reflection3D_swigregister(Reflection3D)
5751 class Cylinder3D(_GeometricPrimitive3D):
5752  r"""Proxy of C++ IMP::algebra::Cylinder3D class."""
5753 
5754  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5755 
5756  def __init__(self, *args):
5757  r"""
5758  __init__(Cylinder3D self) -> Cylinder3D
5759  __init__(Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
5760  """
5761  _IMP_algebra.Cylinder3D_swiginit(self, _IMP_algebra.new_Cylinder3D(*args))
5762 
5763  def get_radius(self):
5764  r"""get_radius(Cylinder3D self) -> double"""
5765  return _IMP_algebra.Cylinder3D_get_radius(self)
5766 
5767  def get_segment(self):
5768  r"""get_segment(Cylinder3D self) -> Segment3D"""
5769  return _IMP_algebra.Cylinder3D_get_segment(self)
5770 
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)
5774 
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)
5778 
5779  def show(self, *args):
5780  r"""show(Cylinder3D self, _ostream out=std::cout)"""
5781  return _IMP_algebra.Cylinder3D_show(self, *args)
5782 
5783  def __str__(self):
5784  r"""__str__(Cylinder3D self) -> std::string"""
5785  return _IMP_algebra.Cylinder3D___str__(self)
5786 
5787  def __repr__(self):
5788  r"""__repr__(Cylinder3D self) -> std::string"""
5789  return _IMP_algebra.Cylinder3D___repr__(self)
5790 
5791  def _get_as_binary(self):
5792  r"""_get_as_binary(Cylinder3D self) -> PyObject *"""
5793  return _IMP_algebra.Cylinder3D__get_as_binary(self)
5794 
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)
5798 
5799  def __getstate__(self):
5800  p = self._get_as_binary()
5801  if len(self.__dict__) > 1:
5802  d = self.__dict__.copy()
5803  del d['this']
5804  p = (d, p)
5805  return p
5806 
5807  def __setstate__(self, p):
5808  if not hasattr(self, 'this'):
5809  self.__init__()
5810  if isinstance(p, tuple):
5811  d, p = p
5812  self.__dict__.update(d)
5813  return self._set_from_binary(p)
5814 
5815  __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
5816 
5817 # Register Cylinder3D in _IMP_algebra:
5818 _IMP_algebra.Cylinder3D_swigregister(Cylinder3D)
5819 
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."""
5825 
5826  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5827 
5828  def __init__(self, *args):
5829  r"""
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
5833  """
5834  _IMP_algebra.Ellipsoid3D_swiginit(self, _IMP_algebra.new_Ellipsoid3D(*args))
5835 
5836  def get_radii(self):
5837  r"""get_radii(Ellipsoid3D self) -> Vector3D"""
5838  return _IMP_algebra.Ellipsoid3D_get_radii(self)
5839 
5840  def get_reference_frame(self):
5841  r"""get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
5842  return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)
5843 
5844  def show(self, *args):
5845  r"""show(Ellipsoid3D self, _ostream out=std::cout)"""
5846  return _IMP_algebra.Ellipsoid3D_show(self, *args)
5847 
5848  def __str__(self):
5849  r"""__str__(Ellipsoid3D self) -> std::string"""
5850  return _IMP_algebra.Ellipsoid3D___str__(self)
5851 
5852  def __repr__(self):
5853  r"""__repr__(Ellipsoid3D self) -> std::string"""
5854  return _IMP_algebra.Ellipsoid3D___repr__(self)
5855 
5856  def _get_as_binary(self):
5857  r"""_get_as_binary(Ellipsoid3D self) -> PyObject *"""
5858  return _IMP_algebra.Ellipsoid3D__get_as_binary(self)
5859 
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)
5863 
5864  def __getstate__(self):
5865  p = self._get_as_binary()
5866  if len(self.__dict__) > 1:
5867  d = self.__dict__.copy()
5868  del d['this']
5869  p = (d, p)
5870  return p
5871 
5872  def __setstate__(self, p):
5873  if not hasattr(self, 'this'):
5874  self.__init__()
5875  if isinstance(p, tuple):
5876  d, p = p
5877  self.__dict__.update(d)
5878  return self._set_from_binary(p)
5879 
5880  __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
5881 
5882 # Register Ellipsoid3D in _IMP_algebra:
5883 _IMP_algebra.Ellipsoid3D_swigregister(Ellipsoid3D)
5884 
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."""
5890 
5891  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5892 
5893  def __init__(self, *args):
5894  r"""
5895  __init__(ConnollySurfacePoint self) -> ConnollySurfacePoint
5896  __init__(ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
5897  """
5898  _IMP_algebra.ConnollySurfacePoint_swiginit(self, _IMP_algebra.new_ConnollySurfacePoint(*args))
5899 
5900  def get_atom(self, i):
5901  r"""get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
5902  return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)
5903 
5904  def get_surface_point(self):
5905  r"""get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
5906  return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)
5907 
5908  def get_area(self):
5909  r"""get_area(ConnollySurfacePoint self) -> double"""
5910  return _IMP_algebra.ConnollySurfacePoint_get_area(self)
5911 
5912  def get_normal(self):
5913  r"""get_normal(ConnollySurfacePoint self) -> Vector3D"""
5914  return _IMP_algebra.ConnollySurfacePoint_get_normal(self)
5915 
5916  def show(self, *args):
5917  r"""show(ConnollySurfacePoint self, _ostream out=std::cout)"""
5918  return _IMP_algebra.ConnollySurfacePoint_show(self, *args)
5919 
5920  def __str__(self):
5921  r"""__str__(ConnollySurfacePoint self) -> std::string"""
5922  return _IMP_algebra.ConnollySurfacePoint___str__(self)
5923 
5924  def __repr__(self):
5925  r"""__repr__(ConnollySurfacePoint self) -> std::string"""
5926  return _IMP_algebra.ConnollySurfacePoint___repr__(self)
5927 
5928  def _get_as_binary(self):
5929  r"""_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
5930  return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)
5931 
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)
5935 
5936  def __getstate__(self):
5937  p = self._get_as_binary()
5938  if len(self.__dict__) > 1:
5939  d = self.__dict__.copy()
5940  del d['this']
5941  p = (d, p)
5942  return p
5943 
5944  def __setstate__(self, p):
5945  if not hasattr(self, 'this'):
5946  self.__init__()
5947  if isinstance(p, tuple):
5948  d, p = p
5949  self.__dict__.update(d)
5950  return self._set_from_binary(p)
5951 
5952  __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
5953 
5954 # Register ConnollySurfacePoint in _IMP_algebra:
5955 _IMP_algebra.ConnollySurfacePoint_swigregister(ConnollySurfacePoint)
5956 
5957 def get_connolly_surface(spheres, density, probe_radius):
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."""
5962 
5963  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5964 
5965  def __init__(self, *args):
5966  r"""
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
5971  """
5972  _IMP_algebra.LogEmbedding3D_swiginit(self, _IMP_algebra.new_LogEmbedding3D(*args))
5973 
5974  def set_origin(self, o):
5975  r"""set_origin(LogEmbedding3D self, Vector3D o)"""
5976  return _IMP_algebra.LogEmbedding3D_set_origin(self, o)
5977 
5978  def get_origin(self):
5979  r"""get_origin(LogEmbedding3D self) -> Vector3D"""
5980  return _IMP_algebra.LogEmbedding3D_get_origin(self)
5981 
5982  def get_dimension(self):
5983  r"""get_dimension(LogEmbedding3D self) -> unsigned int"""
5984  return _IMP_algebra.LogEmbedding3D_get_dimension(self)
5985 
5986  def set_unit_cell(self, *args):
5987  r"""
5988  set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
5989  set_unit_cell(LogEmbedding3D self, Vector3D o)
5990  """
5991  return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)
5992 
5993  def get_unit_cell(self):
5994  r"""get_unit_cell(LogEmbedding3D self) -> Vector3D"""
5995  return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)
5996 
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)
6000 
6001  def get_index(self, o):
6002  r"""get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
6003  return _IMP_algebra.LogEmbedding3D_get_index(self, o)
6004 
6005  def get_center(self, *args):
6006  r"""
6007  get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
6008  get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
6009  """
6010  return _IMP_algebra.LogEmbedding3D_get_center(self, *args)
6011 
6012  def get_bounding_box(self, *args):
6013  r"""
6014  get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
6015  get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
6016  """
6017  return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)
6018 
6019  def show(self, *args):
6020  r"""show(LogEmbedding3D self, _ostream out=std::cout)"""
6021  return _IMP_algebra.LogEmbedding3D_show(self, *args)
6022 
6023  def __str__(self):
6024  r"""__str__(LogEmbedding3D self) -> std::string"""
6025  return _IMP_algebra.LogEmbedding3D___str__(self)
6026 
6027  def __repr__(self):
6028  r"""__repr__(LogEmbedding3D self) -> std::string"""
6029  return _IMP_algebra.LogEmbedding3D___repr__(self)
6030 
6031  def __cmp__(self, arg2):
6032  r"""__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
6033  return _IMP_algebra.LogEmbedding3D___cmp__(self, arg2)
6034 
6035  def __eq__(self, arg2):
6036  r"""__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
6037  return _IMP_algebra.LogEmbedding3D___eq__(self, arg2)
6038 
6039  def _get_as_binary(self):
6040  r"""_get_as_binary(LogEmbedding3D self) -> PyObject *"""
6041  return _IMP_algebra.LogEmbedding3D__get_as_binary(self)
6042 
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)
6046 
6047  def __getstate__(self):
6048  p = self._get_as_binary()
6049  if len(self.__dict__) > 1:
6050  d = self.__dict__.copy()
6051  del d['this']
6052  p = (d, p)
6053  return p
6054 
6055  def __setstate__(self, p):
6056  if not hasattr(self, 'this'):
6057  self.__init__()
6058  if isinstance(p, tuple):
6059  d, p = p
6060  self.__dict__.update(d)
6061  return self._set_from_binary(p)
6062 
6063  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
6064 
6065 # Register LogEmbedding3D in _IMP_algebra:
6066 _IMP_algebra.LogEmbedding3D_swigregister(LogEmbedding3D)
6067 class LogEmbeddingKD(object):
6068  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< -1 > class."""
6069 
6070  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6071 
6072  def __init__(self, *args):
6073  r"""
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
6078  """
6079  _IMP_algebra.LogEmbeddingKD_swiginit(self, _IMP_algebra.new_LogEmbeddingKD(*args))
6080 
6081  def set_origin(self, o):
6082  r"""set_origin(LogEmbeddingKD self, VectorKD o)"""
6083  return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)
6084 
6085  def get_origin(self):
6086  r"""get_origin(LogEmbeddingKD self) -> VectorKD"""
6087  return _IMP_algebra.LogEmbeddingKD_get_origin(self)
6088 
6089  def get_dimension(self):
6090  r"""get_dimension(LogEmbeddingKD self) -> unsigned int"""
6091  return _IMP_algebra.LogEmbeddingKD_get_dimension(self)
6092 
6093  def set_unit_cell(self, *args):
6094  r"""
6095  set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
6096  set_unit_cell(LogEmbeddingKD self, VectorKD o)
6097  """
6098  return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)
6099 
6100  def get_unit_cell(self):
6101  r"""get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
6102  return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)
6103 
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)
6107 
6108  def get_index(self, o):
6109  r"""get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
6110  return _IMP_algebra.LogEmbeddingKD_get_index(self, o)
6111 
6112  def get_center(self, *args):
6113  r"""
6114  get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
6115  get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
6116  """
6117  return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)
6118 
6119  def get_bounding_box(self, *args):
6120  r"""
6121  get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
6122  get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
6123  """
6124  return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)
6125 
6126  def show(self, *args):
6127  r"""show(LogEmbeddingKD self, _ostream out=std::cout)"""
6128  return _IMP_algebra.LogEmbeddingKD_show(self, *args)
6129 
6130  def __str__(self):
6131  r"""__str__(LogEmbeddingKD self) -> std::string"""
6132  return _IMP_algebra.LogEmbeddingKD___str__(self)
6133 
6134  def __repr__(self):
6135  r"""__repr__(LogEmbeddingKD self) -> std::string"""
6136  return _IMP_algebra.LogEmbeddingKD___repr__(self)
6137 
6138  def __cmp__(self, arg2):
6139  r"""__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
6140  return _IMP_algebra.LogEmbeddingKD___cmp__(self, arg2)
6141 
6142  def __eq__(self, arg2):
6143  r"""__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
6144  return _IMP_algebra.LogEmbeddingKD___eq__(self, arg2)
6145 
6146  def _get_as_binary(self):
6147  r"""_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
6148  return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)
6149 
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)
6153 
6154  def __getstate__(self):
6155  p = self._get_as_binary()
6156  if len(self.__dict__) > 1:
6157  d = self.__dict__.copy()
6158  del d['this']
6159  p = (d, p)
6160  return p
6161 
6162  def __setstate__(self, p):
6163  if not hasattr(self, 'this'):
6164  self.__init__()
6165  if isinstance(p, tuple):
6166  d, p = p
6167  self.__dict__.update(d)
6168  return self._set_from_binary(p)
6169 
6170  __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
6171 
6172 # Register LogEmbeddingKD in _IMP_algebra:
6173 _IMP_algebra.LogEmbeddingKD_swigregister(LogEmbeddingKD)
6174 class DenseFloatLogGridKD(object):
6175  r"""Proxy of C++ IMP::algebra::DenseFloatLogGridKD class."""
6176 
6177  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6178 
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))
6182 
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)
6186 
6187  def __getitem__(self, *args):
6188  r"""
6189  __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
6190  __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
6191  """
6192  return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)
6193 
6194  def __setitem__(self, *args):
6195  r"""
6196  __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
6197  __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
6198  """
6199  return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)
6200 
6201  def get_bounding_box(self, *args):
6202  r"""
6203  get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6204  get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
6205  """
6206  return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)
6207 
6208  def get_indexes(self, *args):
6209  r"""
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 > >
6212  """
6213  return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)
6214 
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)
6218 
6219  def get_extended_indexes(self, *args):
6220  r"""
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 > >
6223  """
6224  return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)
6225 
6226  def get_center(self, *args):
6227  r"""
6228  get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6229  get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
6230  """
6231  return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)
6232 
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)
6236 
6237  def get_index(self, v):
6238  r"""get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6239  return _IMP_algebra.DenseFloatLogGridKD_get_index(self, v)
6240 
6241  def get_origin(self):
6242  r"""get_origin(DenseFloatLogGridKD self) -> VectorKD"""
6243  return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)
6244 
6245  def get_dimension(self):
6246  r"""get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
6247  return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)
6248 
6249  def get_unit_cell(self):
6250  r"""get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
6251  return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)
6252 
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)
6256 
6257  def __str__(self):
6258  r"""__str__(DenseFloatLogGridKD self) -> std::string"""
6259  return _IMP_algebra.DenseFloatLogGridKD___str__(self)
6260 
6261  def __repr__(self):
6262  r"""__repr__(DenseFloatLogGridKD self) -> std::string"""
6263  return _IMP_algebra.DenseFloatLogGridKD___repr__(self)
6264 
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
6269 
6270 # Register DenseFloatLogGridKD in _IMP_algebra:
6271 _IMP_algebra.DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
6272 class DenseIntLogGrid3D(object):
6273  r"""Proxy of C++ IMP::algebra::DenseIntLogGrid3D class."""
6274 
6275  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6276 
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))
6280 
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)
6284 
6285  def __getitem__(self, *args):
6286  r"""
6287  __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
6288  __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
6289  """
6290  return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)
6291 
6292  def __setitem__(self, *args):
6293  r"""
6294  __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
6295  __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
6296  """
6297  return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)
6298 
6299  def get_bounding_box(self, *args):
6300  r"""
6301  get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6302  get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
6303  """
6304  return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)
6305 
6306  def get_indexes(self, *args):
6307  r"""
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 > >
6310  """
6311  return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)
6312 
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)
6316 
6317  def get_extended_indexes(self, *args):
6318  r"""
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 > >
6321  """
6322  return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)
6323 
6324  def get_center(self, *args):
6325  r"""
6326  get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6327  get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
6328  """
6329  return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)
6330 
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)
6334 
6335  def get_index(self, v):
6336  r"""get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6337  return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)
6338 
6339  def get_origin(self):
6340  r"""get_origin(DenseIntLogGrid3D self) -> Vector3D"""
6341  return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)
6342 
6343  def get_dimension(self):
6344  r"""get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
6345  return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)
6346 
6347  def get_unit_cell(self):
6348  r"""get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
6349  return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)
6350 
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)
6354 
6355  def __str__(self):
6356  r"""__str__(DenseIntLogGrid3D self) -> std::string"""
6357  return _IMP_algebra.DenseIntLogGrid3D___str__(self)
6358 
6359  def __repr__(self):
6360  r"""__repr__(DenseIntLogGrid3D self) -> std::string"""
6361  return _IMP_algebra.DenseIntLogGrid3D___repr__(self)
6362 
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
6367 
6368 # Register DenseIntLogGrid3D in _IMP_algebra:
6369 _IMP_algebra.DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
6370 class DenseDoubleGrid3D(object):
6371  r"""Proxy of C++ IMP::algebra::DenseGrid3D< double > class."""
6372 
6373  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6374 
6375  def __init__(self, *args):
6376  r"""
6377  __init__(DenseDoubleGrid3D self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
6378  __init__(DenseDoubleGrid3D self) -> DenseDoubleGrid3D
6379  """
6380  _IMP_algebra.DenseDoubleGrid3D_swiginit(self, _IMP_algebra.new_DenseDoubleGrid3D(*args))
6381 
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)
6385 
6386  def __getitem__(self, *args):
6387  r"""
6388  __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
6389  __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
6390  """
6391  return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)
6392 
6393  def __setitem__(self, *args):
6394  r"""
6395  __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
6396  __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
6397  """
6398  return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)
6399 
6400  def get_bounding_box(self, *args):
6401  r"""
6402  get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6403  get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
6404  """
6405  return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)
6406 
6407  def get_indexes(self, *args):
6408  r"""
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 > >
6411  """
6412  return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)
6413 
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)
6417 
6418  def get_extended_indexes(self, *args):
6419  r"""
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 > >
6422  """
6423  return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)
6424 
6425  def get_center(self, *args):
6426  r"""
6427  get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6428  get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
6429  """
6430  return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)
6431 
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)
6435 
6436  def get_index(self, v):
6437  r"""get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6438  return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)
6439 
6440  def get_origin(self):
6441  r"""get_origin(DenseDoubleGrid3D self) -> Vector3D"""
6442  return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)
6443 
6444  def get_dimension(self):
6445  r"""get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
6446  return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)
6447 
6448  def get_unit_cell(self):
6449  r"""get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
6450  return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)
6451 
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)
6455 
6456  def __str__(self):
6457  r"""__str__(DenseDoubleGrid3D self) -> std::string"""
6458  return _IMP_algebra.DenseDoubleGrid3D___str__(self)
6459 
6460  def __repr__(self):
6461  r"""__repr__(DenseDoubleGrid3D self) -> std::string"""
6462  return _IMP_algebra.DenseDoubleGrid3D___repr__(self)
6463 
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
6468 
6469 # Register DenseDoubleGrid3D in _IMP_algebra:
6470 _IMP_algebra.DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
6471 class DenseFloatGrid3D(object):
6472  r"""Proxy of C++ IMP::algebra::DenseGrid3D< float > class."""
6473 
6474  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6475 
6476  def __init__(self, *args):
6477  r"""
6478  __init__(DenseFloatGrid3D self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
6479  __init__(DenseFloatGrid3D self) -> DenseFloatGrid3D
6480  """
6481  _IMP_algebra.DenseFloatGrid3D_swiginit(self, _IMP_algebra.new_DenseFloatGrid3D(*args))
6482 
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)
6486 
6487  def __getitem__(self, *args):
6488  r"""
6489  __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
6490  __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
6491  """
6492  return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)
6493 
6494  def __setitem__(self, *args):
6495  r"""
6496  __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
6497  __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
6498  """
6499  return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)
6500 
6501  def get_bounding_box(self, *args):
6502  r"""
6503  get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6504  get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
6505  """
6506  return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)
6507 
6508  def get_indexes(self, *args):
6509  r"""
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 > >
6512  """
6513  return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)
6514 
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)
6518 
6519  def get_extended_indexes(self, *args):
6520  r"""
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 > >
6523  """
6524  return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)
6525 
6526  def get_center(self, *args):
6527  r"""
6528  get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6529  get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
6530  """
6531  return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)
6532 
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)
6536 
6537  def get_index(self, v):
6538  r"""get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6539  return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)
6540 
6541  def get_origin(self):
6542  r"""get_origin(DenseFloatGrid3D self) -> Vector3D"""
6543  return _IMP_algebra.DenseFloatGrid3D_get_origin(self)
6544 
6545  def get_dimension(self):
6546  r"""get_dimension(DenseFloatGrid3D self) -> unsigned int"""
6547  return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)
6548 
6549  def get_unit_cell(self):
6550  r"""get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
6551  return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)
6552 
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)
6556 
6557  def __str__(self):
6558  r"""__str__(DenseFloatGrid3D self) -> std::string"""
6559  return _IMP_algebra.DenseFloatGrid3D___str__(self)
6560 
6561  def __repr__(self):
6562  r"""__repr__(DenseFloatGrid3D self) -> std::string"""
6563  return _IMP_algebra.DenseFloatGrid3D___repr__(self)
6564 
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
6569 
6570 # Register DenseFloatGrid3D in _IMP_algebra:
6571 _IMP_algebra.DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
6572 class SparseUnboundedIntGrid3D(object):
6573  r"""Proxy of C++ IMP::algebra::SparseUnboundedGrid3D< int > class."""
6574 
6575  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6576 
6577  def __init__(self, *args):
6578  r"""
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
6582  """
6583  _IMP_algebra.SparseUnboundedIntGrid3D_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGrid3D(*args))
6584 
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)
6588 
6589  def __getitem__(self, *args):
6590  r"""
6591  __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
6592  __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
6593  """
6594  return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)
6595 
6596  def __setitem__(self, *args):
6597  r"""
6598  __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
6599  __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
6600  """
6601  return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)
6602 
6603  def get_bounding_box(self, *args):
6604  r"""
6605  get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6606  get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
6607  """
6608  return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)
6609 
6610  def get_indexes(self, *args):
6611  r"""
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 > >
6614  """
6615  return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)
6616 
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)
6620 
6621  def get_extended_indexes(self, *args):
6622  r"""
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 > >
6625  """
6626  return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)
6627 
6628  def get_center(self, *args):
6629  r"""
6630  get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6631  get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
6632  """
6633  return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)
6634 
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)
6638 
6639  def get_index(self, v):
6640  r"""get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6641  return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)
6642 
6643  def get_origin(self):
6644  r"""get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
6645  return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)
6646 
6647  def get_dimension(self):
6648  r"""get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
6649  return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)
6650 
6651  def get_unit_cell(self):
6652  r"""get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
6653  return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)
6654 
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)
6658 
6659  def __str__(self):
6660  r"""__str__(SparseUnboundedIntGrid3D self) -> std::string"""
6661  return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)
6662 
6663  def __repr__(self):
6664  r"""__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
6665  return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)
6666 
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
6671 
6672 # Register SparseUnboundedIntGrid3D in _IMP_algebra:
6673 _IMP_algebra.SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
6674 class SparseUnboundedIntGridKD(object):
6675  r"""Proxy of C++ IMP::algebra::SparseUnboundedGridD< -1,int > class."""
6676 
6677  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6678 
6679  def __init__(self, *args):
6680  r"""
6681  __init__(SparseUnboundedIntGridKD self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
6682  __init__(SparseUnboundedIntGridKD self) -> SparseUnboundedIntGridKD
6683  """
6684  _IMP_algebra.SparseUnboundedIntGridKD_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGridKD(*args))
6685 
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)
6689 
6690  def __getitem__(self, *args):
6691  r"""
6692  __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
6693  __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
6694  """
6695  return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)
6696 
6697  def __setitem__(self, *args):
6698  r"""
6699  __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
6700  __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
6701  """
6702  return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)
6703 
6704  def get_bounding_box(self, *args):
6705  r"""
6706  get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6707  get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
6708  """
6709  return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)
6710 
6711  def get_indexes(self, *args):
6712  r"""
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 > >
6715  """
6716  return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)
6717 
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)
6721 
6722  def get_extended_indexes(self, *args):
6723  r"""
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 > >
6726  """
6727  return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)
6728 
6729  def get_center(self, *args):
6730  r"""
6731  get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6732  get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
6733  """
6734  return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)
6735 
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)
6739 
6740  def get_index(self, v):
6741  r"""get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6742  return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)
6743 
6744  def get_origin(self):
6745  r"""get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
6746  return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)
6747 
6748  def get_dimension(self):
6749  r"""get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
6750  return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)
6751 
6752  def get_unit_cell(self):
6753  r"""get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
6754  return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)
6755 
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)
6759 
6760  def __str__(self):
6761  r"""__str__(SparseUnboundedIntGridKD self) -> std::string"""
6762  return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)
6763 
6764  def __repr__(self):
6765  r"""__repr__(SparseUnboundedIntGridKD self) -> std::string"""
6766  return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)
6767 
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
6772 
6773 # Register SparseUnboundedIntGridKD in _IMP_algebra:
6774 _IMP_algebra.SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
6775 class GridIndex1D(IMP._Value):
6776  r"""Proxy of C++ IMP::algebra::GridIndexD< 1 > class."""
6777 
6778  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6779 
6780  def __init__(self, *args):
6781  r"""
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
6789  """
6790  _IMP_algebra.GridIndex1D_swiginit(self, _IMP_algebra.new_GridIndex1D(*args))
6791 
6792  def get_dimension(self):
6793  r"""get_dimension(GridIndex1D self) -> unsigned int"""
6794  return _IMP_algebra.GridIndex1D_get_dimension(self)
6795 
6796  def __getitem__(self, i):
6797  r"""__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
6798  return _IMP_algebra.GridIndex1D___getitem__(self, i)
6799 
6800  def show(self, *args):
6801  r"""show(GridIndex1D self, _ostream out=std::cout)"""
6802  return _IMP_algebra.GridIndex1D_show(self, *args)
6803 
6804  def __len__(self):
6805  r"""__len__(GridIndex1D self) -> unsigned int"""
6806  return _IMP_algebra.GridIndex1D___len__(self)
6807 
6808  def __cmp__(self, o):
6809  r"""__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
6810  return _IMP_algebra.GridIndex1D___cmp__(self, o)
6811 
6812  def __eq__(self, o):
6813  r"""__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
6814  return _IMP_algebra.GridIndex1D___eq__(self, o)
6815 
6816  def __ne__(self, o):
6817  r"""__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
6818  return _IMP_algebra.GridIndex1D___ne__(self, o)
6819 
6820  def __lt__(self, o):
6821  r"""__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
6822  return _IMP_algebra.GridIndex1D___lt__(self, o)
6823 
6824  def __gt__(self, o):
6825  r"""__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
6826  return _IMP_algebra.GridIndex1D___gt__(self, o)
6827 
6828  def __ge__(self, o):
6829  r"""__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
6830  return _IMP_algebra.GridIndex1D___ge__(self, o)
6831 
6832  def __le__(self, o):
6833  r"""__le__(GridIndex1D self, GridIndex1D o) -> bool"""
6834  return _IMP_algebra.GridIndex1D___le__(self, o)
6835 
6836  def __hash__(self):
6837  r"""__hash__(GridIndex1D self) -> std::size_t"""
6838  return _IMP_algebra.GridIndex1D___hash__(self)
6839 
6840  def __str__(self):
6841  r"""__str__(GridIndex1D self) -> std::string"""
6842  return _IMP_algebra.GridIndex1D___str__(self)
6843 
6844  def __repr__(self):
6845  r"""__repr__(GridIndex1D self) -> std::string"""
6846  return _IMP_algebra.GridIndex1D___repr__(self)
6847 
6848  def _get_as_binary(self):
6849  r"""_get_as_binary(GridIndex1D self) -> PyObject *"""
6850  return _IMP_algebra.GridIndex1D__get_as_binary(self)
6851 
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)
6855 
6856  def __getstate__(self):
6857  p = self._get_as_binary()
6858  if len(self.__dict__) > 1:
6859  d = self.__dict__.copy()
6860  del d['this']
6861  p = (d, p)
6862  return p
6863 
6864  def __setstate__(self, p):
6865  if not hasattr(self, 'this'):
6866  self.__init__()
6867  if isinstance(p, tuple):
6868  d, p = p
6869  self.__dict__.update(d)
6870  return self._set_from_binary(p)
6871 
6872  __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
6873 
6874 # Register GridIndex1D in _IMP_algebra:
6875 _IMP_algebra.GridIndex1D_swigregister(GridIndex1D)
6876 class GridIndex2D(IMP._Value):
6877  r"""Proxy of C++ IMP::algebra::GridIndexD< 2 > class."""
6878 
6879  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6880 
6881  def __init__(self, *args):
6882  r"""
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
6890  """
6891  _IMP_algebra.GridIndex2D_swiginit(self, _IMP_algebra.new_GridIndex2D(*args))
6892 
6893  def get_dimension(self):
6894  r"""get_dimension(GridIndex2D self) -> unsigned int"""
6895  return _IMP_algebra.GridIndex2D_get_dimension(self)
6896 
6897  def __getitem__(self, i):
6898  r"""__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
6899  return _IMP_algebra.GridIndex2D___getitem__(self, i)
6900 
6901  def show(self, *args):
6902  r"""show(GridIndex2D self, _ostream out=std::cout)"""
6903  return _IMP_algebra.GridIndex2D_show(self, *args)
6904 
6905  def __len__(self):
6906  r"""__len__(GridIndex2D self) -> unsigned int"""
6907  return _IMP_algebra.GridIndex2D___len__(self)
6908 
6909  def __cmp__(self, o):
6910  r"""__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
6911  return _IMP_algebra.GridIndex2D___cmp__(self, o)
6912 
6913  def __eq__(self, o):
6914  r"""__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
6915  return _IMP_algebra.GridIndex2D___eq__(self, o)
6916 
6917  def __ne__(self, o):
6918  r"""__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
6919  return _IMP_algebra.GridIndex2D___ne__(self, o)
6920 
6921  def __lt__(self, o):
6922  r"""__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
6923  return _IMP_algebra.GridIndex2D___lt__(self, o)
6924 
6925  def __gt__(self, o):
6926  r"""__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
6927  return _IMP_algebra.GridIndex2D___gt__(self, o)
6928 
6929  def __ge__(self, o):
6930  r"""__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
6931  return _IMP_algebra.GridIndex2D___ge__(self, o)
6932 
6933  def __le__(self, o):
6934  r"""__le__(GridIndex2D self, GridIndex2D o) -> bool"""
6935  return _IMP_algebra.GridIndex2D___le__(self, o)
6936 
6937  def __hash__(self):
6938  r"""__hash__(GridIndex2D self) -> std::size_t"""
6939  return _IMP_algebra.GridIndex2D___hash__(self)
6940 
6941  def __str__(self):
6942  r"""__str__(GridIndex2D self) -> std::string"""
6943  return _IMP_algebra.GridIndex2D___str__(self)
6944 
6945  def __repr__(self):
6946  r"""__repr__(GridIndex2D self) -> std::string"""
6947  return _IMP_algebra.GridIndex2D___repr__(self)
6948 
6949  def _get_as_binary(self):
6950  r"""_get_as_binary(GridIndex2D self) -> PyObject *"""
6951  return _IMP_algebra.GridIndex2D__get_as_binary(self)
6952 
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)
6956 
6957  def __getstate__(self):
6958  p = self._get_as_binary()
6959  if len(self.__dict__) > 1:
6960  d = self.__dict__.copy()
6961  del d['this']
6962  p = (d, p)
6963  return p
6964 
6965  def __setstate__(self, p):
6966  if not hasattr(self, 'this'):
6967  self.__init__()
6968  if isinstance(p, tuple):
6969  d, p = p
6970  self.__dict__.update(d)
6971  return self._set_from_binary(p)
6972 
6973  __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
6974 
6975 # Register GridIndex2D in _IMP_algebra:
6976 _IMP_algebra.GridIndex2D_swigregister(GridIndex2D)
6977 class GridIndex3D(IMP._Value):
6978  r"""Proxy of C++ IMP::algebra::GridIndexD< 3 > class."""
6979 
6980  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6981 
6982  def __init__(self, *args):
6983  r"""
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
6991  """
6992  _IMP_algebra.GridIndex3D_swiginit(self, _IMP_algebra.new_GridIndex3D(*args))
6993 
6994  def get_dimension(self):
6995  r"""get_dimension(GridIndex3D self) -> unsigned int"""
6996  return _IMP_algebra.GridIndex3D_get_dimension(self)
6997 
6998  def __getitem__(self, i):
6999  r"""__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
7000  return _IMP_algebra.GridIndex3D___getitem__(self, i)
7001 
7002  def show(self, *args):
7003  r"""show(GridIndex3D self, _ostream out=std::cout)"""
7004  return _IMP_algebra.GridIndex3D_show(self, *args)
7005 
7006  def __len__(self):
7007  r"""__len__(GridIndex3D self) -> unsigned int"""
7008  return _IMP_algebra.GridIndex3D___len__(self)
7009 
7010  def __cmp__(self, o):
7011  r"""__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
7012  return _IMP_algebra.GridIndex3D___cmp__(self, o)
7013 
7014  def __eq__(self, o):
7015  r"""__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
7016  return _IMP_algebra.GridIndex3D___eq__(self, o)
7017 
7018  def __ne__(self, o):
7019  r"""__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
7020  return _IMP_algebra.GridIndex3D___ne__(self, o)
7021 
7022  def __lt__(self, o):
7023  r"""__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
7024  return _IMP_algebra.GridIndex3D___lt__(self, o)
7025 
7026  def __gt__(self, o):
7027  r"""__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
7028  return _IMP_algebra.GridIndex3D___gt__(self, o)
7029 
7030  def __ge__(self, o):
7031  r"""__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
7032  return _IMP_algebra.GridIndex3D___ge__(self, o)
7033 
7034  def __le__(self, o):
7035  r"""__le__(GridIndex3D self, GridIndex3D o) -> bool"""
7036  return _IMP_algebra.GridIndex3D___le__(self, o)
7037 
7038  def __hash__(self):
7039  r"""__hash__(GridIndex3D self) -> std::size_t"""
7040  return _IMP_algebra.GridIndex3D___hash__(self)
7041 
7042  def __str__(self):
7043  r"""__str__(GridIndex3D self) -> std::string"""
7044  return _IMP_algebra.GridIndex3D___str__(self)
7045 
7046  def __repr__(self):
7047  r"""__repr__(GridIndex3D self) -> std::string"""
7048  return _IMP_algebra.GridIndex3D___repr__(self)
7049 
7050  def _get_as_binary(self):
7051  r"""_get_as_binary(GridIndex3D self) -> PyObject *"""
7052  return _IMP_algebra.GridIndex3D__get_as_binary(self)
7053 
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)
7057 
7058  def __getstate__(self):
7059  p = self._get_as_binary()
7060  if len(self.__dict__) > 1:
7061  d = self.__dict__.copy()
7062  del d['this']
7063  p = (d, p)
7064  return p
7065 
7066  def __setstate__(self, p):
7067  if not hasattr(self, 'this'):
7068  self.__init__()
7069  if isinstance(p, tuple):
7070  d, p = p
7071  self.__dict__.update(d)
7072  return self._set_from_binary(p)
7073 
7074  __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
7075 
7076 # Register GridIndex3D in _IMP_algebra:
7077 _IMP_algebra.GridIndex3D_swigregister(GridIndex3D)
7078 class GridIndex4D(IMP._Value):
7079  r"""Proxy of C++ IMP::algebra::GridIndexD< 4 > class."""
7080 
7081  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7082 
7083  def __init__(self, *args):
7084  r"""
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
7092  """
7093  _IMP_algebra.GridIndex4D_swiginit(self, _IMP_algebra.new_GridIndex4D(*args))
7094 
7095  def get_dimension(self):
7096  r"""get_dimension(GridIndex4D self) -> unsigned int"""
7097  return _IMP_algebra.GridIndex4D_get_dimension(self)
7098 
7099  def __getitem__(self, i):
7100  r"""__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
7101  return _IMP_algebra.GridIndex4D___getitem__(self, i)
7102 
7103  def show(self, *args):
7104  r"""show(GridIndex4D self, _ostream out=std::cout)"""
7105  return _IMP_algebra.GridIndex4D_show(self, *args)
7106 
7107  def __len__(self):
7108  r"""__len__(GridIndex4D self) -> unsigned int"""
7109  return _IMP_algebra.GridIndex4D___len__(self)
7110 
7111  def __cmp__(self, o):
7112  r"""__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
7113  return _IMP_algebra.GridIndex4D___cmp__(self, o)
7114 
7115  def __eq__(self, o):
7116  r"""__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
7117  return _IMP_algebra.GridIndex4D___eq__(self, o)
7118 
7119  def __ne__(self, o):
7120  r"""__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
7121  return _IMP_algebra.GridIndex4D___ne__(self, o)
7122 
7123  def __lt__(self, o):
7124  r"""__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
7125  return _IMP_algebra.GridIndex4D___lt__(self, o)
7126 
7127  def __gt__(self, o):
7128  r"""__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
7129  return _IMP_algebra.GridIndex4D___gt__(self, o)
7130 
7131  def __ge__(self, o):
7132  r"""__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
7133  return _IMP_algebra.GridIndex4D___ge__(self, o)
7134 
7135  def __le__(self, o):
7136  r"""__le__(GridIndex4D self, GridIndex4D o) -> bool"""
7137  return _IMP_algebra.GridIndex4D___le__(self, o)
7138 
7139  def __hash__(self):
7140  r"""__hash__(GridIndex4D self) -> std::size_t"""
7141  return _IMP_algebra.GridIndex4D___hash__(self)
7142 
7143  def __str__(self):
7144  r"""__str__(GridIndex4D self) -> std::string"""
7145  return _IMP_algebra.GridIndex4D___str__(self)
7146 
7147  def __repr__(self):
7148  r"""__repr__(GridIndex4D self) -> std::string"""
7149  return _IMP_algebra.GridIndex4D___repr__(self)
7150 
7151  def _get_as_binary(self):
7152  r"""_get_as_binary(GridIndex4D self) -> PyObject *"""
7153  return _IMP_algebra.GridIndex4D__get_as_binary(self)
7154 
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)
7158 
7159  def __getstate__(self):
7160  p = self._get_as_binary()
7161  if len(self.__dict__) > 1:
7162  d = self.__dict__.copy()
7163  del d['this']
7164  p = (d, p)
7165  return p
7166 
7167  def __setstate__(self, p):
7168  if not hasattr(self, 'this'):
7169  self.__init__()
7170  if isinstance(p, tuple):
7171  d, p = p
7172  self.__dict__.update(d)
7173  return self._set_from_binary(p)
7174 
7175  __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
7176 
7177 # Register GridIndex4D in _IMP_algebra:
7178 _IMP_algebra.GridIndex4D_swigregister(GridIndex4D)
7179 class GridIndex5D(IMP._Value):
7180  r"""Proxy of C++ IMP::algebra::GridIndexD< 5 > class."""
7181 
7182  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7183 
7184  def __init__(self, *args):
7185  r"""
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
7193  """
7194  _IMP_algebra.GridIndex5D_swiginit(self, _IMP_algebra.new_GridIndex5D(*args))
7195 
7196  def get_dimension(self):
7197  r"""get_dimension(GridIndex5D self) -> unsigned int"""
7198  return _IMP_algebra.GridIndex5D_get_dimension(self)
7199 
7200  def __getitem__(self, i):
7201  r"""__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
7202  return _IMP_algebra.GridIndex5D___getitem__(self, i)
7203 
7204  def show(self, *args):
7205  r"""show(GridIndex5D self, _ostream out=std::cout)"""
7206  return _IMP_algebra.GridIndex5D_show(self, *args)
7207 
7208  def __len__(self):
7209  r"""__len__(GridIndex5D self) -> unsigned int"""
7210  return _IMP_algebra.GridIndex5D___len__(self)
7211 
7212  def __cmp__(self, o):
7213  r"""__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
7214  return _IMP_algebra.GridIndex5D___cmp__(self, o)
7215 
7216  def __eq__(self, o):
7217  r"""__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
7218  return _IMP_algebra.GridIndex5D___eq__(self, o)
7219 
7220  def __ne__(self, o):
7221  r"""__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
7222  return _IMP_algebra.GridIndex5D___ne__(self, o)
7223 
7224  def __lt__(self, o):
7225  r"""__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
7226  return _IMP_algebra.GridIndex5D___lt__(self, o)
7227 
7228  def __gt__(self, o):
7229  r"""__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
7230  return _IMP_algebra.GridIndex5D___gt__(self, o)
7231 
7232  def __ge__(self, o):
7233  r"""__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
7234  return _IMP_algebra.GridIndex5D___ge__(self, o)
7235 
7236  def __le__(self, o):
7237  r"""__le__(GridIndex5D self, GridIndex5D o) -> bool"""
7238  return _IMP_algebra.GridIndex5D___le__(self, o)
7239 
7240  def __hash__(self):
7241  r"""__hash__(GridIndex5D self) -> std::size_t"""
7242  return _IMP_algebra.GridIndex5D___hash__(self)
7243 
7244  def __str__(self):
7245  r"""__str__(GridIndex5D self) -> std::string"""
7246  return _IMP_algebra.GridIndex5D___str__(self)
7247 
7248  def __repr__(self):
7249  r"""__repr__(GridIndex5D self) -> std::string"""
7250  return _IMP_algebra.GridIndex5D___repr__(self)
7251 
7252  def _get_as_binary(self):
7253  r"""_get_as_binary(GridIndex5D self) -> PyObject *"""
7254  return _IMP_algebra.GridIndex5D__get_as_binary(self)
7255 
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)
7259 
7260  def __getstate__(self):
7261  p = self._get_as_binary()
7262  if len(self.__dict__) > 1:
7263  d = self.__dict__.copy()
7264  del d['this']
7265  p = (d, p)
7266  return p
7267 
7268  def __setstate__(self, p):
7269  if not hasattr(self, 'this'):
7270  self.__init__()
7271  if isinstance(p, tuple):
7272  d, p = p
7273  self.__dict__.update(d)
7274  return self._set_from_binary(p)
7275 
7276  __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
7277 
7278 # Register GridIndex5D in _IMP_algebra:
7279 _IMP_algebra.GridIndex5D_swigregister(GridIndex5D)
7280 class GridIndex6D(IMP._Value):
7281  r"""Proxy of C++ IMP::algebra::GridIndexD< 6 > class."""
7282 
7283  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7284 
7285  def __init__(self, *args):
7286  r"""
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
7294  """
7295  _IMP_algebra.GridIndex6D_swiginit(self, _IMP_algebra.new_GridIndex6D(*args))
7296 
7297  def get_dimension(self):
7298  r"""get_dimension(GridIndex6D self) -> unsigned int"""
7299  return _IMP_algebra.GridIndex6D_get_dimension(self)
7300 
7301  def __getitem__(self, i):
7302  r"""__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
7303  return _IMP_algebra.GridIndex6D___getitem__(self, i)
7304 
7305  def show(self, *args):
7306  r"""show(GridIndex6D self, _ostream out=std::cout)"""
7307  return _IMP_algebra.GridIndex6D_show(self, *args)
7308 
7309  def __len__(self):
7310  r"""__len__(GridIndex6D self) -> unsigned int"""
7311  return _IMP_algebra.GridIndex6D___len__(self)
7312 
7313  def __cmp__(self, o):
7314  r"""__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
7315  return _IMP_algebra.GridIndex6D___cmp__(self, o)
7316 
7317  def __eq__(self, o):
7318  r"""__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
7319  return _IMP_algebra.GridIndex6D___eq__(self, o)
7320 
7321  def __ne__(self, o):
7322  r"""__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
7323  return _IMP_algebra.GridIndex6D___ne__(self, o)
7324 
7325  def __lt__(self, o):
7326  r"""__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
7327  return _IMP_algebra.GridIndex6D___lt__(self, o)
7328 
7329  def __gt__(self, o):
7330  r"""__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
7331  return _IMP_algebra.GridIndex6D___gt__(self, o)
7332 
7333  def __ge__(self, o):
7334  r"""__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
7335  return _IMP_algebra.GridIndex6D___ge__(self, o)
7336 
7337  def __le__(self, o):
7338  r"""__le__(GridIndex6D self, GridIndex6D o) -> bool"""
7339  return _IMP_algebra.GridIndex6D___le__(self, o)
7340 
7341  def __hash__(self):
7342  r"""__hash__(GridIndex6D self) -> std::size_t"""
7343  return _IMP_algebra.GridIndex6D___hash__(self)
7344 
7345  def __str__(self):
7346  r"""__str__(GridIndex6D self) -> std::string"""
7347  return _IMP_algebra.GridIndex6D___str__(self)
7348 
7349  def __repr__(self):
7350  r"""__repr__(GridIndex6D self) -> std::string"""
7351  return _IMP_algebra.GridIndex6D___repr__(self)
7352 
7353  def _get_as_binary(self):
7354  r"""_get_as_binary(GridIndex6D self) -> PyObject *"""
7355  return _IMP_algebra.GridIndex6D__get_as_binary(self)
7356 
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)
7360 
7361  def __getstate__(self):
7362  p = self._get_as_binary()
7363  if len(self.__dict__) > 1:
7364  d = self.__dict__.copy()
7365  del d['this']
7366  p = (d, p)
7367  return p
7368 
7369  def __setstate__(self, p):
7370  if not hasattr(self, 'this'):
7371  self.__init__()
7372  if isinstance(p, tuple):
7373  d, p = p
7374  self.__dict__.update(d)
7375  return self._set_from_binary(p)
7376 
7377  __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
7378 
7379 # Register GridIndex6D in _IMP_algebra:
7380 _IMP_algebra.GridIndex6D_swigregister(GridIndex6D)
7381 class GridIndexKD(IMP._Value):
7382  r"""Proxy of C++ IMP::algebra::GridIndexD< -1 > class."""
7383 
7384  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7385 
7386  def __init__(self, *args):
7387  r"""
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
7395  """
7396  _IMP_algebra.GridIndexKD_swiginit(self, _IMP_algebra.new_GridIndexKD(*args))
7397 
7398  def get_dimension(self):
7399  r"""get_dimension(GridIndexKD self) -> unsigned int"""
7400  return _IMP_algebra.GridIndexKD_get_dimension(self)
7401 
7402  def __getitem__(self, i):
7403  r"""__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
7404  return _IMP_algebra.GridIndexKD___getitem__(self, i)
7405 
7406  def show(self, *args):
7407  r"""show(GridIndexKD self, _ostream out=std::cout)"""
7408  return _IMP_algebra.GridIndexKD_show(self, *args)
7409 
7410  def __len__(self):
7411  r"""__len__(GridIndexKD self) -> unsigned int"""
7412  return _IMP_algebra.GridIndexKD___len__(self)
7413 
7414  def __cmp__(self, o):
7415  r"""__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
7416  return _IMP_algebra.GridIndexKD___cmp__(self, o)
7417 
7418  def __eq__(self, o):
7419  r"""__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
7420  return _IMP_algebra.GridIndexKD___eq__(self, o)
7421 
7422  def __ne__(self, o):
7423  r"""__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
7424  return _IMP_algebra.GridIndexKD___ne__(self, o)
7425 
7426  def __lt__(self, o):
7427  r"""__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
7428  return _IMP_algebra.GridIndexKD___lt__(self, o)
7429 
7430  def __gt__(self, o):
7431  r"""__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
7432  return _IMP_algebra.GridIndexKD___gt__(self, o)
7433 
7434  def __ge__(self, o):
7435  r"""__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
7436  return _IMP_algebra.GridIndexKD___ge__(self, o)
7437 
7438  def __le__(self, o):
7439  r"""__le__(GridIndexKD self, GridIndexKD o) -> bool"""
7440  return _IMP_algebra.GridIndexKD___le__(self, o)
7441 
7442  def __hash__(self):
7443  r"""__hash__(GridIndexKD self) -> std::size_t"""
7444  return _IMP_algebra.GridIndexKD___hash__(self)
7445 
7446  def __str__(self):
7447  r"""__str__(GridIndexKD self) -> std::string"""
7448  return _IMP_algebra.GridIndexKD___str__(self)
7449 
7450  def __repr__(self):
7451  r"""__repr__(GridIndexKD self) -> std::string"""
7452  return _IMP_algebra.GridIndexKD___repr__(self)
7453 
7454  def _get_as_binary(self):
7455  r"""_get_as_binary(GridIndexKD self) -> PyObject *"""
7456  return _IMP_algebra.GridIndexKD__get_as_binary(self)
7457 
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)
7461 
7462  def __getstate__(self):
7463  p = self._get_as_binary()
7464  if len(self.__dict__) > 1:
7465  d = self.__dict__.copy()
7466  del d['this']
7467  p = (d, p)
7468  return p
7469 
7470  def __setstate__(self, p):
7471  if not hasattr(self, 'this'):
7472  self.__init__()
7473  if isinstance(p, tuple):
7474  d, p = p
7475  self.__dict__.update(d)
7476  return self._set_from_binary(p)
7477 
7478  __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
7479 
7480 # Register GridIndexKD in _IMP_algebra:
7481 _IMP_algebra.GridIndexKD_swigregister(GridIndexKD)
7482 class ExtendedGridIndex1D(IMP._Value):
7483  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 1 > class."""
7484 
7485  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7486 
7487  def __init__(self, *args):
7488  r"""
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
7497  """
7498  _IMP_algebra.ExtendedGridIndex1D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex1D(*args))
7499 
7500  def get_dimension(self):
7501  r"""get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
7502  return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)
7503 
7504  def __cmp__(self, o):
7505  r"""__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
7506  return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, o)
7507 
7508  def __eq__(self, o):
7509  r"""__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7510  return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)
7511 
7512  def __ne__(self, o):
7513  r"""__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7514  return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)
7515 
7516  def __lt__(self, o):
7517  r"""__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7518  return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)
7519 
7520  def __gt__(self, o):
7521  r"""__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7522  return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)
7523 
7524  def __ge__(self, o):
7525  r"""__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7526  return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)
7527 
7528  def __le__(self, o):
7529  r"""__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7530  return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)
7531 
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)
7535 
7536  def __getitem__(self, i):
7537  r"""__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
7538  return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)
7539 
7540  def show(self, *args):
7541  r"""show(ExtendedGridIndex1D self, _ostream out=std::cout)"""
7542  return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)
7543 
7544  def __len__(self):
7545  r"""__len__(ExtendedGridIndex1D self) -> unsigned int"""
7546  return _IMP_algebra.ExtendedGridIndex1D___len__(self)
7547 
7548  def __hash__(self):
7549  r"""__hash__(ExtendedGridIndex1D self) -> std::size_t"""
7550  return _IMP_algebra.ExtendedGridIndex1D___hash__(self)
7551 
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)
7555 
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)
7559 
7560  def __str__(self):
7561  r"""__str__(ExtendedGridIndex1D self) -> std::string"""
7562  return _IMP_algebra.ExtendedGridIndex1D___str__(self)
7563 
7564  def __repr__(self):
7565  r"""__repr__(ExtendedGridIndex1D self) -> std::string"""
7566  return _IMP_algebra.ExtendedGridIndex1D___repr__(self)
7567 
7568  def _get_as_binary(self):
7569  r"""_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
7570  return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)
7571 
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)
7575 
7576  def __getstate__(self):
7577  p = self._get_as_binary()
7578  if len(self.__dict__) > 1:
7579  d = self.__dict__.copy()
7580  del d['this']
7581  p = (d, p)
7582  return p
7583 
7584  def __setstate__(self, p):
7585  if not hasattr(self, 'this'):
7586  self.__init__()
7587  if isinstance(p, tuple):
7588  d, p = p
7589  self.__dict__.update(d)
7590  return self._set_from_binary(p)
7591 
7592  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
7593 
7594 # Register ExtendedGridIndex1D in _IMP_algebra:
7595 _IMP_algebra.ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
7596 class ExtendedGridIndex2D(IMP._Value):
7597  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 2 > class."""
7598 
7599  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7600 
7601  def __init__(self, *args):
7602  r"""
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
7611  """
7612  _IMP_algebra.ExtendedGridIndex2D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex2D(*args))
7613 
7614  def get_dimension(self):
7615  r"""get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
7616  return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)
7617 
7618  def __cmp__(self, o):
7619  r"""__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
7620  return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, o)
7621 
7622  def __eq__(self, o):
7623  r"""__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7624  return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)
7625 
7626  def __ne__(self, o):
7627  r"""__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7628  return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)
7629 
7630  def __lt__(self, o):
7631  r"""__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7632  return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)
7633 
7634  def __gt__(self, o):
7635  r"""__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7636  return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)
7637 
7638  def __ge__(self, o):
7639  r"""__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7640  return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)
7641 
7642  def __le__(self, o):
7643  r"""__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7644  return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)
7645 
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)
7649 
7650  def __getitem__(self, i):
7651  r"""__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
7652  return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)
7653 
7654  def show(self, *args):
7655  r"""show(ExtendedGridIndex2D self, _ostream out=std::cout)"""
7656  return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)
7657 
7658  def __len__(self):
7659  r"""__len__(ExtendedGridIndex2D self) -> unsigned int"""
7660  return _IMP_algebra.ExtendedGridIndex2D___len__(self)
7661 
7662  def __hash__(self):
7663  r"""__hash__(ExtendedGridIndex2D self) -> std::size_t"""
7664  return _IMP_algebra.ExtendedGridIndex2D___hash__(self)
7665 
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)
7669 
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)
7673 
7674  def __str__(self):
7675  r"""__str__(ExtendedGridIndex2D self) -> std::string"""
7676  return _IMP_algebra.ExtendedGridIndex2D___str__(self)
7677 
7678  def __repr__(self):
7679  r"""__repr__(ExtendedGridIndex2D self) -> std::string"""
7680  return _IMP_algebra.ExtendedGridIndex2D___repr__(self)
7681 
7682  def _get_as_binary(self):
7683  r"""_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
7684  return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)
7685 
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)
7689 
7690  def __getstate__(self):
7691  p = self._get_as_binary()
7692  if len(self.__dict__) > 1:
7693  d = self.__dict__.copy()
7694  del d['this']
7695  p = (d, p)
7696  return p
7697 
7698  def __setstate__(self, p):
7699  if not hasattr(self, 'this'):
7700  self.__init__()
7701  if isinstance(p, tuple):
7702  d, p = p
7703  self.__dict__.update(d)
7704  return self._set_from_binary(p)
7705 
7706  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
7707 
7708 # Register ExtendedGridIndex2D in _IMP_algebra:
7709 _IMP_algebra.ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
7710 class ExtendedGridIndex3D(IMP._Value):
7711  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 3 > class."""
7712 
7713  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7714 
7715  def __init__(self, *args):
7716  r"""
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
7725  """
7726  _IMP_algebra.ExtendedGridIndex3D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex3D(*args))
7727 
7728  def get_dimension(self):
7729  r"""get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
7730  return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)
7731 
7732  def __cmp__(self, o):
7733  r"""__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
7734  return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, o)
7735 
7736  def __eq__(self, o):
7737  r"""__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7738  return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)
7739 
7740  def __ne__(self, o):
7741  r"""__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7742  return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)
7743 
7744  def __lt__(self, o):
7745  r"""__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7746  return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)
7747 
7748  def __gt__(self, o):
7749  r"""__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7750  return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)
7751 
7752  def __ge__(self, o):
7753  r"""__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7754  return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)
7755 
7756  def __le__(self, o):
7757  r"""__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7758  return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)
7759 
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)
7763 
7764  def __getitem__(self, i):
7765  r"""__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
7766  return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)
7767 
7768  def show(self, *args):
7769  r"""show(ExtendedGridIndex3D self, _ostream out=std::cout)"""
7770  return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)
7771 
7772  def __len__(self):
7773  r"""__len__(ExtendedGridIndex3D self) -> unsigned int"""
7774  return _IMP_algebra.ExtendedGridIndex3D___len__(self)
7775 
7776  def __hash__(self):
7777  r"""__hash__(ExtendedGridIndex3D self) -> std::size_t"""
7778  return _IMP_algebra.ExtendedGridIndex3D___hash__(self)
7779 
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)
7783 
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)
7787 
7788  def __str__(self):
7789  r"""__str__(ExtendedGridIndex3D self) -> std::string"""
7790  return _IMP_algebra.ExtendedGridIndex3D___str__(self)
7791 
7792  def __repr__(self):
7793  r"""__repr__(ExtendedGridIndex3D self) -> std::string"""
7794  return _IMP_algebra.ExtendedGridIndex3D___repr__(self)
7795 
7796  def _get_as_binary(self):
7797  r"""_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
7798  return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)
7799 
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)
7803 
7804  def __getstate__(self):
7805  p = self._get_as_binary()
7806  if len(self.__dict__) > 1:
7807  d = self.__dict__.copy()
7808  del d['this']
7809  p = (d, p)
7810  return p
7811 
7812  def __setstate__(self, p):
7813  if not hasattr(self, 'this'):
7814  self.__init__()
7815  if isinstance(p, tuple):
7816  d, p = p
7817  self.__dict__.update(d)
7818  return self._set_from_binary(p)
7819 
7820  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
7821 
7822 # Register ExtendedGridIndex3D in _IMP_algebra:
7823 _IMP_algebra.ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
7824 class ExtendedGridIndex4D(IMP._Value):
7825  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 4 > class."""
7826 
7827  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7828 
7829  def __init__(self, *args):
7830  r"""
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
7839  """
7840  _IMP_algebra.ExtendedGridIndex4D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex4D(*args))
7841 
7842  def get_dimension(self):
7843  r"""get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
7844  return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)
7845 
7846  def __cmp__(self, o):
7847  r"""__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
7848  return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, o)
7849 
7850  def __eq__(self, o):
7851  r"""__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7852  return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)
7853 
7854  def __ne__(self, o):
7855  r"""__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7856  return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)
7857 
7858  def __lt__(self, o):
7859  r"""__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7860  return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)
7861 
7862  def __gt__(self, o):
7863  r"""__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7864  return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)
7865 
7866  def __ge__(self, o):
7867  r"""__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7868  return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)
7869 
7870  def __le__(self, o):
7871  r"""__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7872  return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)
7873 
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)
7877 
7878  def __getitem__(self, i):
7879  r"""__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
7880  return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)
7881 
7882  def show(self, *args):
7883  r"""show(ExtendedGridIndex4D self, _ostream out=std::cout)"""
7884  return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)
7885 
7886  def __len__(self):
7887  r"""__len__(ExtendedGridIndex4D self) -> unsigned int"""
7888  return _IMP_algebra.ExtendedGridIndex4D___len__(self)
7889 
7890  def __hash__(self):
7891  r"""__hash__(ExtendedGridIndex4D self) -> std::size_t"""
7892  return _IMP_algebra.ExtendedGridIndex4D___hash__(self)
7893 
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)
7897 
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)
7901 
7902  def __str__(self):
7903  r"""__str__(ExtendedGridIndex4D self) -> std::string"""
7904  return _IMP_algebra.ExtendedGridIndex4D___str__(self)
7905 
7906  def __repr__(self):
7907  r"""__repr__(ExtendedGridIndex4D self) -> std::string"""
7908  return _IMP_algebra.ExtendedGridIndex4D___repr__(self)
7909 
7910  def _get_as_binary(self):
7911  r"""_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
7912  return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)
7913 
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)
7917 
7918  def __getstate__(self):
7919  p = self._get_as_binary()
7920  if len(self.__dict__) > 1:
7921  d = self.__dict__.copy()
7922  del d['this']
7923  p = (d, p)
7924  return p
7925 
7926  def __setstate__(self, p):
7927  if not hasattr(self, 'this'):
7928  self.__init__()
7929  if isinstance(p, tuple):
7930  d, p = p
7931  self.__dict__.update(d)
7932  return self._set_from_binary(p)
7933 
7934  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
7935 
7936 # Register ExtendedGridIndex4D in _IMP_algebra:
7937 _IMP_algebra.ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
7938 class ExtendedGridIndex5D(IMP._Value):
7939  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 5 > class."""
7940 
7941  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7942 
7943  def __init__(self, *args):
7944  r"""
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
7953  """
7954  _IMP_algebra.ExtendedGridIndex5D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex5D(*args))
7955 
7956  def get_dimension(self):
7957  r"""get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
7958  return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)
7959 
7960  def __cmp__(self, o):
7961  r"""__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
7962  return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, o)
7963 
7964  def __eq__(self, o):
7965  r"""__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7966  return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)
7967 
7968  def __ne__(self, o):
7969  r"""__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7970  return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)
7971 
7972  def __lt__(self, o):
7973  r"""__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7974  return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)
7975 
7976  def __gt__(self, o):
7977  r"""__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7978  return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)
7979 
7980  def __ge__(self, o):
7981  r"""__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7982  return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)
7983 
7984  def __le__(self, o):
7985  r"""__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7986  return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)
7987 
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)
7991 
7992  def __getitem__(self, i):
7993  r"""__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
7994  return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)
7995 
7996  def show(self, *args):
7997  r"""show(ExtendedGridIndex5D self, _ostream out=std::cout)"""
7998  return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)
7999 
8000  def __len__(self):
8001  r"""__len__(ExtendedGridIndex5D self) -> unsigned int"""
8002  return _IMP_algebra.ExtendedGridIndex5D___len__(self)
8003 
8004  def __hash__(self):
8005  r"""__hash__(ExtendedGridIndex5D self) -> std::size_t"""
8006  return _IMP_algebra.ExtendedGridIndex5D___hash__(self)
8007 
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)
8011 
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)
8015 
8016  def __str__(self):
8017  r"""__str__(ExtendedGridIndex5D self) -> std::string"""
8018  return _IMP_algebra.ExtendedGridIndex5D___str__(self)
8019 
8020  def __repr__(self):
8021  r"""__repr__(ExtendedGridIndex5D self) -> std::string"""
8022  return _IMP_algebra.ExtendedGridIndex5D___repr__(self)
8023 
8024  def _get_as_binary(self):
8025  r"""_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
8026  return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)
8027 
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)
8031 
8032  def __getstate__(self):
8033  p = self._get_as_binary()
8034  if len(self.__dict__) > 1:
8035  d = self.__dict__.copy()
8036  del d['this']
8037  p = (d, p)
8038  return p
8039 
8040  def __setstate__(self, p):
8041  if not hasattr(self, 'this'):
8042  self.__init__()
8043  if isinstance(p, tuple):
8044  d, p = p
8045  self.__dict__.update(d)
8046  return self._set_from_binary(p)
8047 
8048  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
8049 
8050 # Register ExtendedGridIndex5D in _IMP_algebra:
8051 _IMP_algebra.ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
8052 class ExtendedGridIndex6D(IMP._Value):
8053  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 6 > class."""
8054 
8055  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8056 
8057  def __init__(self, *args):
8058  r"""
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
8067  """
8068  _IMP_algebra.ExtendedGridIndex6D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex6D(*args))
8069 
8070  def get_dimension(self):
8071  r"""get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
8072  return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)
8073 
8074  def __cmp__(self, o):
8075  r"""__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
8076  return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, o)
8077 
8078  def __eq__(self, o):
8079  r"""__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8080  return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)
8081 
8082  def __ne__(self, o):
8083  r"""__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8084  return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)
8085 
8086  def __lt__(self, o):
8087  r"""__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8088  return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)
8089 
8090  def __gt__(self, o):
8091  r"""__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8092  return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)
8093 
8094  def __ge__(self, o):
8095  r"""__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8096  return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)
8097 
8098  def __le__(self, o):
8099  r"""__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8100  return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)
8101 
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)
8105 
8106  def __getitem__(self, i):
8107  r"""__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
8108  return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)
8109 
8110  def show(self, *args):
8111  r"""show(ExtendedGridIndex6D self, _ostream out=std::cout)"""
8112  return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)
8113 
8114  def __len__(self):
8115  r"""__len__(ExtendedGridIndex6D self) -> unsigned int"""
8116  return _IMP_algebra.ExtendedGridIndex6D___len__(self)
8117 
8118  def __hash__(self):
8119  r"""__hash__(ExtendedGridIndex6D self) -> std::size_t"""
8120  return _IMP_algebra.ExtendedGridIndex6D___hash__(self)
8121 
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)
8125 
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)
8129 
8130  def __str__(self):
8131  r"""__str__(ExtendedGridIndex6D self) -> std::string"""
8132  return _IMP_algebra.ExtendedGridIndex6D___str__(self)
8133 
8134  def __repr__(self):
8135  r"""__repr__(ExtendedGridIndex6D self) -> std::string"""
8136  return _IMP_algebra.ExtendedGridIndex6D___repr__(self)
8137 
8138  def _get_as_binary(self):
8139  r"""_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
8140  return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)
8141 
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)
8145 
8146  def __getstate__(self):
8147  p = self._get_as_binary()
8148  if len(self.__dict__) > 1:
8149  d = self.__dict__.copy()
8150  del d['this']
8151  p = (d, p)
8152  return p
8153 
8154  def __setstate__(self, p):
8155  if not hasattr(self, 'this'):
8156  self.__init__()
8157  if isinstance(p, tuple):
8158  d, p = p
8159  self.__dict__.update(d)
8160  return self._set_from_binary(p)
8161 
8162  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
8163 
8164 # Register ExtendedGridIndex6D in _IMP_algebra:
8165 _IMP_algebra.ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
8166 class ExtendedGridIndexKD(IMP._Value):
8167  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< -1 > class."""
8168 
8169  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8170 
8171  def __init__(self, *args):
8172  r"""
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
8181  """
8182  _IMP_algebra.ExtendedGridIndexKD_swiginit(self, _IMP_algebra.new_ExtendedGridIndexKD(*args))
8183 
8184  def get_dimension(self):
8185  r"""get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
8186  return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)
8187 
8188  def __cmp__(self, o):
8189  r"""__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
8190  return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, o)
8191 
8192  def __eq__(self, o):
8193  r"""__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8194  return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)
8195 
8196  def __ne__(self, o):
8197  r"""__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8198  return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)
8199 
8200  def __lt__(self, o):
8201  r"""__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8202  return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)
8203 
8204  def __gt__(self, o):
8205  r"""__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8206  return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)
8207 
8208  def __ge__(self, o):
8209  r"""__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8210  return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)
8211 
8212  def __le__(self, o):
8213  r"""__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8214  return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)
8215 
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)
8219 
8220  def __getitem__(self, i):
8221  r"""__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
8222  return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)
8223 
8224  def show(self, *args):
8225  r"""show(ExtendedGridIndexKD self, _ostream out=std::cout)"""
8226  return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)
8227 
8228  def __len__(self):
8229  r"""__len__(ExtendedGridIndexKD self) -> unsigned int"""
8230  return _IMP_algebra.ExtendedGridIndexKD___len__(self)
8231 
8232  def __hash__(self):
8233  r"""__hash__(ExtendedGridIndexKD self) -> std::size_t"""
8234  return _IMP_algebra.ExtendedGridIndexKD___hash__(self)
8235 
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)
8239 
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)
8243 
8244  def __str__(self):
8245  r"""__str__(ExtendedGridIndexKD self) -> std::string"""
8246  return _IMP_algebra.ExtendedGridIndexKD___str__(self)
8247 
8248  def __repr__(self):
8249  r"""__repr__(ExtendedGridIndexKD self) -> std::string"""
8250  return _IMP_algebra.ExtendedGridIndexKD___repr__(self)
8251 
8252  def _get_as_binary(self):
8253  r"""_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
8254  return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)
8255 
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)
8259 
8260  def __getstate__(self):
8261  p = self._get_as_binary()
8262  if len(self.__dict__) > 1:
8263  d = self.__dict__.copy()
8264  del d['this']
8265  p = (d, p)
8266  return p
8267 
8268  def __setstate__(self, p):
8269  if not hasattr(self, 'this'):
8270  self.__init__()
8271  if isinstance(p, tuple):
8272  d, p = p
8273  self.__dict__.update(d)
8274  return self._set_from_binary(p)
8275 
8276  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
8277 
8278 # Register ExtendedGridIndexKD in _IMP_algebra:
8279 _IMP_algebra.ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
8280 class BoundedGridRange1D(object):
8281  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 1 > class."""
8282 
8283  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8284 
8285  @staticmethod
8286  def get_is_bounded():
8287  r"""get_is_bounded() -> bool"""
8288  return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
8289 
8290  def __init__(self, *args):
8291  r"""
8292  __init__(BoundedGridRange1D self) -> BoundedGridRange1D
8293  __init__(BoundedGridRange1D self, IMP::Ints const & counts) -> BoundedGridRange1D
8294  """
8295  _IMP_algebra.BoundedGridRange1D_swiginit(self, _IMP_algebra.new_BoundedGridRange1D(*args))
8296 
8297  def get_number_of_voxels(self, *args):
8298  r"""
8299  get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
8300  get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
8301  """
8302  return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)
8303 
8304  def get_end_index(self):
8305  r"""get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8306  return _IMP_algebra.BoundedGridRange1D_get_end_index(self)
8307 
8308  def show(self, *args):
8309  r"""show(BoundedGridRange1D self, _ostream out=std::cout)"""
8310  return _IMP_algebra.BoundedGridRange1D_show(self, *args)
8311 
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)
8315 
8316  def get_indexes(self, lb, ub):
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)
8319 
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)
8323 
8324  def get_index(self, v):
8325  r"""get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
8326  return _IMP_algebra.BoundedGridRange1D_get_index(self, v)
8327 
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)
8331 
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)
8335 
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)
8339 
8340  def __str__(self):
8341  r"""__str__(BoundedGridRange1D self) -> std::string"""
8342  return _IMP_algebra.BoundedGridRange1D___str__(self)
8343 
8344  def __repr__(self):
8345  r"""__repr__(BoundedGridRange1D self) -> std::string"""
8346  return _IMP_algebra.BoundedGridRange1D___repr__(self)
8347 
8348  def __cmp__(self, arg2):
8349  r"""__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
8350  return _IMP_algebra.BoundedGridRange1D___cmp__(self, arg2)
8351 
8352  def __eq__(self, arg2):
8353  r"""__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
8354  return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)
8355 
8356  def _get_as_binary(self):
8357  r"""_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
8358  return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)
8359 
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)
8363 
8364  def __getstate__(self):
8365  p = self._get_as_binary()
8366  if len(self.__dict__) > 1:
8367  d = self.__dict__.copy()
8368  del d['this']
8369  p = (d, p)
8370  return p
8371 
8372  def __setstate__(self, p):
8373  if not hasattr(self, 'this'):
8374  self.__init__()
8375  if isinstance(p, tuple):
8376  d, p = p
8377  self.__dict__.update(d)
8378  return self._set_from_binary(p)
8379 
8380  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
8381 
8382 # Register BoundedGridRange1D in _IMP_algebra:
8383 _IMP_algebra.BoundedGridRange1D_swigregister(BoundedGridRange1D)
8384 class BoundedGridRange2D(object):
8385  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 2 > class."""
8386 
8387  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8388 
8389  @staticmethod
8390  def get_is_bounded():
8391  r"""get_is_bounded() -> bool"""
8392  return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
8393 
8394  def __init__(self, *args):
8395  r"""
8396  __init__(BoundedGridRange2D self) -> BoundedGridRange2D
8397  __init__(BoundedGridRange2D self, IMP::Ints const & counts) -> BoundedGridRange2D
8398  """
8399  _IMP_algebra.BoundedGridRange2D_swiginit(self, _IMP_algebra.new_BoundedGridRange2D(*args))
8400 
8401  def get_number_of_voxels(self, *args):
8402  r"""
8403  get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
8404  get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
8405  """
8406  return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)
8407 
8408  def get_end_index(self):
8409  r"""get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8410  return _IMP_algebra.BoundedGridRange2D_get_end_index(self)
8411 
8412  def show(self, *args):
8413  r"""show(BoundedGridRange2D self, _ostream out=std::cout)"""
8414  return _IMP_algebra.BoundedGridRange2D_show(self, *args)
8415 
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)
8419 
8420  def get_indexes(self, lb, ub):
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)
8423 
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)
8427 
8428  def get_index(self, v):
8429  r"""get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
8430  return _IMP_algebra.BoundedGridRange2D_get_index(self, v)
8431 
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)
8435 
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)
8439 
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)
8443 
8444  def __str__(self):
8445  r"""__str__(BoundedGridRange2D self) -> std::string"""
8446  return _IMP_algebra.BoundedGridRange2D___str__(self)
8447 
8448  def __repr__(self):
8449  r"""__repr__(BoundedGridRange2D self) -> std::string"""
8450  return _IMP_algebra.BoundedGridRange2D___repr__(self)
8451 
8452  def __cmp__(self, arg2):
8453  r"""__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
8454  return _IMP_algebra.BoundedGridRange2D___cmp__(self, arg2)
8455 
8456  def __eq__(self, arg2):
8457  r"""__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
8458  return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)
8459 
8460  def _get_as_binary(self):
8461  r"""_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
8462  return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)
8463 
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)
8467 
8468  def __getstate__(self):
8469  p = self._get_as_binary()
8470  if len(self.__dict__) > 1:
8471  d = self.__dict__.copy()
8472  del d['this']
8473  p = (d, p)
8474  return p
8475 
8476  def __setstate__(self, p):
8477  if not hasattr(self, 'this'):
8478  self.__init__()
8479  if isinstance(p, tuple):
8480  d, p = p
8481  self.__dict__.update(d)
8482  return self._set_from_binary(p)
8483 
8484  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
8485 
8486 # Register BoundedGridRange2D in _IMP_algebra:
8487 _IMP_algebra.BoundedGridRange2D_swigregister(BoundedGridRange2D)
8488 class BoundedGridRange3D(object):
8489  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 3 > class."""
8490 
8491  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8492 
8493  @staticmethod
8494  def get_is_bounded():
8495  r"""get_is_bounded() -> bool"""
8496  return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
8497 
8498  def __init__(self, *args):
8499  r"""
8500  __init__(BoundedGridRange3D self) -> BoundedGridRange3D
8501  __init__(BoundedGridRange3D self, IMP::Ints const & counts) -> BoundedGridRange3D
8502  """
8503  _IMP_algebra.BoundedGridRange3D_swiginit(self, _IMP_algebra.new_BoundedGridRange3D(*args))
8504 
8505  def get_number_of_voxels(self, *args):
8506  r"""
8507  get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
8508  get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
8509  """
8510  return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)
8511 
8512  def get_end_index(self):
8513  r"""get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8514  return _IMP_algebra.BoundedGridRange3D_get_end_index(self)
8515 
8516  def show(self, *args):
8517  r"""show(BoundedGridRange3D self, _ostream out=std::cout)"""
8518  return _IMP_algebra.BoundedGridRange3D_show(self, *args)
8519 
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)
8523 
8524  def get_indexes(self, lb, ub):
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)
8527 
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)
8531 
8532  def get_index(self, v):
8533  r"""get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
8534  return _IMP_algebra.BoundedGridRange3D_get_index(self, v)
8535 
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)
8539 
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)
8543 
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)
8547 
8548  def __str__(self):
8549  r"""__str__(BoundedGridRange3D self) -> std::string"""
8550  return _IMP_algebra.BoundedGridRange3D___str__(self)
8551 
8552  def __repr__(self):
8553  r"""__repr__(BoundedGridRange3D self) -> std::string"""
8554  return _IMP_algebra.BoundedGridRange3D___repr__(self)
8555 
8556  def __cmp__(self, arg2):
8557  r"""__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
8558  return _IMP_algebra.BoundedGridRange3D___cmp__(self, arg2)
8559 
8560  def __eq__(self, arg2):
8561  r"""__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
8562  return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)
8563 
8564  def _get_as_binary(self):
8565  r"""_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
8566  return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)
8567 
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)
8571 
8572  def __getstate__(self):
8573  p = self._get_as_binary()
8574  if len(self.__dict__) > 1:
8575  d = self.__dict__.copy()
8576  del d['this']
8577  p = (d, p)
8578  return p
8579 
8580  def __setstate__(self, p):
8581  if not hasattr(self, 'this'):
8582  self.__init__()
8583  if isinstance(p, tuple):
8584  d, p = p
8585  self.__dict__.update(d)
8586  return self._set_from_binary(p)
8587 
8588  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
8589 
8590 # Register BoundedGridRange3D in _IMP_algebra:
8591 _IMP_algebra.BoundedGridRange3D_swigregister(BoundedGridRange3D)
8592 class BoundedGridRange4D(object):
8593  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 4 > class."""
8594 
8595  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8596 
8597  @staticmethod
8598  def get_is_bounded():
8599  r"""get_is_bounded() -> bool"""
8600  return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
8601 
8602  def __init__(self, *args):
8603  r"""
8604  __init__(BoundedGridRange4D self) -> BoundedGridRange4D
8605  __init__(BoundedGridRange4D self, IMP::Ints const & counts) -> BoundedGridRange4D
8606  """
8607  _IMP_algebra.BoundedGridRange4D_swiginit(self, _IMP_algebra.new_BoundedGridRange4D(*args))
8608 
8609  def get_number_of_voxels(self, *args):
8610  r"""
8611  get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
8612  get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
8613  """
8614  return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)
8615 
8616  def get_end_index(self):
8617  r"""get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8618  return _IMP_algebra.BoundedGridRange4D_get_end_index(self)
8619 
8620  def show(self, *args):
8621  r"""show(BoundedGridRange4D self, _ostream out=std::cout)"""
8622  return _IMP_algebra.BoundedGridRange4D_show(self, *args)
8623 
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)
8627 
8628  def get_indexes(self, lb, ub):
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)
8631 
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)
8635 
8636  def get_index(self, v):
8637  r"""get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
8638  return _IMP_algebra.BoundedGridRange4D_get_index(self, v)
8639 
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)
8643 
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)
8647 
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)
8651 
8652  def __str__(self):
8653  r"""__str__(BoundedGridRange4D self) -> std::string"""
8654  return _IMP_algebra.BoundedGridRange4D___str__(self)
8655 
8656  def __repr__(self):
8657  r"""__repr__(BoundedGridRange4D self) -> std::string"""
8658  return _IMP_algebra.BoundedGridRange4D___repr__(self)
8659 
8660  def __cmp__(self, arg2):
8661  r"""__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
8662  return _IMP_algebra.BoundedGridRange4D___cmp__(self, arg2)
8663 
8664  def __eq__(self, arg2):
8665  r"""__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
8666  return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)
8667 
8668  def _get_as_binary(self):
8669  r"""_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
8670  return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)
8671 
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)
8675 
8676  def __getstate__(self):
8677  p = self._get_as_binary()
8678  if len(self.__dict__) > 1:
8679  d = self.__dict__.copy()
8680  del d['this']
8681  p = (d, p)
8682  return p
8683 
8684  def __setstate__(self, p):
8685  if not hasattr(self, 'this'):
8686  self.__init__()
8687  if isinstance(p, tuple):
8688  d, p = p
8689  self.__dict__.update(d)
8690  return self._set_from_binary(p)
8691 
8692  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
8693 
8694 # Register BoundedGridRange4D in _IMP_algebra:
8695 _IMP_algebra.BoundedGridRange4D_swigregister(BoundedGridRange4D)
8696 class BoundedGridRange5D(object):
8697  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 5 > class."""
8698 
8699  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8700 
8701  @staticmethod
8702  def get_is_bounded():
8703  r"""get_is_bounded() -> bool"""
8704  return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
8705 
8706  def __init__(self, *args):
8707  r"""
8708  __init__(BoundedGridRange5D self) -> BoundedGridRange5D
8709  __init__(BoundedGridRange5D self, IMP::Ints const & counts) -> BoundedGridRange5D
8710  """
8711  _IMP_algebra.BoundedGridRange5D_swiginit(self, _IMP_algebra.new_BoundedGridRange5D(*args))
8712 
8713  def get_number_of_voxels(self, *args):
8714  r"""
8715  get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
8716  get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
8717  """
8718  return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)
8719 
8720  def get_end_index(self):
8721  r"""get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8722  return _IMP_algebra.BoundedGridRange5D_get_end_index(self)
8723 
8724  def show(self, *args):
8725  r"""show(BoundedGridRange5D self, _ostream out=std::cout)"""
8726  return _IMP_algebra.BoundedGridRange5D_show(self, *args)
8727 
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)
8731 
8732  def get_indexes(self, lb, ub):
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)
8735 
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)
8739 
8740  def get_index(self, v):
8741  r"""get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
8742  return _IMP_algebra.BoundedGridRange5D_get_index(self, v)
8743 
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)
8747 
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)
8751 
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)
8755 
8756  def __str__(self):
8757  r"""__str__(BoundedGridRange5D self) -> std::string"""
8758  return _IMP_algebra.BoundedGridRange5D___str__(self)
8759 
8760  def __repr__(self):
8761  r"""__repr__(BoundedGridRange5D self) -> std::string"""
8762  return _IMP_algebra.BoundedGridRange5D___repr__(self)
8763 
8764  def __cmp__(self, arg2):
8765  r"""__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
8766  return _IMP_algebra.BoundedGridRange5D___cmp__(self, arg2)
8767 
8768  def __eq__(self, arg2):
8769  r"""__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
8770  return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)
8771 
8772  def _get_as_binary(self):
8773  r"""_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
8774  return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)
8775 
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)
8779 
8780  def __getstate__(self):
8781  p = self._get_as_binary()
8782  if len(self.__dict__) > 1:
8783  d = self.__dict__.copy()
8784  del d['this']
8785  p = (d, p)
8786  return p
8787 
8788  def __setstate__(self, p):
8789  if not hasattr(self, 'this'):
8790  self.__init__()
8791  if isinstance(p, tuple):
8792  d, p = p
8793  self.__dict__.update(d)
8794  return self._set_from_binary(p)
8795 
8796  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
8797 
8798 # Register BoundedGridRange5D in _IMP_algebra:
8799 _IMP_algebra.BoundedGridRange5D_swigregister(BoundedGridRange5D)
8800 class BoundedGridRange6D(object):
8801  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 6 > class."""
8802 
8803  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8804 
8805  @staticmethod
8806  def get_is_bounded():
8807  r"""get_is_bounded() -> bool"""
8808  return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
8809 
8810  def __init__(self, *args):
8811  r"""
8812  __init__(BoundedGridRange6D self) -> BoundedGridRange6D
8813  __init__(BoundedGridRange6D self, IMP::Ints const & counts) -> BoundedGridRange6D
8814  """
8815  _IMP_algebra.BoundedGridRange6D_swiginit(self, _IMP_algebra.new_BoundedGridRange6D(*args))
8816 
8817  def get_number_of_voxels(self, *args):
8818  r"""
8819  get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
8820  get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
8821  """
8822  return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)
8823 
8824  def get_end_index(self):
8825  r"""get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8826  return _IMP_algebra.BoundedGridRange6D_get_end_index(self)
8827 
8828  def show(self, *args):
8829  r"""show(BoundedGridRange6D self, _ostream out=std::cout)"""
8830  return _IMP_algebra.BoundedGridRange6D_show(self, *args)
8831 
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)
8835 
8836  def get_indexes(self, lb, ub):
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)
8839 
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)
8843 
8844  def get_index(self, v):
8845  r"""get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
8846  return _IMP_algebra.BoundedGridRange6D_get_index(self, v)
8847 
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)
8851 
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)
8855 
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)
8859 
8860  def __str__(self):
8861  r"""__str__(BoundedGridRange6D self) -> std::string"""
8862  return _IMP_algebra.BoundedGridRange6D___str__(self)
8863 
8864  def __repr__(self):
8865  r"""__repr__(BoundedGridRange6D self) -> std::string"""
8866  return _IMP_algebra.BoundedGridRange6D___repr__(self)
8867 
8868  def __cmp__(self, arg2):
8869  r"""__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
8870  return _IMP_algebra.BoundedGridRange6D___cmp__(self, arg2)
8871 
8872  def __eq__(self, arg2):
8873  r"""__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
8874  return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)
8875 
8876  def _get_as_binary(self):
8877  r"""_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
8878  return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)
8879 
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)
8883 
8884  def __getstate__(self):
8885  p = self._get_as_binary()
8886  if len(self.__dict__) > 1:
8887  d = self.__dict__.copy()
8888  del d['this']
8889  p = (d, p)
8890  return p
8891 
8892  def __setstate__(self, p):
8893  if not hasattr(self, 'this'):
8894  self.__init__()
8895  if isinstance(p, tuple):
8896  d, p = p
8897  self.__dict__.update(d)
8898  return self._set_from_binary(p)
8899 
8900  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
8901 
8902 # Register BoundedGridRange6D in _IMP_algebra:
8903 _IMP_algebra.BoundedGridRange6D_swigregister(BoundedGridRange6D)
8904 class BoundedGridRangeKD(object):
8905  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< -1 > class."""
8906 
8907  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8908 
8909  @staticmethod
8910  def get_is_bounded():
8911  r"""get_is_bounded() -> bool"""
8912  return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
8913 
8914  def __init__(self, *args):
8915  r"""
8916  __init__(BoundedGridRangeKD self) -> BoundedGridRangeKD
8917  __init__(BoundedGridRangeKD self, IMP::Ints const & counts) -> BoundedGridRangeKD
8918  """
8919  _IMP_algebra.BoundedGridRangeKD_swiginit(self, _IMP_algebra.new_BoundedGridRangeKD(*args))
8920 
8921  def get_number_of_voxels(self, *args):
8922  r"""
8923  get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
8924  get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
8925  """
8926  return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)
8927 
8928  def get_end_index(self):
8929  r"""get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8930  return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)
8931 
8932  def show(self, *args):
8933  r"""show(BoundedGridRangeKD self, _ostream out=std::cout)"""
8934  return _IMP_algebra.BoundedGridRangeKD_show(self, *args)
8935 
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)
8939 
8940  def get_indexes(self, lb, ub):
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)
8943 
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)
8947 
8948  def get_index(self, v):
8949  r"""get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
8950  return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)
8951 
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)
8955 
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)
8959 
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)
8963 
8964  def __str__(self):
8965  r"""__str__(BoundedGridRangeKD self) -> std::string"""
8966  return _IMP_algebra.BoundedGridRangeKD___str__(self)
8967 
8968  def __repr__(self):
8969  r"""__repr__(BoundedGridRangeKD self) -> std::string"""
8970  return _IMP_algebra.BoundedGridRangeKD___repr__(self)
8971 
8972  def __cmp__(self, arg2):
8973  r"""__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
8974  return _IMP_algebra.BoundedGridRangeKD___cmp__(self, arg2)
8975 
8976  def __eq__(self, arg2):
8977  r"""__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
8978  return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)
8979 
8980  def _get_as_binary(self):
8981  r"""_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
8982  return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)
8983 
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)
8987 
8988  def __getstate__(self):
8989  p = self._get_as_binary()
8990  if len(self.__dict__) > 1:
8991  d = self.__dict__.copy()
8992  del d['this']
8993  p = (d, p)
8994  return p
8995 
8996  def __setstate__(self, p):
8997  if not hasattr(self, 'this'):
8998  self.__init__()
8999  if isinstance(p, tuple):
9000  d, p = p
9001  self.__dict__.update(d)
9002  return self._set_from_binary(p)
9003 
9004  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
9005 
9006 # Register BoundedGridRangeKD in _IMP_algebra:
9007 _IMP_algebra.BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
9008 class UnboundedGridRange1D(object):
9009  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 1 > class."""
9010 
9011  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9012 
9013  def __init__(self, *args):
9014  r"""
9015  __init__(UnboundedGridRange1D self) -> UnboundedGridRange1D
9016  __init__(UnboundedGridRange1D self, IMP::Ints const & arg2) -> UnboundedGridRange1D
9017  """
9018  _IMP_algebra.UnboundedGridRange1D_swiginit(self, _IMP_algebra.new_UnboundedGridRange1D(*args))
9019 
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)
9023 
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)
9027 
9028  @staticmethod
9029  def get_is_bounded():
9030  r"""get_is_bounded() -> bool"""
9031  return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
9032 
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)
9036 
9037  def show(self, *args):
9038  r"""show(UnboundedGridRange1D self, _ostream out=std::cout)"""
9039  return _IMP_algebra.UnboundedGridRange1D_show(self, *args)
9040 
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)
9044 
9045  def __str__(self):
9046  r"""__str__(UnboundedGridRange1D self) -> std::string"""
9047  return _IMP_algebra.UnboundedGridRange1D___str__(self)
9048 
9049  def __repr__(self):
9050  r"""__repr__(UnboundedGridRange1D self) -> std::string"""
9051  return _IMP_algebra.UnboundedGridRange1D___repr__(self)
9052 
9053  def __cmp__(self, arg2):
9054  r"""__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
9055  return _IMP_algebra.UnboundedGridRange1D___cmp__(self, arg2)
9056 
9057  def __eq__(self, arg2):
9058  r"""__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
9059  return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)
9060 
9061  def _get_as_binary(self):
9062  r"""_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
9063  return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)
9064 
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)
9068 
9069  def __getstate__(self):
9070  p = self._get_as_binary()
9071  if len(self.__dict__) > 1:
9072  d = self.__dict__.copy()
9073  del d['this']
9074  p = (d, p)
9075  return p
9076 
9077  def __setstate__(self, p):
9078  if not hasattr(self, 'this'):
9079  self.__init__()
9080  if isinstance(p, tuple):
9081  d, p = p
9082  self.__dict__.update(d)
9083  return self._set_from_binary(p)
9084 
9085  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
9086 
9087 # Register UnboundedGridRange1D in _IMP_algebra:
9088 _IMP_algebra.UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
9089 class UnboundedGridRange2D(object):
9090  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 2 > class."""
9091 
9092  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9093 
9094  def __init__(self, *args):
9095  r"""
9096  __init__(UnboundedGridRange2D self) -> UnboundedGridRange2D
9097  __init__(UnboundedGridRange2D self, IMP::Ints const & arg2) -> UnboundedGridRange2D
9098  """
9099  _IMP_algebra.UnboundedGridRange2D_swiginit(self, _IMP_algebra.new_UnboundedGridRange2D(*args))
9100 
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)
9104 
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)
9108 
9109  @staticmethod
9110  def get_is_bounded():
9111  r"""get_is_bounded() -> bool"""
9112  return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
9113 
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)
9117 
9118  def show(self, *args):
9119  r"""show(UnboundedGridRange2D self, _ostream out=std::cout)"""
9120  return _IMP_algebra.UnboundedGridRange2D_show(self, *args)
9121 
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)
9125 
9126  def __str__(self):
9127  r"""__str__(UnboundedGridRange2D self) -> std::string"""
9128  return _IMP_algebra.UnboundedGridRange2D___str__(self)
9129 
9130  def __repr__(self):
9131  r"""__repr__(UnboundedGridRange2D self) -> std::string"""
9132  return _IMP_algebra.UnboundedGridRange2D___repr__(self)
9133 
9134  def __cmp__(self, arg2):
9135  r"""__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
9136  return _IMP_algebra.UnboundedGridRange2D___cmp__(self, arg2)
9137 
9138  def __eq__(self, arg2):
9139  r"""__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
9140  return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)
9141 
9142  def _get_as_binary(self):
9143  r"""_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
9144  return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)
9145 
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)
9149 
9150  def __getstate__(self):
9151  p = self._get_as_binary()
9152  if len(self.__dict__) > 1:
9153  d = self.__dict__.copy()
9154  del d['this']
9155  p = (d, p)
9156  return p
9157 
9158  def __setstate__(self, p):
9159  if not hasattr(self, 'this'):
9160  self.__init__()
9161  if isinstance(p, tuple):
9162  d, p = p
9163  self.__dict__.update(d)
9164  return self._set_from_binary(p)
9165 
9166  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
9167 
9168 # Register UnboundedGridRange2D in _IMP_algebra:
9169 _IMP_algebra.UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
9170 class UnboundedGridRange3D(object):
9171  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 3 > class."""
9172 
9173  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9174 
9175  def __init__(self, *args):
9176  r"""
9177  __init__(UnboundedGridRange3D self) -> UnboundedGridRange3D
9178  __init__(UnboundedGridRange3D self, IMP::Ints const & arg2) -> UnboundedGridRange3D
9179  """
9180  _IMP_algebra.UnboundedGridRange3D_swiginit(self, _IMP_algebra.new_UnboundedGridRange3D(*args))
9181 
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)
9185 
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)
9189 
9190  @staticmethod
9191  def get_is_bounded():
9192  r"""get_is_bounded() -> bool"""
9193  return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
9194 
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)
9198 
9199  def show(self, *args):
9200  r"""show(UnboundedGridRange3D self, _ostream out=std::cout)"""
9201  return _IMP_algebra.UnboundedGridRange3D_show(self, *args)
9202 
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)
9206 
9207  def __str__(self):
9208  r"""__str__(UnboundedGridRange3D self) -> std::string"""
9209  return _IMP_algebra.UnboundedGridRange3D___str__(self)
9210 
9211  def __repr__(self):
9212  r"""__repr__(UnboundedGridRange3D self) -> std::string"""
9213  return _IMP_algebra.UnboundedGridRange3D___repr__(self)
9214 
9215  def __cmp__(self, arg2):
9216  r"""__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
9217  return _IMP_algebra.UnboundedGridRange3D___cmp__(self, arg2)
9218 
9219  def __eq__(self, arg2):
9220  r"""__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
9221  return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)
9222 
9223  def _get_as_binary(self):
9224  r"""_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
9225  return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)
9226 
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)
9230 
9231  def __getstate__(self):
9232  p = self._get_as_binary()
9233  if len(self.__dict__) > 1:
9234  d = self.__dict__.copy()
9235  del d['this']
9236  p = (d, p)
9237  return p
9238 
9239  def __setstate__(self, p):
9240  if not hasattr(self, 'this'):
9241  self.__init__()
9242  if isinstance(p, tuple):
9243  d, p = p
9244  self.__dict__.update(d)
9245  return self._set_from_binary(p)
9246 
9247  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
9248 
9249 # Register UnboundedGridRange3D in _IMP_algebra:
9250 _IMP_algebra.UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
9251 class UnboundedGridRange4D(object):
9252  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 4 > class."""
9253 
9254  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9255 
9256  def __init__(self, *args):
9257  r"""
9258  __init__(UnboundedGridRange4D self) -> UnboundedGridRange4D
9259  __init__(UnboundedGridRange4D self, IMP::Ints const & arg2) -> UnboundedGridRange4D
9260  """
9261  _IMP_algebra.UnboundedGridRange4D_swiginit(self, _IMP_algebra.new_UnboundedGridRange4D(*args))
9262 
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)
9266 
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)
9270 
9271  @staticmethod
9272  def get_is_bounded():
9273  r"""get_is_bounded() -> bool"""
9274  return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
9275 
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)
9279 
9280  def show(self, *args):
9281  r"""show(UnboundedGridRange4D self, _ostream out=std::cout)"""
9282  return _IMP_algebra.UnboundedGridRange4D_show(self, *args)
9283 
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)
9287 
9288  def __str__(self):
9289  r"""__str__(UnboundedGridRange4D self) -> std::string"""
9290  return _IMP_algebra.UnboundedGridRange4D___str__(self)
9291 
9292  def __repr__(self):
9293  r"""__repr__(UnboundedGridRange4D self) -> std::string"""
9294  return _IMP_algebra.UnboundedGridRange4D___repr__(self)
9295 
9296  def __cmp__(self, arg2):
9297  r"""__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
9298  return _IMP_algebra.UnboundedGridRange4D___cmp__(self, arg2)
9299 
9300  def __eq__(self, arg2):
9301  r"""__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
9302  return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)
9303 
9304  def _get_as_binary(self):
9305  r"""_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
9306  return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)
9307 
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)
9311 
9312  def __getstate__(self):
9313  p = self._get_as_binary()
9314  if len(self.__dict__) > 1:
9315  d = self.__dict__.copy()
9316  del d['this']
9317  p = (d, p)
9318  return p
9319 
9320  def __setstate__(self, p):
9321  if not hasattr(self, 'this'):
9322  self.__init__()
9323  if isinstance(p, tuple):
9324  d, p = p
9325  self.__dict__.update(d)
9326  return self._set_from_binary(p)
9327 
9328  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
9329 
9330 # Register UnboundedGridRange4D in _IMP_algebra:
9331 _IMP_algebra.UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
9332 class UnboundedGridRange5D(object):
9333  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 5 > class."""
9334 
9335  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9336 
9337  def __init__(self, *args):
9338  r"""
9339  __init__(UnboundedGridRange5D self) -> UnboundedGridRange5D
9340  __init__(UnboundedGridRange5D self, IMP::Ints const & arg2) -> UnboundedGridRange5D
9341  """
9342  _IMP_algebra.UnboundedGridRange5D_swiginit(self, _IMP_algebra.new_UnboundedGridRange5D(*args))
9343 
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)
9347 
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)
9351 
9352  @staticmethod
9353  def get_is_bounded():
9354  r"""get_is_bounded() -> bool"""
9355  return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
9356 
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)
9360 
9361  def show(self, *args):
9362  r"""show(UnboundedGridRange5D self, _ostream out=std::cout)"""
9363  return _IMP_algebra.UnboundedGridRange5D_show(self, *args)
9364 
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)
9368 
9369  def __str__(self):
9370  r"""__str__(UnboundedGridRange5D self) -> std::string"""
9371  return _IMP_algebra.UnboundedGridRange5D___str__(self)
9372 
9373  def __repr__(self):
9374  r"""__repr__(UnboundedGridRange5D self) -> std::string"""
9375  return _IMP_algebra.UnboundedGridRange5D___repr__(self)
9376 
9377  def __cmp__(self, arg2):
9378  r"""__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
9379  return _IMP_algebra.UnboundedGridRange5D___cmp__(self, arg2)
9380 
9381  def __eq__(self, arg2):
9382  r"""__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
9383  return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)
9384 
9385  def _get_as_binary(self):
9386  r"""_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
9387  return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)
9388 
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)
9392 
9393  def __getstate__(self):
9394  p = self._get_as_binary()
9395  if len(self.__dict__) > 1:
9396  d = self.__dict__.copy()
9397  del d['this']
9398  p = (d, p)
9399  return p
9400 
9401  def __setstate__(self, p):
9402  if not hasattr(self, 'this'):
9403  self.__init__()
9404  if isinstance(p, tuple):
9405  d, p = p
9406  self.__dict__.update(d)
9407  return self._set_from_binary(p)
9408 
9409  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
9410 
9411 # Register UnboundedGridRange5D in _IMP_algebra:
9412 _IMP_algebra.UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
9413 class UnboundedGridRange6D(object):
9414  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 6 > class."""
9415 
9416  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9417 
9418  def __init__(self, *args):
9419  r"""
9420  __init__(UnboundedGridRange6D self) -> UnboundedGridRange6D
9421  __init__(UnboundedGridRange6D self, IMP::Ints const & arg2) -> UnboundedGridRange6D
9422  """
9423  _IMP_algebra.UnboundedGridRange6D_swiginit(self, _IMP_algebra.new_UnboundedGridRange6D(*args))
9424 
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)
9428 
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)
9432 
9433  @staticmethod
9434  def get_is_bounded():
9435  r"""get_is_bounded() -> bool"""
9436  return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
9437 
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)
9441 
9442  def show(self, *args):
9443  r"""show(UnboundedGridRange6D self, _ostream out=std::cout)"""
9444  return _IMP_algebra.UnboundedGridRange6D_show(self, *args)
9445 
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)
9449 
9450  def __str__(self):
9451  r"""__str__(UnboundedGridRange6D self) -> std::string"""
9452  return _IMP_algebra.UnboundedGridRange6D___str__(self)
9453 
9454  def __repr__(self):
9455  r"""__repr__(UnboundedGridRange6D self) -> std::string"""
9456  return _IMP_algebra.UnboundedGridRange6D___repr__(self)
9457 
9458  def __cmp__(self, arg2):
9459  r"""__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
9460  return _IMP_algebra.UnboundedGridRange6D___cmp__(self, arg2)
9461 
9462  def __eq__(self, arg2):
9463  r"""__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
9464  return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)
9465 
9466  def _get_as_binary(self):
9467  r"""_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
9468  return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)
9469 
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)
9473 
9474  def __getstate__(self):
9475  p = self._get_as_binary()
9476  if len(self.__dict__) > 1:
9477  d = self.__dict__.copy()
9478  del d['this']
9479  p = (d, p)
9480  return p
9481 
9482  def __setstate__(self, p):
9483  if not hasattr(self, 'this'):
9484  self.__init__()
9485  if isinstance(p, tuple):
9486  d, p = p
9487  self.__dict__.update(d)
9488  return self._set_from_binary(p)
9489 
9490  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
9491 
9492 # Register UnboundedGridRange6D in _IMP_algebra:
9493 _IMP_algebra.UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
9494 class UnboundedGridRangeKD(object):
9495  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< -1 > class."""
9496 
9497  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9498 
9499  def __init__(self, *args):
9500  r"""
9501  __init__(UnboundedGridRangeKD self) -> UnboundedGridRangeKD
9502  __init__(UnboundedGridRangeKD self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
9503  """
9504  _IMP_algebra.UnboundedGridRangeKD_swiginit(self, _IMP_algebra.new_UnboundedGridRangeKD(*args))
9505 
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)
9509 
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)
9513 
9514  @staticmethod
9515  def get_is_bounded():
9516  r"""get_is_bounded() -> bool"""
9517  return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
9518 
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)
9522 
9523  def show(self, *args):
9524  r"""show(UnboundedGridRangeKD self, _ostream out=std::cout)"""
9525  return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)
9526 
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)
9530 
9531  def __str__(self):
9532  r"""__str__(UnboundedGridRangeKD self) -> std::string"""
9533  return _IMP_algebra.UnboundedGridRangeKD___str__(self)
9534 
9535  def __repr__(self):
9536  r"""__repr__(UnboundedGridRangeKD self) -> std::string"""
9537  return _IMP_algebra.UnboundedGridRangeKD___repr__(self)
9538 
9539  def __cmp__(self, arg2):
9540  r"""__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
9541  return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, arg2)
9542 
9543  def __eq__(self, arg2):
9544  r"""__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
9545  return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)
9546 
9547  def _get_as_binary(self):
9548  r"""_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
9549  return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)
9550 
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)
9554 
9555  def __getstate__(self):
9556  p = self._get_as_binary()
9557  if len(self.__dict__) > 1:
9558  d = self.__dict__.copy()
9559  del d['this']
9560  p = (d, p)
9561  return p
9562 
9563  def __setstate__(self, p):
9564  if not hasattr(self, 'this'):
9565  self.__init__()
9566  if isinstance(p, tuple):
9567  d, p = p
9568  self.__dict__.update(d)
9569  return self._set_from_binary(p)
9570 
9571  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
9572 
9573 # Register UnboundedGridRangeKD in _IMP_algebra:
9574 _IMP_algebra.UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
9575 class DefaultEmbedding1D(object):
9576  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 1 > class."""
9577 
9578  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9579 
9580  def __init__(self, *args):
9581  r"""
9582  __init__(DefaultEmbedding1D self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
9583  __init__(DefaultEmbedding1D self) -> DefaultEmbedding1D
9584  """
9585  _IMP_algebra.DefaultEmbedding1D_swiginit(self, _IMP_algebra.new_DefaultEmbedding1D(*args))
9586 
9587  def set_origin(self, o):
9588  r"""set_origin(DefaultEmbedding1D self, Vector1D o)"""
9589  return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)
9590 
9591  def get_origin(self):
9592  r"""get_origin(DefaultEmbedding1D self) -> Vector1D"""
9593  return _IMP_algebra.DefaultEmbedding1D_get_origin(self)
9594 
9595  def get_dimension(self):
9596  r"""get_dimension(DefaultEmbedding1D self) -> unsigned int"""
9597  return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)
9598 
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)
9602 
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)
9606 
9607  def get_unit_cell(self):
9608  r"""get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9609  return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)
9610 
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)
9614 
9615  def get_index(self, o):
9616  r"""get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
9617  return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)
9618 
9619  def get_center(self, *args):
9620  r"""
9621  get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
9622  get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
9623  """
9624  return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)
9625 
9626  def get_bounding_box(self, *args):
9627  r"""
9628  get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
9629  get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
9630  """
9631  return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)
9632 
9633  def show(self, *args):
9634  r"""show(DefaultEmbedding1D self, _ostream out=std::cout)"""
9635  return _IMP_algebra.DefaultEmbedding1D_show(self, *args)
9636 
9637  def __str__(self):
9638  r"""__str__(DefaultEmbedding1D self) -> std::string"""
9639  return _IMP_algebra.DefaultEmbedding1D___str__(self)
9640 
9641  def __repr__(self):
9642  r"""__repr__(DefaultEmbedding1D self) -> std::string"""
9643  return _IMP_algebra.DefaultEmbedding1D___repr__(self)
9644 
9645  def __cmp__(self, arg2):
9646  r"""__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
9647  return _IMP_algebra.DefaultEmbedding1D___cmp__(self, arg2)
9648 
9649  def __eq__(self, arg2):
9650  r"""__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
9651  return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)
9652 
9653  def _get_as_binary(self):
9654  r"""_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
9655  return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)
9656 
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)
9660 
9661  def __getstate__(self):
9662  p = self._get_as_binary()
9663  if len(self.__dict__) > 1:
9664  d = self.__dict__.copy()
9665  del d['this']
9666  p = (d, p)
9667  return p
9668 
9669  def __setstate__(self, p):
9670  if not hasattr(self, 'this'):
9671  self.__init__()
9672  if isinstance(p, tuple):
9673  d, p = p
9674  self.__dict__.update(d)
9675  return self._set_from_binary(p)
9676 
9677  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
9678 
9679 # Register DefaultEmbedding1D in _IMP_algebra:
9680 _IMP_algebra.DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
9681 class DefaultEmbedding2D(object):
9682  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 2 > class."""
9683 
9684  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9685 
9686  def __init__(self, *args):
9687  r"""
9688  __init__(DefaultEmbedding2D self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
9689  __init__(DefaultEmbedding2D self) -> DefaultEmbedding2D
9690  """
9691  _IMP_algebra.DefaultEmbedding2D_swiginit(self, _IMP_algebra.new_DefaultEmbedding2D(*args))
9692 
9693  def set_origin(self, o):
9694  r"""set_origin(DefaultEmbedding2D self, Vector2D o)"""
9695  return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)
9696 
9697  def get_origin(self):
9698  r"""get_origin(DefaultEmbedding2D self) -> Vector2D"""
9699  return _IMP_algebra.DefaultEmbedding2D_get_origin(self)
9700 
9701  def get_dimension(self):
9702  r"""get_dimension(DefaultEmbedding2D self) -> unsigned int"""
9703  return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)
9704 
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)
9708 
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)
9712 
9713  def get_unit_cell(self):
9714  r"""get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9715  return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)
9716 
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)
9720 
9721  def get_index(self, o):
9722  r"""get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
9723  return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)
9724 
9725  def get_center(self, *args):
9726  r"""
9727  get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
9728  get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
9729  """
9730  return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)
9731 
9732  def get_bounding_box(self, *args):
9733  r"""
9734  get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
9735  get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
9736  """
9737  return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)
9738 
9739  def show(self, *args):
9740  r"""show(DefaultEmbedding2D self, _ostream out=std::cout)"""
9741  return _IMP_algebra.DefaultEmbedding2D_show(self, *args)
9742 
9743  def __str__(self):
9744  r"""__str__(DefaultEmbedding2D self) -> std::string"""
9745  return _IMP_algebra.DefaultEmbedding2D___str__(self)
9746 
9747  def __repr__(self):
9748  r"""__repr__(DefaultEmbedding2D self) -> std::string"""
9749  return _IMP_algebra.DefaultEmbedding2D___repr__(self)
9750 
9751  def __cmp__(self, arg2):
9752  r"""__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
9753  return _IMP_algebra.DefaultEmbedding2D___cmp__(self, arg2)
9754 
9755  def __eq__(self, arg2):
9756  r"""__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
9757  return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)
9758 
9759  def _get_as_binary(self):
9760  r"""_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
9761  return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)
9762 
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)
9766 
9767  def __getstate__(self):
9768  p = self._get_as_binary()
9769  if len(self.__dict__) > 1:
9770  d = self.__dict__.copy()
9771  del d['this']
9772  p = (d, p)
9773  return p
9774 
9775  def __setstate__(self, p):
9776  if not hasattr(self, 'this'):
9777  self.__init__()
9778  if isinstance(p, tuple):
9779  d, p = p
9780  self.__dict__.update(d)
9781  return self._set_from_binary(p)
9782 
9783  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
9784 
9785 # Register DefaultEmbedding2D in _IMP_algebra:
9786 _IMP_algebra.DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
9787 class DefaultEmbedding3D(object):
9788  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 3 > class."""
9789 
9790  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9791 
9792  def __init__(self, *args):
9793  r"""
9794  __init__(DefaultEmbedding3D self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
9795  __init__(DefaultEmbedding3D self) -> DefaultEmbedding3D
9796  """
9797  _IMP_algebra.DefaultEmbedding3D_swiginit(self, _IMP_algebra.new_DefaultEmbedding3D(*args))
9798 
9799  def set_origin(self, o):
9800  r"""set_origin(DefaultEmbedding3D self, Vector3D o)"""
9801  return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)
9802 
9803  def get_origin(self):
9804  r"""get_origin(DefaultEmbedding3D self) -> Vector3D"""
9805  return _IMP_algebra.DefaultEmbedding3D_get_origin(self)
9806 
9807  def get_dimension(self):
9808  r"""get_dimension(DefaultEmbedding3D self) -> unsigned int"""
9809  return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)
9810 
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)
9814 
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)
9818 
9819  def get_unit_cell(self):
9820  r"""get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9821  return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)
9822 
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)
9826 
9827  def get_index(self, o):
9828  r"""get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
9829  return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)
9830 
9831  def get_center(self, *args):
9832  r"""
9833  get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
9834  get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
9835  """
9836  return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)
9837 
9838  def get_bounding_box(self, *args):
9839  r"""
9840  get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
9841  get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
9842  """
9843  return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)
9844 
9845  def show(self, *args):
9846  r"""show(DefaultEmbedding3D self, _ostream out=std::cout)"""
9847  return _IMP_algebra.DefaultEmbedding3D_show(self, *args)
9848 
9849  def __str__(self):
9850  r"""__str__(DefaultEmbedding3D self) -> std::string"""
9851  return _IMP_algebra.DefaultEmbedding3D___str__(self)
9852 
9853  def __repr__(self):
9854  r"""__repr__(DefaultEmbedding3D self) -> std::string"""
9855  return _IMP_algebra.DefaultEmbedding3D___repr__(self)
9856 
9857  def __cmp__(self, arg2):
9858  r"""__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
9859  return _IMP_algebra.DefaultEmbedding3D___cmp__(self, arg2)
9860 
9861  def __eq__(self, arg2):
9862  r"""__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
9863  return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)
9864 
9865  def _get_as_binary(self):
9866  r"""_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
9867  return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)
9868 
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)
9872 
9873  def __getstate__(self):
9874  p = self._get_as_binary()
9875  if len(self.__dict__) > 1:
9876  d = self.__dict__.copy()
9877  del d['this']
9878  p = (d, p)
9879  return p
9880 
9881  def __setstate__(self, p):
9882  if not hasattr(self, 'this'):
9883  self.__init__()
9884  if isinstance(p, tuple):
9885  d, p = p
9886  self.__dict__.update(d)
9887  return self._set_from_binary(p)
9888 
9889  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
9890 
9891 # Register DefaultEmbedding3D in _IMP_algebra:
9892 _IMP_algebra.DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
9893 class DefaultEmbedding4D(object):
9894  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 4 > class."""
9895 
9896  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9897 
9898  def __init__(self, *args):
9899  r"""
9900  __init__(DefaultEmbedding4D self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
9901  __init__(DefaultEmbedding4D self) -> DefaultEmbedding4D
9902  """
9903  _IMP_algebra.DefaultEmbedding4D_swiginit(self, _IMP_algebra.new_DefaultEmbedding4D(*args))
9904 
9905  def set_origin(self, o):
9906  r"""set_origin(DefaultEmbedding4D self, Vector4D o)"""
9907  return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)
9908 
9909  def get_origin(self):
9910  r"""get_origin(DefaultEmbedding4D self) -> Vector4D"""
9911  return _IMP_algebra.DefaultEmbedding4D_get_origin(self)
9912 
9913  def get_dimension(self):
9914  r"""get_dimension(DefaultEmbedding4D self) -> unsigned int"""
9915  return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)
9916 
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)
9920 
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)
9924 
9925  def get_unit_cell(self):
9926  r"""get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9927  return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)
9928 
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)
9932 
9933  def get_index(self, o):
9934  r"""get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
9935  return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)
9936 
9937  def get_center(self, *args):
9938  r"""
9939  get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
9940  get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
9941  """
9942  return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)
9943 
9944  def get_bounding_box(self, *args):
9945  r"""
9946  get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
9947  get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
9948  """
9949  return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)
9950 
9951  def show(self, *args):
9952  r"""show(DefaultEmbedding4D self, _ostream out=std::cout)"""
9953  return _IMP_algebra.DefaultEmbedding4D_show(self, *args)
9954 
9955  def __str__(self):
9956  r"""__str__(DefaultEmbedding4D self) -> std::string"""
9957  return _IMP_algebra.DefaultEmbedding4D___str__(self)
9958 
9959  def __repr__(self):
9960  r"""__repr__(DefaultEmbedding4D self) -> std::string"""
9961  return _IMP_algebra.DefaultEmbedding4D___repr__(self)
9962 
9963  def __cmp__(self, arg2):
9964  r"""__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
9965  return _IMP_algebra.DefaultEmbedding4D___cmp__(self, arg2)
9966 
9967  def __eq__(self, arg2):
9968  r"""__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
9969  return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)
9970 
9971  def _get_as_binary(self):
9972  r"""_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
9973  return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)
9974 
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)
9978 
9979  def __getstate__(self):
9980  p = self._get_as_binary()
9981  if len(self.__dict__) > 1:
9982  d = self.__dict__.copy()
9983  del d['this']
9984  p = (d, p)
9985  return p
9986 
9987  def __setstate__(self, p):
9988  if not hasattr(self, 'this'):
9989  self.__init__()
9990  if isinstance(p, tuple):
9991  d, p = p
9992  self.__dict__.update(d)
9993  return self._set_from_binary(p)
9994 
9995  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
9996 
9997 # Register DefaultEmbedding4D in _IMP_algebra:
9998 _IMP_algebra.DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
9999 class DefaultEmbedding5D(object):
10000  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 5 > class."""
10001 
10002  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10003 
10004  def __init__(self, *args):
10005  r"""
10006  __init__(DefaultEmbedding5D self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
10007  __init__(DefaultEmbedding5D self) -> DefaultEmbedding5D
10008  """
10009  _IMP_algebra.DefaultEmbedding5D_swiginit(self, _IMP_algebra.new_DefaultEmbedding5D(*args))
10010 
10011  def set_origin(self, o):
10012  r"""set_origin(DefaultEmbedding5D self, Vector5D o)"""
10013  return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)
10014 
10015  def get_origin(self):
10016  r"""get_origin(DefaultEmbedding5D self) -> Vector5D"""
10017  return _IMP_algebra.DefaultEmbedding5D_get_origin(self)
10018 
10019  def get_dimension(self):
10020  r"""get_dimension(DefaultEmbedding5D self) -> unsigned int"""
10021  return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)
10022 
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)
10026 
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)
10030 
10031  def get_unit_cell(self):
10032  r"""get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10033  return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)
10034 
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)
10038 
10039  def get_index(self, o):
10040  r"""get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
10041  return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)
10042 
10043  def get_center(self, *args):
10044  r"""
10045  get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10046  get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
10047  """
10048  return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)
10049 
10050  def get_bounding_box(self, *args):
10051  r"""
10052  get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10053  get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10054  """
10055  return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)
10056 
10057  def show(self, *args):
10058  r"""show(DefaultEmbedding5D self, _ostream out=std::cout)"""
10059  return _IMP_algebra.DefaultEmbedding5D_show(self, *args)
10060 
10061  def __str__(self):
10062  r"""__str__(DefaultEmbedding5D self) -> std::string"""
10063  return _IMP_algebra.DefaultEmbedding5D___str__(self)
10064 
10065  def __repr__(self):
10066  r"""__repr__(DefaultEmbedding5D self) -> std::string"""
10067  return _IMP_algebra.DefaultEmbedding5D___repr__(self)
10068 
10069  def __cmp__(self, arg2):
10070  r"""__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
10071  return _IMP_algebra.DefaultEmbedding5D___cmp__(self, arg2)
10072 
10073  def __eq__(self, arg2):
10074  r"""__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
10075  return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)
10076 
10077  def _get_as_binary(self):
10078  r"""_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
10079  return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)
10080 
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)
10084 
10085  def __getstate__(self):
10086  p = self._get_as_binary()
10087  if len(self.__dict__) > 1:
10088  d = self.__dict__.copy()
10089  del d['this']
10090  p = (d, p)
10091  return p
10092 
10093  def __setstate__(self, p):
10094  if not hasattr(self, 'this'):
10095  self.__init__()
10096  if isinstance(p, tuple):
10097  d, p = p
10098  self.__dict__.update(d)
10099  return self._set_from_binary(p)
10100 
10101  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
10102 
10103 # Register DefaultEmbedding5D in _IMP_algebra:
10104 _IMP_algebra.DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
10105 class DefaultEmbedding6D(object):
10106  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 6 > class."""
10107 
10108  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10109 
10110  def __init__(self, *args):
10111  r"""
10112  __init__(DefaultEmbedding6D self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
10113  __init__(DefaultEmbedding6D self) -> DefaultEmbedding6D
10114  """
10115  _IMP_algebra.DefaultEmbedding6D_swiginit(self, _IMP_algebra.new_DefaultEmbedding6D(*args))
10116 
10117  def set_origin(self, o):
10118  r"""set_origin(DefaultEmbedding6D self, Vector6D o)"""
10119  return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)
10120 
10121  def get_origin(self):
10122  r"""get_origin(DefaultEmbedding6D self) -> Vector6D"""
10123  return _IMP_algebra.DefaultEmbedding6D_get_origin(self)
10124 
10125  def get_dimension(self):
10126  r"""get_dimension(DefaultEmbedding6D self) -> unsigned int"""
10127  return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)
10128 
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)
10132 
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)
10136 
10137  def get_unit_cell(self):
10138  r"""get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10139  return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)
10140 
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)
10144 
10145  def get_index(self, o):
10146  r"""get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
10147  return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)
10148 
10149  def get_center(self, *args):
10150  r"""
10151  get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10152  get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
10153  """
10154  return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)
10155 
10156  def get_bounding_box(self, *args):
10157  r"""
10158  get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10159  get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10160  """
10161  return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)
10162 
10163  def show(self, *args):
10164  r"""show(DefaultEmbedding6D self, _ostream out=std::cout)"""
10165  return _IMP_algebra.DefaultEmbedding6D_show(self, *args)
10166 
10167  def __str__(self):
10168  r"""__str__(DefaultEmbedding6D self) -> std::string"""
10169  return _IMP_algebra.DefaultEmbedding6D___str__(self)
10170 
10171  def __repr__(self):
10172  r"""__repr__(DefaultEmbedding6D self) -> std::string"""
10173  return _IMP_algebra.DefaultEmbedding6D___repr__(self)
10174 
10175  def __cmp__(self, arg2):
10176  r"""__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
10177  return _IMP_algebra.DefaultEmbedding6D___cmp__(self, arg2)
10178 
10179  def __eq__(self, arg2):
10180  r"""__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
10181  return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)
10182 
10183  def _get_as_binary(self):
10184  r"""_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
10185  return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)
10186 
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)
10190 
10191  def __getstate__(self):
10192  p = self._get_as_binary()
10193  if len(self.__dict__) > 1:
10194  d = self.__dict__.copy()
10195  del d['this']
10196  p = (d, p)
10197  return p
10198 
10199  def __setstate__(self, p):
10200  if not hasattr(self, 'this'):
10201  self.__init__()
10202  if isinstance(p, tuple):
10203  d, p = p
10204  self.__dict__.update(d)
10205  return self._set_from_binary(p)
10206 
10207  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
10208 
10209 # Register DefaultEmbedding6D in _IMP_algebra:
10210 _IMP_algebra.DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
10211 class DefaultEmbeddingKD(object):
10212  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< -1 > class."""
10213 
10214  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10215 
10216  def __init__(self, *args):
10217  r"""
10218  __init__(DefaultEmbeddingKD self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
10219  __init__(DefaultEmbeddingKD self) -> DefaultEmbeddingKD
10220  """
10221  _IMP_algebra.DefaultEmbeddingKD_swiginit(self, _IMP_algebra.new_DefaultEmbeddingKD(*args))
10222 
10223  def set_origin(self, o):
10224  r"""set_origin(DefaultEmbeddingKD self, VectorKD o)"""
10225  return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)
10226 
10227  def get_origin(self):
10228  r"""get_origin(DefaultEmbeddingKD self) -> VectorKD"""
10229  return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)
10230 
10231  def get_dimension(self):
10232  r"""get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
10233  return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)
10234 
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)
10238 
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)
10242 
10243  def get_unit_cell(self):
10244  r"""get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10245  return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)
10246 
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)
10250 
10251  def get_index(self, o):
10252  r"""get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
10253  return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)
10254 
10255  def get_center(self, *args):
10256  r"""
10257  get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
10258  get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
10259  """
10260  return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)
10261 
10262  def get_bounding_box(self, *args):
10263  r"""
10264  get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
10265  get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
10266  """
10267  return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)
10268 
10269  def show(self, *args):
10270  r"""show(DefaultEmbeddingKD self, _ostream out=std::cout)"""
10271  return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)
10272 
10273  def __str__(self):
10274  r"""__str__(DefaultEmbeddingKD self) -> std::string"""
10275  return _IMP_algebra.DefaultEmbeddingKD___str__(self)
10276 
10277  def __repr__(self):
10278  r"""__repr__(DefaultEmbeddingKD self) -> std::string"""
10279  return _IMP_algebra.DefaultEmbeddingKD___repr__(self)
10280 
10281  def __cmp__(self, arg2):
10282  r"""__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
10283  return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, arg2)
10284 
10285  def __eq__(self, arg2):
10286  r"""__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
10287  return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)
10288 
10289  def _get_as_binary(self):
10290  r"""_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
10291  return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)
10292 
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)
10296 
10297  def __getstate__(self):
10298  p = self._get_as_binary()
10299  if len(self.__dict__) > 1:
10300  d = self.__dict__.copy()
10301  del d['this']
10302  p = (d, p)
10303  return p
10304 
10305  def __setstate__(self, p):
10306  if not hasattr(self, 'this'):
10307  self.__init__()
10308  if isinstance(p, tuple):
10309  d, p = p
10310  self.__dict__.update(d)
10311  return self._set_from_binary(p)
10312 
10313  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
10314 
10315 # Register DefaultEmbeddingKD in _IMP_algebra:
10316 _IMP_algebra.DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
10317 class LogEmbedding1D(object):
10318  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 1 > class."""
10319 
10320  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10321 
10322  def __init__(self, *args):
10323  r"""
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
10328  """
10329  _IMP_algebra.LogEmbedding1D_swiginit(self, _IMP_algebra.new_LogEmbedding1D(*args))
10330 
10331  def set_origin(self, o):
10332  r"""set_origin(LogEmbedding1D self, Vector1D o)"""
10333  return _IMP_algebra.LogEmbedding1D_set_origin(self, o)
10334 
10335  def get_origin(self):
10336  r"""get_origin(LogEmbedding1D self) -> Vector1D"""
10337  return _IMP_algebra.LogEmbedding1D_get_origin(self)
10338 
10339  def get_dimension(self):
10340  r"""get_dimension(LogEmbedding1D self) -> unsigned int"""
10341  return _IMP_algebra.LogEmbedding1D_get_dimension(self)
10342 
10343  def set_unit_cell(self, *args):
10344  r"""
10345  set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
10346  set_unit_cell(LogEmbedding1D self, Vector1D o)
10347  """
10348  return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)
10349 
10350  def get_unit_cell(self):
10351  r"""get_unit_cell(LogEmbedding1D self) -> Vector1D"""
10352  return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)
10353 
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)
10357 
10358  def get_index(self, o):
10359  r"""get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
10360  return _IMP_algebra.LogEmbedding1D_get_index(self, o)
10361 
10362  def get_center(self, *args):
10363  r"""
10364  get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
10365  get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
10366  """
10367  return _IMP_algebra.LogEmbedding1D_get_center(self, *args)
10368 
10369  def get_bounding_box(self, *args):
10370  r"""
10371  get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
10372  get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
10373  """
10374  return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)
10375 
10376  def show(self, *args):
10377  r"""show(LogEmbedding1D self, _ostream out=std::cout)"""
10378  return _IMP_algebra.LogEmbedding1D_show(self, *args)
10379 
10380  def __str__(self):
10381  r"""__str__(LogEmbedding1D self) -> std::string"""
10382  return _IMP_algebra.LogEmbedding1D___str__(self)
10383 
10384  def __repr__(self):
10385  r"""__repr__(LogEmbedding1D self) -> std::string"""
10386  return _IMP_algebra.LogEmbedding1D___repr__(self)
10387 
10388  def __cmp__(self, arg2):
10389  r"""__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
10390  return _IMP_algebra.LogEmbedding1D___cmp__(self, arg2)
10391 
10392  def __eq__(self, arg2):
10393  r"""__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
10394  return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)
10395 
10396  def _get_as_binary(self):
10397  r"""_get_as_binary(LogEmbedding1D self) -> PyObject *"""
10398  return _IMP_algebra.LogEmbedding1D__get_as_binary(self)
10399 
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)
10403 
10404  def __getstate__(self):
10405  p = self._get_as_binary()
10406  if len(self.__dict__) > 1:
10407  d = self.__dict__.copy()
10408  del d['this']
10409  p = (d, p)
10410  return p
10411 
10412  def __setstate__(self, p):
10413  if not hasattr(self, 'this'):
10414  self.__init__()
10415  if isinstance(p, tuple):
10416  d, p = p
10417  self.__dict__.update(d)
10418  return self._set_from_binary(p)
10419 
10420  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
10421 
10422 # Register LogEmbedding1D in _IMP_algebra:
10423 _IMP_algebra.LogEmbedding1D_swigregister(LogEmbedding1D)
10424 class LogEmbedding2D(object):
10425  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 2 > class."""
10426 
10427  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10428 
10429  def __init__(self, *args):
10430  r"""
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
10435  """
10436  _IMP_algebra.LogEmbedding2D_swiginit(self, _IMP_algebra.new_LogEmbedding2D(*args))
10437 
10438  def set_origin(self, o):
10439  r"""set_origin(LogEmbedding2D self, Vector2D o)"""
10440  return _IMP_algebra.LogEmbedding2D_set_origin(self, o)
10441 
10442  def get_origin(self):
10443  r"""get_origin(LogEmbedding2D self) -> Vector2D"""
10444  return _IMP_algebra.LogEmbedding2D_get_origin(self)
10445 
10446  def get_dimension(self):
10447  r"""get_dimension(LogEmbedding2D self) -> unsigned int"""
10448  return _IMP_algebra.LogEmbedding2D_get_dimension(self)
10449 
10450  def set_unit_cell(self, *args):
10451  r"""
10452  set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
10453  set_unit_cell(LogEmbedding2D self, Vector2D o)
10454  """
10455  return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)
10456 
10457  def get_unit_cell(self):
10458  r"""get_unit_cell(LogEmbedding2D self) -> Vector2D"""
10459  return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)
10460 
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)
10464 
10465  def get_index(self, o):
10466  r"""get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
10467  return _IMP_algebra.LogEmbedding2D_get_index(self, o)
10468 
10469  def get_center(self, *args):
10470  r"""
10471  get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
10472  get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
10473  """
10474  return _IMP_algebra.LogEmbedding2D_get_center(self, *args)
10475 
10476  def get_bounding_box(self, *args):
10477  r"""
10478  get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
10479  get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
10480  """
10481  return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)
10482 
10483  def show(self, *args):
10484  r"""show(LogEmbedding2D self, _ostream out=std::cout)"""
10485  return _IMP_algebra.LogEmbedding2D_show(self, *args)
10486 
10487  def __str__(self):
10488  r"""__str__(LogEmbedding2D self) -> std::string"""
10489  return _IMP_algebra.LogEmbedding2D___str__(self)
10490 
10491  def __repr__(self):
10492  r"""__repr__(LogEmbedding2D self) -> std::string"""
10493  return _IMP_algebra.LogEmbedding2D___repr__(self)
10494 
10495  def __cmp__(self, arg2):
10496  r"""__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
10497  return _IMP_algebra.LogEmbedding2D___cmp__(self, arg2)
10498 
10499  def __eq__(self, arg2):
10500  r"""__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
10501  return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)
10502 
10503  def _get_as_binary(self):
10504  r"""_get_as_binary(LogEmbedding2D self) -> PyObject *"""
10505  return _IMP_algebra.LogEmbedding2D__get_as_binary(self)
10506 
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)
10510 
10511  def __getstate__(self):
10512  p = self._get_as_binary()
10513  if len(self.__dict__) > 1:
10514  d = self.__dict__.copy()
10515  del d['this']
10516  p = (d, p)
10517  return p
10518 
10519  def __setstate__(self, p):
10520  if not hasattr(self, 'this'):
10521  self.__init__()
10522  if isinstance(p, tuple):
10523  d, p = p
10524  self.__dict__.update(d)
10525  return self._set_from_binary(p)
10526 
10527  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
10528 
10529 # Register LogEmbedding2D in _IMP_algebra:
10530 _IMP_algebra.LogEmbedding2D_swigregister(LogEmbedding2D)
10531 class LogEmbedding4D(object):
10532  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 4 > class."""
10533 
10534  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10535 
10536  def __init__(self, *args):
10537  r"""
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
10542  """
10543  _IMP_algebra.LogEmbedding4D_swiginit(self, _IMP_algebra.new_LogEmbedding4D(*args))
10544 
10545  def set_origin(self, o):
10546  r"""set_origin(LogEmbedding4D self, Vector4D o)"""
10547  return _IMP_algebra.LogEmbedding4D_set_origin(self, o)
10548 
10549  def get_origin(self):
10550  r"""get_origin(LogEmbedding4D self) -> Vector4D"""
10551  return _IMP_algebra.LogEmbedding4D_get_origin(self)
10552 
10553  def get_dimension(self):
10554  r"""get_dimension(LogEmbedding4D self) -> unsigned int"""
10555  return _IMP_algebra.LogEmbedding4D_get_dimension(self)
10556 
10557  def set_unit_cell(self, *args):
10558  r"""
10559  set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
10560  set_unit_cell(LogEmbedding4D self, Vector4D o)
10561  """
10562  return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)
10563 
10564  def get_unit_cell(self):
10565  r"""get_unit_cell(LogEmbedding4D self) -> Vector4D"""
10566  return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)
10567 
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)
10571 
10572  def get_index(self, o):
10573  r"""get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
10574  return _IMP_algebra.LogEmbedding4D_get_index(self, o)
10575 
10576  def get_center(self, *args):
10577  r"""
10578  get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
10579  get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
10580  """
10581  return _IMP_algebra.LogEmbedding4D_get_center(self, *args)
10582 
10583  def get_bounding_box(self, *args):
10584  r"""
10585  get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
10586  get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
10587  """
10588  return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)
10589 
10590  def show(self, *args):
10591  r"""show(LogEmbedding4D self, _ostream out=std::cout)"""
10592  return _IMP_algebra.LogEmbedding4D_show(self, *args)
10593 
10594  def __str__(self):
10595  r"""__str__(LogEmbedding4D self) -> std::string"""
10596  return _IMP_algebra.LogEmbedding4D___str__(self)
10597 
10598  def __repr__(self):
10599  r"""__repr__(LogEmbedding4D self) -> std::string"""
10600  return _IMP_algebra.LogEmbedding4D___repr__(self)
10601 
10602  def __cmp__(self, arg2):
10603  r"""__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
10604  return _IMP_algebra.LogEmbedding4D___cmp__(self, arg2)
10605 
10606  def __eq__(self, arg2):
10607  r"""__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
10608  return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)
10609 
10610  def _get_as_binary(self):
10611  r"""_get_as_binary(LogEmbedding4D self) -> PyObject *"""
10612  return _IMP_algebra.LogEmbedding4D__get_as_binary(self)
10613 
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)
10617 
10618  def __getstate__(self):
10619  p = self._get_as_binary()
10620  if len(self.__dict__) > 1:
10621  d = self.__dict__.copy()
10622  del d['this']
10623  p = (d, p)
10624  return p
10625 
10626  def __setstate__(self, p):
10627  if not hasattr(self, 'this'):
10628  self.__init__()
10629  if isinstance(p, tuple):
10630  d, p = p
10631  self.__dict__.update(d)
10632  return self._set_from_binary(p)
10633 
10634  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
10635 
10636 # Register LogEmbedding4D in _IMP_algebra:
10637 _IMP_algebra.LogEmbedding4D_swigregister(LogEmbedding4D)
10638 class LogEmbedding5D(object):
10639  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 5 > class."""
10640 
10641  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10642 
10643  def __init__(self, *args):
10644  r"""
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
10649  """
10650  _IMP_algebra.LogEmbedding5D_swiginit(self, _IMP_algebra.new_LogEmbedding5D(*args))
10651 
10652  def set_origin(self, o):
10653  r"""set_origin(LogEmbedding5D self, Vector5D o)"""
10654  return _IMP_algebra.LogEmbedding5D_set_origin(self, o)
10655 
10656  def get_origin(self):
10657  r"""get_origin(LogEmbedding5D self) -> Vector5D"""
10658  return _IMP_algebra.LogEmbedding5D_get_origin(self)
10659 
10660  def get_dimension(self):
10661  r"""get_dimension(LogEmbedding5D self) -> unsigned int"""
10662  return _IMP_algebra.LogEmbedding5D_get_dimension(self)
10663 
10664  def set_unit_cell(self, *args):
10665  r"""
10666  set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
10667  set_unit_cell(LogEmbedding5D self, Vector5D o)
10668  """
10669  return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)
10670 
10671  def get_unit_cell(self):
10672  r"""get_unit_cell(LogEmbedding5D self) -> Vector5D"""
10673  return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)
10674 
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)
10678 
10679  def get_index(self, o):
10680  r"""get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
10681  return _IMP_algebra.LogEmbedding5D_get_index(self, o)
10682 
10683  def get_center(self, *args):
10684  r"""
10685  get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10686  get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
10687  """
10688  return _IMP_algebra.LogEmbedding5D_get_center(self, *args)
10689 
10690  def get_bounding_box(self, *args):
10691  r"""
10692  get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10693  get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10694  """
10695  return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)
10696 
10697  def show(self, *args):
10698  r"""show(LogEmbedding5D self, _ostream out=std::cout)"""
10699  return _IMP_algebra.LogEmbedding5D_show(self, *args)
10700 
10701  def __str__(self):
10702  r"""__str__(LogEmbedding5D self) -> std::string"""
10703  return _IMP_algebra.LogEmbedding5D___str__(self)
10704 
10705  def __repr__(self):
10706  r"""__repr__(LogEmbedding5D self) -> std::string"""
10707  return _IMP_algebra.LogEmbedding5D___repr__(self)
10708 
10709  def __cmp__(self, arg2):
10710  r"""__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
10711  return _IMP_algebra.LogEmbedding5D___cmp__(self, arg2)
10712 
10713  def __eq__(self, arg2):
10714  r"""__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
10715  return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)
10716 
10717  def _get_as_binary(self):
10718  r"""_get_as_binary(LogEmbedding5D self) -> PyObject *"""
10719  return _IMP_algebra.LogEmbedding5D__get_as_binary(self)
10720 
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)
10724 
10725  def __getstate__(self):
10726  p = self._get_as_binary()
10727  if len(self.__dict__) > 1:
10728  d = self.__dict__.copy()
10729  del d['this']
10730  p = (d, p)
10731  return p
10732 
10733  def __setstate__(self, p):
10734  if not hasattr(self, 'this'):
10735  self.__init__()
10736  if isinstance(p, tuple):
10737  d, p = p
10738  self.__dict__.update(d)
10739  return self._set_from_binary(p)
10740 
10741  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
10742 
10743 # Register LogEmbedding5D in _IMP_algebra:
10744 _IMP_algebra.LogEmbedding5D_swigregister(LogEmbedding5D)
10745 class LogEmbedding6D(object):
10746  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 6 > class."""
10747 
10748  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10749 
10750  def __init__(self, *args):
10751  r"""
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
10756  """
10757  _IMP_algebra.LogEmbedding6D_swiginit(self, _IMP_algebra.new_LogEmbedding6D(*args))
10758 
10759  def set_origin(self, o):
10760  r"""set_origin(LogEmbedding6D self, Vector6D o)"""
10761  return _IMP_algebra.LogEmbedding6D_set_origin(self, o)
10762 
10763  def get_origin(self):
10764  r"""get_origin(LogEmbedding6D self) -> Vector6D"""
10765  return _IMP_algebra.LogEmbedding6D_get_origin(self)
10766 
10767  def get_dimension(self):
10768  r"""get_dimension(LogEmbedding6D self) -> unsigned int"""
10769  return _IMP_algebra.LogEmbedding6D_get_dimension(self)
10770 
10771  def set_unit_cell(self, *args):
10772  r"""
10773  set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
10774  set_unit_cell(LogEmbedding6D self, Vector6D o)
10775  """
10776  return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)
10777 
10778  def get_unit_cell(self):
10779  r"""get_unit_cell(LogEmbedding6D self) -> Vector6D"""
10780  return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)
10781 
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)
10785 
10786  def get_index(self, o):
10787  r"""get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
10788  return _IMP_algebra.LogEmbedding6D_get_index(self, o)
10789 
10790  def get_center(self, *args):
10791  r"""
10792  get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10793  get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
10794  """
10795  return _IMP_algebra.LogEmbedding6D_get_center(self, *args)
10796 
10797  def get_bounding_box(self, *args):
10798  r"""
10799  get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10800  get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10801  """
10802  return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)
10803 
10804  def show(self, *args):
10805  r"""show(LogEmbedding6D self, _ostream out=std::cout)"""
10806  return _IMP_algebra.LogEmbedding6D_show(self, *args)
10807 
10808  def __str__(self):
10809  r"""__str__(LogEmbedding6D self) -> std::string"""
10810  return _IMP_algebra.LogEmbedding6D___str__(self)
10811 
10812  def __repr__(self):
10813  r"""__repr__(LogEmbedding6D self) -> std::string"""
10814  return _IMP_algebra.LogEmbedding6D___repr__(self)
10815 
10816  def __cmp__(self, arg2):
10817  r"""__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
10818  return _IMP_algebra.LogEmbedding6D___cmp__(self, arg2)
10819 
10820  def __eq__(self, arg2):
10821  r"""__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
10822  return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)
10823 
10824  def _get_as_binary(self):
10825  r"""_get_as_binary(LogEmbedding6D self) -> PyObject *"""
10826  return _IMP_algebra.LogEmbedding6D__get_as_binary(self)
10827 
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)
10831 
10832  def __getstate__(self):
10833  p = self._get_as_binary()
10834  if len(self.__dict__) > 1:
10835  d = self.__dict__.copy()
10836  del d['this']
10837  p = (d, p)
10838  return p
10839 
10840  def __setstate__(self, p):
10841  if not hasattr(self, 'this'):
10842  self.__init__()
10843  if isinstance(p, tuple):
10844  d, p = p
10845  self.__dict__.update(d)
10846  return self._set_from_binary(p)
10847 
10848  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
10849 
10850 # Register LogEmbedding6D in _IMP_algebra:
10851 _IMP_algebra.LogEmbedding6D_swigregister(LogEmbedding6D)
10852 class SpherePatch3D(_GeometricPrimitive3D):
10853  r"""Proxy of C++ IMP::algebra::SpherePatch3D class."""
10854 
10855  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10856 
10857  def __init__(self, *args):
10858  r"""
10859  __init__(SpherePatch3D self) -> SpherePatch3D
10860  __init__(SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
10861  """
10862  _IMP_algebra.SpherePatch3D_swiginit(self, _IMP_algebra.new_SpherePatch3D(*args))
10863 
10864  def get_contains(self, p):
10865  r"""get_contains(SpherePatch3D self, Vector3D p) -> bool"""
10866  return _IMP_algebra.SpherePatch3D_get_contains(self, p)
10867 
10868  def get_plane(self):
10869  r"""get_plane(SpherePatch3D self) -> Plane3D"""
10870  return _IMP_algebra.SpherePatch3D_get_plane(self)
10871 
10872  def get_sphere(self):
10873  r"""get_sphere(SpherePatch3D self) -> Sphere3D"""
10874  return _IMP_algebra.SpherePatch3D_get_sphere(self)
10875 
10876  def show(self, *args):
10877  r"""show(SpherePatch3D self, _ostream out=std::cout)"""
10878  return _IMP_algebra.SpherePatch3D_show(self, *args)
10879 
10880  def get_boundary_point(self):
10881  r"""get_boundary_point(SpherePatch3D self) -> Vector3D"""
10882  return _IMP_algebra.SpherePatch3D_get_boundary_point(self)
10883 
10884  def __str__(self):
10885  r"""__str__(SpherePatch3D self) -> std::string"""
10886  return _IMP_algebra.SpherePatch3D___str__(self)
10887 
10888  def __repr__(self):
10889  r"""__repr__(SpherePatch3D self) -> std::string"""
10890  return _IMP_algebra.SpherePatch3D___repr__(self)
10891 
10892  def _get_as_binary(self):
10893  r"""_get_as_binary(SpherePatch3D self) -> PyObject *"""
10894  return _IMP_algebra.SpherePatch3D__get_as_binary(self)
10895 
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)
10899 
10900  def __getstate__(self):
10901  p = self._get_as_binary()
10902  if len(self.__dict__) > 1:
10903  d = self.__dict__.copy()
10904  del d['this']
10905  p = (d, p)
10906  return p
10907 
10908  def __setstate__(self, p):
10909  if not hasattr(self, 'this'):
10910  self.__init__()
10911  if isinstance(p, tuple):
10912  d, p = p
10913  self.__dict__.update(d)
10914  return self._set_from_binary(p)
10915 
10916  __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
10917 
10918 # Register SpherePatch3D in _IMP_algebra:
10919 _IMP_algebra.SpherePatch3D_swigregister(SpherePatch3D)
10920 
10921 def get_area(*args):
10922  r"""
10923  get_area(Plane3D g) -> double
10924  get_area(SpherePatch3D g) -> double
10925  """
10926  return _IMP_algebra.get_area(*args)
10927 
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."""
10933 
10934  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10935 
10936  def __init__(self, *args):
10937  r"""
10938  __init__(Cone3D self) -> Cone3D
10939  __init__(Cone3D self, Segment3D s, double radius) -> Cone3D
10940  """
10941  _IMP_algebra.Cone3D_swiginit(self, _IMP_algebra.new_Cone3D(*args))
10942 
10943  def get_tip(self):
10944  r"""get_tip(Cone3D self) -> Vector3D"""
10945  return _IMP_algebra.Cone3D_get_tip(self)
10946 
10947  def get_direction(self):
10948  r"""get_direction(Cone3D self) -> Vector3D"""
10949  return _IMP_algebra.Cone3D_get_direction(self)
10950 
10951  def get_height(self):
10952  r"""get_height(Cone3D self) -> double"""
10953  return _IMP_algebra.Cone3D_get_height(self)
10954 
10955  def get_angle(self):
10956  r"""get_angle(Cone3D self) -> double"""
10957  return _IMP_algebra.Cone3D_get_angle(self)
10958 
10959  def get_radius(self):
10960  r"""get_radius(Cone3D self) -> double"""
10961  return _IMP_algebra.Cone3D_get_radius(self)
10962 
10963  def get_contains(self, v):
10964  r"""get_contains(Cone3D self, Vector3D v) -> bool"""
10965  return _IMP_algebra.Cone3D_get_contains(self, v)
10966 
10967  def get_base_plane(self):
10968  r"""get_base_plane(Cone3D self) -> Plane3D"""
10969  return _IMP_algebra.Cone3D_get_base_plane(self)
10970 
10971  def show(self, *args):
10972  r"""show(Cone3D self, _ostream out=std::cout)"""
10973  return _IMP_algebra.Cone3D_show(self, *args)
10974 
10975  def __str__(self):
10976  r"""__str__(Cone3D self) -> std::string"""
10977  return _IMP_algebra.Cone3D___str__(self)
10978 
10979  def __repr__(self):
10980  r"""__repr__(Cone3D self) -> std::string"""
10981  return _IMP_algebra.Cone3D___repr__(self)
10982 
10983  def _get_as_binary(self):
10984  r"""_get_as_binary(Cone3D self) -> PyObject *"""
10985  return _IMP_algebra.Cone3D__get_as_binary(self)
10986 
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)
10990 
10991  def __getstate__(self):
10992  p = self._get_as_binary()
10993  if len(self.__dict__) > 1:
10994  d = self.__dict__.copy()
10995  del d['this']
10996  p = (d, p)
10997  return p
10998 
10999  def __setstate__(self, p):
11000  if not hasattr(self, 'this'):
11001  self.__init__()
11002  if isinstance(p, tuple):
11003  d, p = p
11004  self.__dict__.update(d)
11005  return self._set_from_binary(p)
11006 
11007  __swig_destroy__ = _IMP_algebra.delete_Cone3D
11008 
11009 # Register Cone3D in _IMP_algebra:
11010 _IMP_algebra.Cone3D_swigregister(Cone3D)
11011 
11012 def get_surface_area(*args):
11013  r"""
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
11019  """
11020  return _IMP_algebra.get_surface_area(*args)
11021 
11022 def get_volume(*args):
11023  r"""
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
11029  """
11030  return _IMP_algebra.get_volume(*args)
11031 
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)
11035 
11036 def write_pts(vs, out):
11037  r"""write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
11038  return _IMP_algebra.write_pts(vs, out)
11039 
11040 def read_pts(input):
11041  r"""read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
11042  return _IMP_algebra.read_pts(input)
11043 
11044 def write_spheres(vs, out):
11045  r"""write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
11046  return _IMP_algebra.write_spheres(vs, out)
11047 
11048 def read_spheres(input):
11049  r"""read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
11050  return _IMP_algebra.read_spheres(input)
11051 
11053  r"""get_random_vector_on_unit_sphere() -> Vector3D"""
11054  return _IMP_algebra.get_random_vector_on_unit_sphere()
11055 
11056 def get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle):
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)
11059 
11060 def get_random_chain(*args):
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)
11063 
11064 def reversed_read(dest, size, nitems, f, reverse):
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)
11067 
11068 def reversed_write(src, size, nitems, f, reverse=False):
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)
11071 
11072 def get_is_big_endian():
11073  r"""get_is_big_endian() -> bool"""
11074  return _IMP_algebra.get_is_big_endian()
11075 
11076 def get_is_little_endian():
11077  r"""get_is_little_endian() -> bool"""
11078  return _IMP_algebra.get_is_little_endian()
11079 
11080 def get_shortest_segment(*args):
11081  r"""
11082  get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
11083  get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
11084  """
11085  return _IMP_algebra.get_shortest_segment(*args)
11086 class DynamicNearestNeighbor3D(IMP.Object):
11087  r"""Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class."""
11088 
11089  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11090 
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))
11094 
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)
11098 
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)
11102 
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
11107 
11108  def __str__(self):
11109  r"""__str__(DynamicNearestNeighbor3D self) -> std::string"""
11110  return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)
11111 
11112  def __repr__(self):
11113  r"""__repr__(DynamicNearestNeighbor3D self) -> std::string"""
11114  return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)
11115 
11116  @staticmethod
11117  def get_from(o):
11118  return _object_cast_to_DynamicNearestNeighbor3D(o)
11119 
11120 
11121 # Register DynamicNearestNeighbor3D in _IMP_algebra:
11122 _IMP_algebra.DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
11123 class VectorKDMetric(IMP.Object):
11124  r"""Proxy of C++ IMP::algebra::VectorKDMetric class."""
11125 
11126  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11127 
11128  def __init__(self, name):
11129  r"""__init__(VectorKDMetric self, std::string name) -> VectorKDMetric"""
11130  if self.__class__ == VectorKDMetric:
11131  _self = None
11132  else:
11133  _self = self
11134  _IMP_algebra.VectorKDMetric_swiginit(self, _IMP_algebra.new_VectorKDMetric(_self, name))
11135 
11136  if self.__class__ != VectorKDMetric:
11137  _director_objects.register(self)
11138 
11139 
11140 
11141 
11142  def get_distance(self, a, b):
11143  r"""get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
11144  return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)
11145 
11146  def get_centroid(self, vs):
11147  r"""get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
11148  return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)
11149 
11150  def __str__(self):
11151  r"""__str__(VectorKDMetric self) -> std::string"""
11152  return _IMP_algebra.VectorKDMetric___str__(self)
11153 
11154  def __repr__(self):
11155  r"""__repr__(VectorKDMetric self) -> std::string"""
11156  return _IMP_algebra.VectorKDMetric___repr__(self)
11157 
11158  @staticmethod
11159  def get_from(o):
11160  return _object_cast_to_VectorKDMetric(o)
11161 
11162 
11163  def get_type_name(self):
11164  return self.__class__.__name__
11165  def do_show(self, out):
11166  pass
11167  def get_version_info(self):
11168  if"IMP::algebra" == "IMP":
11169  return VersionInfo(self.__module__,
11170  __import__(self.__module__).get_module_version())
11171  else:
11172  return IMP.VersionInfo(self.__module__,
11173  __import__(self.__module__).get_module_version())
11174  @staticmethod
11175  def get_from(o):
11176  return _object_cast_to_VectorKDMetric(o)
11177 
11178  __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
11179  def __disown__(self):
11180  self.this.disown()
11181  _IMP_algebra.disown_VectorKDMetric(self)
11182  return weakref.proxy(self)
11183 
11184  def do_destroy(self):
11185  r"""do_destroy(VectorKDMetric self)"""
11186  return _IMP_algebra.VectorKDMetric_do_destroy(self)
11187 
11188 # Register VectorKDMetric in _IMP_algebra:
11189 _IMP_algebra.VectorKDMetric_swigregister(VectorKDMetric)
11190 class EuclideanVectorKDMetric(VectorKDMetric):
11191  r"""Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class."""
11192 
11193  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11194 
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))
11198 
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
11203 
11204  def __str__(self):
11205  r"""__str__(EuclideanVectorKDMetric self) -> std::string"""
11206  return _IMP_algebra.EuclideanVectorKDMetric___str__(self)
11207 
11208  def __repr__(self):
11209  r"""__repr__(EuclideanVectorKDMetric self) -> std::string"""
11210  return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)
11211 
11212  @staticmethod
11213  def get_from(o):
11214  return _object_cast_to_EuclideanVectorKDMetric(o)
11215 
11216 
11217  def _get_as_binary(self):
11218  r"""_get_as_binary(EuclideanVectorKDMetric self) -> PyObject *"""
11219  return _IMP_algebra.EuclideanVectorKDMetric__get_as_binary(self)
11220 
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)
11224 
11225  def __getstate__(self):
11226  p = self._get_as_binary()
11227  if len(self.__dict__) > 1:
11228  d = self.__dict__.copy()
11229  del d['this']
11230  p = (d, p)
11231  return p
11232 
11233  def __setstate__(self, p):
11234  if not hasattr(self, 'this'):
11235  self.__init__()
11236  if isinstance(p, tuple):
11237  d, p = p
11238  self.__dict__.update(d)
11239  return self._set_from_binary(p)
11240 
11241 
11242 # Register EuclideanVectorKDMetric in _IMP_algebra:
11243 _IMP_algebra.EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
11244 class MaxVectorKDMetric(VectorKDMetric):
11245  r"""Proxy of C++ IMP::algebra::MaxVectorKDMetric class."""
11246 
11247  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11248 
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))
11252 
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
11257 
11258  def __str__(self):
11259  r"""__str__(MaxVectorKDMetric self) -> std::string"""
11260  return _IMP_algebra.MaxVectorKDMetric___str__(self)
11261 
11262  def __repr__(self):
11263  r"""__repr__(MaxVectorKDMetric self) -> std::string"""
11264  return _IMP_algebra.MaxVectorKDMetric___repr__(self)
11265 
11266  @staticmethod
11267  def get_from(o):
11268  return _object_cast_to_MaxVectorKDMetric(o)
11269 
11270 
11271  def _get_as_binary(self):
11272  r"""_get_as_binary(MaxVectorKDMetric self) -> PyObject *"""
11273  return _IMP_algebra.MaxVectorKDMetric__get_as_binary(self)
11274 
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)
11278 
11279  def __getstate__(self):
11280  p = self._get_as_binary()
11281  if len(self.__dict__) > 1:
11282  d = self.__dict__.copy()
11283  del d['this']
11284  p = (d, p)
11285  return p
11286 
11287  def __setstate__(self, p):
11288  if not hasattr(self, 'this'):
11289  self.__init__()
11290  if isinstance(p, tuple):
11291  d, p = p
11292  self.__dict__.update(d)
11293  return self._set_from_binary(p)
11294 
11295 
11296 # Register MaxVectorKDMetric in _IMP_algebra:
11297 _IMP_algebra.MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
11298 class Gaussian3D(_GeometricPrimitive3D):
11299  r"""Proxy of C++ IMP::algebra::Gaussian3D class."""
11300 
11301  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11302 
11303  def __init__(self, *args):
11304  r"""
11305  __init__(Gaussian3D self) -> Gaussian3D
11306  __init__(Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
11307  """
11308  _IMP_algebra.Gaussian3D_swiginit(self, _IMP_algebra.new_Gaussian3D(*args))
11309 
11310  def get_reference_frame(self):
11311  r"""get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
11312  return _IMP_algebra.Gaussian3D_get_reference_frame(self)
11313 
11314  def get_variances(self):
11315  r"""get_variances(Gaussian3D self) -> Vector3D"""
11316  return _IMP_algebra.Gaussian3D_get_variances(self)
11317 
11318  def get_center(self):
11319  r"""get_center(Gaussian3D self) -> Vector3D"""
11320  return _IMP_algebra.Gaussian3D_get_center(self)
11321 
11322  def show(self, *args):
11323  r"""show(Gaussian3D self, _ostream out=std::cout)"""
11324  return _IMP_algebra.Gaussian3D_show(self, *args)
11325 
11326  def __str__(self):
11327  r"""__str__(Gaussian3D self) -> std::string"""
11328  return _IMP_algebra.Gaussian3D___str__(self)
11329 
11330  def __repr__(self):
11331  r"""__repr__(Gaussian3D self) -> std::string"""
11332  return _IMP_algebra.Gaussian3D___repr__(self)
11333 
11334  def _get_as_binary(self):
11335  r"""_get_as_binary(Gaussian3D self) -> PyObject *"""
11336  return _IMP_algebra.Gaussian3D__get_as_binary(self)
11337 
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)
11341 
11342  def __getstate__(self):
11343  p = self._get_as_binary()
11344  if len(self.__dict__) > 1:
11345  d = self.__dict__.copy()
11346  del d['this']
11347  p = (d, p)
11348  return p
11349 
11350  def __setstate__(self, p):
11351  if not hasattr(self, 'this'):
11352  self.__init__()
11353  if isinstance(p, tuple):
11354  d, p = p
11355  self.__dict__.update(d)
11356  return self._set_from_binary(p)
11357 
11358  __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
11359 
11360 # Register Gaussian3D in _IMP_algebra:
11361 _IMP_algebra.Gaussian3D_swigregister(Gaussian3D)
11362 
11363 def get_covariance(g):
11364  r"""get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
11365  return _IMP_algebra.get_covariance(g)
11366 
11367 def get_gaussian_from_covariance(covariance, center):
11368  r"""get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
11369  return _IMP_algebra.get_gaussian_from_covariance(covariance, center)
11370 
11371 def get_rasterized(gmm, weights, cell_width, bb):
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)
11374 
11375 def get_rasterized_fast(gmm, weights, cell_width, bb, factor=2.5):
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)
11378 
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)
11382 
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)
11386 
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)
11390 
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)
11394 
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)
11398 class NearestNeighbor1D(IMP.Object):
11399  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 1 > class."""
11400 
11401  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11402 
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))
11406 
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)
11410 
11411  def get_nearest_neighbor(self, *args):
11412  r"""
11413  get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
11414  get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
11415  """
11416  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)
11417 
11418  def get_nearest_neighbors(self, *args):
11419  r"""
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
11422  """
11423  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)
11424 
11425  def get_in_ball(self, *args):
11426  r"""
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
11429  """
11430  return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)
11431 
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
11436 
11437  def __str__(self):
11438  r"""__str__(NearestNeighbor1D self) -> std::string"""
11439  return _IMP_algebra.NearestNeighbor1D___str__(self)
11440 
11441  def __repr__(self):
11442  r"""__repr__(NearestNeighbor1D self) -> std::string"""
11443  return _IMP_algebra.NearestNeighbor1D___repr__(self)
11444 
11445  @staticmethod
11446  def get_from(o):
11447  return _object_cast_to_NearestNeighborD(o)
11448 
11449 
11450 # Register NearestNeighbor1D in _IMP_algebra:
11451 _IMP_algebra.NearestNeighbor1D_swigregister(NearestNeighbor1D)
11452 class NearestNeighbor2D(IMP.Object):
11453  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 2 > class."""
11454 
11455  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11456 
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))
11460 
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)
11464 
11465  def get_nearest_neighbor(self, *args):
11466  r"""
11467  get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
11468  get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
11469  """
11470  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)
11471 
11472  def get_nearest_neighbors(self, *args):
11473  r"""
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
11476  """
11477  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)
11478 
11479  def get_in_ball(self, *args):
11480  r"""
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
11483  """
11484  return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)
11485 
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
11490 
11491  def __str__(self):
11492  r"""__str__(NearestNeighbor2D self) -> std::string"""
11493  return _IMP_algebra.NearestNeighbor2D___str__(self)
11494 
11495  def __repr__(self):
11496  r"""__repr__(NearestNeighbor2D self) -> std::string"""
11497  return _IMP_algebra.NearestNeighbor2D___repr__(self)
11498 
11499  @staticmethod
11500  def get_from(o):
11501  return _object_cast_to_NearestNeighborD(o)
11502 
11503 
11504 # Register NearestNeighbor2D in _IMP_algebra:
11505 _IMP_algebra.NearestNeighbor2D_swigregister(NearestNeighbor2D)
11506 class NearestNeighbor3D(IMP.Object):
11507  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 3 > class."""
11508 
11509  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11510 
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))
11514 
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)
11518 
11519  def get_nearest_neighbor(self, *args):
11520  r"""
11521  get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
11522  get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
11523  """
11524  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)
11525 
11526  def get_nearest_neighbors(self, *args):
11527  r"""
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
11530  """
11531  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)
11532 
11533  def get_in_ball(self, *args):
11534  r"""
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
11537  """
11538  return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)
11539 
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
11544 
11545  def __str__(self):
11546  r"""__str__(NearestNeighbor3D self) -> std::string"""
11547  return _IMP_algebra.NearestNeighbor3D___str__(self)
11548 
11549  def __repr__(self):
11550  r"""__repr__(NearestNeighbor3D self) -> std::string"""
11551  return _IMP_algebra.NearestNeighbor3D___repr__(self)
11552 
11553  @staticmethod
11554  def get_from(o):
11555  return _object_cast_to_NearestNeighborD(o)
11556 
11557 
11558 # Register NearestNeighbor3D in _IMP_algebra:
11559 _IMP_algebra.NearestNeighbor3D_swigregister(NearestNeighbor3D)
11560 class NearestNeighbor4D(IMP.Object):
11561  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 4 > class."""
11562 
11563  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11564 
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))
11568 
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)
11572 
11573  def get_nearest_neighbor(self, *args):
11574  r"""
11575  get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
11576  get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
11577  """
11578  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)
11579 
11580  def get_nearest_neighbors(self, *args):
11581  r"""
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
11584  """
11585  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)
11586 
11587  def get_in_ball(self, *args):
11588  r"""
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
11591  """
11592  return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)
11593 
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
11598 
11599  def __str__(self):
11600  r"""__str__(NearestNeighbor4D self) -> std::string"""
11601  return _IMP_algebra.NearestNeighbor4D___str__(self)
11602 
11603  def __repr__(self):
11604  r"""__repr__(NearestNeighbor4D self) -> std::string"""
11605  return _IMP_algebra.NearestNeighbor4D___repr__(self)
11606 
11607  @staticmethod
11608  def get_from(o):
11609  return _object_cast_to_NearestNeighborD(o)
11610 
11611 
11612 # Register NearestNeighbor4D in _IMP_algebra:
11613 _IMP_algebra.NearestNeighbor4D_swigregister(NearestNeighbor4D)
11614 class NearestNeighbor5D(IMP.Object):
11615  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 5 > class."""
11616 
11617  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11618 
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))
11622 
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)
11626 
11627  def get_nearest_neighbor(self, *args):
11628  r"""
11629  get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
11630  get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
11631  """
11632  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)
11633 
11634  def get_nearest_neighbors(self, *args):
11635  r"""
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
11638  """
11639  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)
11640 
11641  def get_in_ball(self, *args):
11642  r"""
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
11645  """
11646  return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)
11647 
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
11652 
11653  def __str__(self):
11654  r"""__str__(NearestNeighbor5D self) -> std::string"""
11655  return _IMP_algebra.NearestNeighbor5D___str__(self)
11656 
11657  def __repr__(self):
11658  r"""__repr__(NearestNeighbor5D self) -> std::string"""
11659  return _IMP_algebra.NearestNeighbor5D___repr__(self)
11660 
11661  @staticmethod
11662  def get_from(o):
11663  return _object_cast_to_NearestNeighborD(o)
11664 
11665 
11666 # Register NearestNeighbor5D in _IMP_algebra:
11667 _IMP_algebra.NearestNeighbor5D_swigregister(NearestNeighbor5D)
11668 class NearestNeighbor6D(IMP.Object):
11669  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 6 > class."""
11670 
11671  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11672 
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))
11676 
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)
11680 
11681  def get_nearest_neighbor(self, *args):
11682  r"""
11683  get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
11684  get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
11685  """
11686  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)
11687 
11688  def get_nearest_neighbors(self, *args):
11689  r"""
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
11692  """
11693  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)
11694 
11695  def get_in_ball(self, *args):
11696  r"""
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
11699  """
11700  return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)
11701 
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
11706 
11707  def __str__(self):
11708  r"""__str__(NearestNeighbor6D self) -> std::string"""
11709  return _IMP_algebra.NearestNeighbor6D___str__(self)
11710 
11711  def __repr__(self):
11712  r"""__repr__(NearestNeighbor6D self) -> std::string"""
11713  return _IMP_algebra.NearestNeighbor6D___repr__(self)
11714 
11715  @staticmethod
11716  def get_from(o):
11717  return _object_cast_to_NearestNeighborD(o)
11718 
11719 
11720 # Register NearestNeighbor6D in _IMP_algebra:
11721 _IMP_algebra.NearestNeighbor6D_swigregister(NearestNeighbor6D)
11722 class NearestNeighborKD(IMP.Object):
11723  r"""Proxy of C++ IMP::algebra::NearestNeighborD< -1 > class."""
11724 
11725  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11726 
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))
11730 
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)
11734 
11735  def get_nearest_neighbor(self, *args):
11736  r"""
11737  get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
11738  get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
11739  """
11740  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)
11741 
11742  def get_nearest_neighbors(self, *args):
11743  r"""
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
11746  """
11747  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)
11748 
11749  def get_in_ball(self, *args):
11750  r"""
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
11753  """
11754  return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)
11755 
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
11760 
11761  def __str__(self):
11762  r"""__str__(NearestNeighborKD self) -> std::string"""
11763  return _IMP_algebra.NearestNeighborKD___str__(self)
11764 
11765  def __repr__(self):
11766  r"""__repr__(NearestNeighborKD self) -> std::string"""
11767  return _IMP_algebra.NearestNeighborKD___repr__(self)
11768 
11769  @staticmethod
11770  def get_from(o):
11771  return _object_cast_to_NearestNeighborD(o)
11772 
11773 
11774 # Register NearestNeighborKD in _IMP_algebra:
11775 _IMP_algebra.NearestNeighborKD_swigregister(NearestNeighborKD)
11776 
11777 def get_transformation_aligning_pair(set_from, set_to):
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."""
11782 
11783  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11784 
11785  def __init__(self, *args):
11786  r"""
11787  __init__(PrincipalComponentAnalysis1D self) -> PrincipalComponentAnalysis1D
11788  __init__(PrincipalComponentAnalysis1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
11789  """
11790  _IMP_algebra.PrincipalComponentAnalysis1D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis1D(*args))
11791 
11792  def get_principal_components(self):
11793  r"""get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
11794  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)
11795 
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)
11799 
11800  def get_principal_values(self):
11801  r"""get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
11802  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)
11803 
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)
11807 
11808  def get_centroid(self):
11809  r"""get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
11810  return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)
11811 
11812  def set_centroid(self, cntr):
11813  r"""set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
11814  return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)
11815 
11816  def show(self, *args):
11817  r"""show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)"""
11818  return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)
11819 
11820  def __cmp__(self, o):
11821  r"""__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
11822  return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, o)
11823 
11824  def __eq__(self, o):
11825  r"""__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11826  return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)
11827 
11828  def __ne__(self, o):
11829  r"""__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11830  return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)
11831 
11832  def __lt__(self, o):
11833  r"""__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11834  return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)
11835 
11836  def __gt__(self, o):
11837  r"""__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11838  return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)
11839 
11840  def __ge__(self, o):
11841  r"""__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11842  return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)
11843 
11844  def __le__(self, o):
11845  r"""__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11846  return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)
11847 
11848  def __str__(self):
11849  r"""__str__(PrincipalComponentAnalysis1D self) -> std::string"""
11850  return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)
11851 
11852  def __repr__(self):
11853  r"""__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
11854  return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)
11855 
11856  def _get_as_binary(self):
11857  r"""_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
11858  return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)
11859 
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)
11863 
11864  def __getstate__(self):
11865  p = self._get_as_binary()
11866  if len(self.__dict__) > 1:
11867  d = self.__dict__.copy()
11868  del d['this']
11869  p = (d, p)
11870  return p
11871 
11872  def __setstate__(self, p):
11873  if not hasattr(self, 'this'):
11874  self.__init__()
11875  if isinstance(p, tuple):
11876  d, p = p
11877  self.__dict__.update(d)
11878  return self._set_from_binary(p)
11879 
11880  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
11881 
11882 # Register PrincipalComponentAnalysis1D in _IMP_algebra:
11883 _IMP_algebra.PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
11884 class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
11885  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 2 > class."""
11886 
11887  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11888 
11889  def __init__(self, *args):
11890  r"""
11891  __init__(PrincipalComponentAnalysis2D self) -> PrincipalComponentAnalysis2D
11892  __init__(PrincipalComponentAnalysis2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
11893  """
11894  _IMP_algebra.PrincipalComponentAnalysis2D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis2D(*args))
11895 
11896  def get_principal_components(self):
11897  r"""get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
11898  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)
11899 
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)
11903 
11904  def get_principal_values(self):
11905  r"""get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
11906  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)
11907 
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)
11911 
11912  def get_centroid(self):
11913  r"""get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
11914  return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)
11915 
11916  def set_centroid(self, cntr):
11917  r"""set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
11918  return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)
11919 
11920  def show(self, *args):
11921  r"""show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)"""
11922  return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)
11923 
11924  def __cmp__(self, o):
11925  r"""__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
11926  return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, o)
11927 
11928  def __eq__(self, o):
11929  r"""__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11930  return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)
11931 
11932  def __ne__(self, o):
11933  r"""__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11934  return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)
11935 
11936  def __lt__(self, o):
11937  r"""__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11938  return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)
11939 
11940  def __gt__(self, o):
11941  r"""__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11942  return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)
11943 
11944  def __ge__(self, o):
11945  r"""__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11946  return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)
11947 
11948  def __le__(self, o):
11949  r"""__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11950  return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)
11951 
11952  def __str__(self):
11953  r"""__str__(PrincipalComponentAnalysis2D self) -> std::string"""
11954  return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)
11955 
11956  def __repr__(self):
11957  r"""__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
11958  return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)
11959 
11960  def _get_as_binary(self):
11961  r"""_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
11962  return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)
11963 
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)
11967 
11968  def __getstate__(self):
11969  p = self._get_as_binary()
11970  if len(self.__dict__) > 1:
11971  d = self.__dict__.copy()
11972  del d['this']
11973  p = (d, p)
11974  return p
11975 
11976  def __setstate__(self, p):
11977  if not hasattr(self, 'this'):
11978  self.__init__()
11979  if isinstance(p, tuple):
11980  d, p = p
11981  self.__dict__.update(d)
11982  return self._set_from_binary(p)
11983 
11984  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
11985 
11986 # Register PrincipalComponentAnalysis2D in _IMP_algebra:
11987 _IMP_algebra.PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
11988 class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
11989  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 3 > class."""
11990 
11991  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11992 
11993  def __init__(self, *args):
11994  r"""
11995  __init__(PrincipalComponentAnalysis3D self) -> PrincipalComponentAnalysis3D
11996  __init__(PrincipalComponentAnalysis3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
11997  """
11998  _IMP_algebra.PrincipalComponentAnalysis3D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis3D(*args))
11999 
12000  def get_principal_components(self):
12001  r"""get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
12002  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)
12003 
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)
12007 
12008  def get_principal_values(self):
12009  r"""get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
12010  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)
12011 
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)
12015 
12016  def get_centroid(self):
12017  r"""get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
12018  return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)
12019 
12020  def set_centroid(self, cntr):
12021  r"""set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
12022  return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)
12023 
12024  def show(self, *args):
12025  r"""show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)"""
12026  return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)
12027 
12028  def __cmp__(self, o):
12029  r"""__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
12030  return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, o)
12031 
12032  def __eq__(self, o):
12033  r"""__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12034  return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)
12035 
12036  def __ne__(self, o):
12037  r"""__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12038  return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)
12039 
12040  def __lt__(self, o):
12041  r"""__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12042  return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)
12043 
12044  def __gt__(self, o):
12045  r"""__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12046  return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)
12047 
12048  def __ge__(self, o):
12049  r"""__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12050  return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)
12051 
12052  def __le__(self, o):
12053  r"""__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12054  return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)
12055 
12056  def __str__(self):
12057  r"""__str__(PrincipalComponentAnalysis3D self) -> std::string"""
12058  return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)
12059 
12060  def __repr__(self):
12061  r"""__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
12062  return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)
12063 
12064  def _get_as_binary(self):
12065  r"""_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
12066  return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)
12067 
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)
12071 
12072  def __getstate__(self):
12073  p = self._get_as_binary()
12074  if len(self.__dict__) > 1:
12075  d = self.__dict__.copy()
12076  del d['this']
12077  p = (d, p)
12078  return p
12079 
12080  def __setstate__(self, p):
12081  if not hasattr(self, 'this'):
12082  self.__init__()
12083  if isinstance(p, tuple):
12084  d, p = p
12085  self.__dict__.update(d)
12086  return self._set_from_binary(p)
12087 
12088  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
12089 
12090 # Register PrincipalComponentAnalysis3D in _IMP_algebra:
12091 _IMP_algebra.PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
12092 class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
12093  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 4 > class."""
12094 
12095  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12096 
12097  def __init__(self, *args):
12098  r"""
12099  __init__(PrincipalComponentAnalysis4D self) -> PrincipalComponentAnalysis4D
12100  __init__(PrincipalComponentAnalysis4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
12101  """
12102  _IMP_algebra.PrincipalComponentAnalysis4D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis4D(*args))
12103 
12104  def get_principal_components(self):
12105  r"""get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
12106  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)
12107 
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)
12111 
12112  def get_principal_values(self):
12113  r"""get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
12114  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)
12115 
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)
12119 
12120  def get_centroid(self):
12121  r"""get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
12122  return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)
12123 
12124  def set_centroid(self, cntr):
12125  r"""set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
12126  return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)
12127 
12128  def show(self, *args):
12129  r"""show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)"""
12130  return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)
12131 
12132  def __cmp__(self, o):
12133  r"""__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
12134  return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, o)
12135 
12136  def __eq__(self, o):
12137  r"""__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12138  return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)
12139 
12140  def __ne__(self, o):
12141  r"""__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12142  return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)
12143 
12144  def __lt__(self, o):
12145  r"""__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12146  return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)
12147 
12148  def __gt__(self, o):
12149  r"""__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12150  return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)
12151 
12152  def __ge__(self, o):
12153  r"""__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12154  return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)
12155 
12156  def __le__(self, o):
12157  r"""__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12158  return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)
12159 
12160  def __str__(self):
12161  r"""__str__(PrincipalComponentAnalysis4D self) -> std::string"""
12162  return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)
12163 
12164  def __repr__(self):
12165  r"""__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
12166  return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)
12167 
12168  def _get_as_binary(self):
12169  r"""_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
12170  return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)
12171 
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)
12175 
12176  def __getstate__(self):
12177  p = self._get_as_binary()
12178  if len(self.__dict__) > 1:
12179  d = self.__dict__.copy()
12180  del d['this']
12181  p = (d, p)
12182  return p
12183 
12184  def __setstate__(self, p):
12185  if not hasattr(self, 'this'):
12186  self.__init__()
12187  if isinstance(p, tuple):
12188  d, p = p
12189  self.__dict__.update(d)
12190  return self._set_from_binary(p)
12191 
12192  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
12193 
12194 # Register PrincipalComponentAnalysis4D in _IMP_algebra:
12195 _IMP_algebra.PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
12196 class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
12197  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 5 > class."""
12198 
12199  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12200 
12201  def __init__(self, *args):
12202  r"""
12203  __init__(PrincipalComponentAnalysis5D self) -> PrincipalComponentAnalysis5D
12204  __init__(PrincipalComponentAnalysis5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
12205  """
12206  _IMP_algebra.PrincipalComponentAnalysis5D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis5D(*args))
12207 
12208  def get_principal_components(self):
12209  r"""get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
12210  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)
12211 
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)
12215 
12216  def get_principal_values(self):
12217  r"""get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
12218  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)
12219 
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)
12223 
12224  def get_centroid(self):
12225  r"""get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
12226  return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)
12227 
12228  def set_centroid(self, cntr):
12229  r"""set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
12230  return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)
12231 
12232  def show(self, *args):
12233  r"""show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)"""
12234  return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)
12235 
12236  def __cmp__(self, o):
12237  r"""__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
12238  return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, o)
12239 
12240  def __eq__(self, o):
12241  r"""__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12242  return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)
12243 
12244  def __ne__(self, o):
12245  r"""__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12246  return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)
12247 
12248  def __lt__(self, o):
12249  r"""__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12250  return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)
12251 
12252  def __gt__(self, o):
12253  r"""__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12254  return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)
12255 
12256  def __ge__(self, o):
12257  r"""__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12258  return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)
12259 
12260  def __le__(self, o):
12261  r"""__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12262  return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)
12263 
12264  def __str__(self):
12265  r"""__str__(PrincipalComponentAnalysis5D self) -> std::string"""
12266  return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)
12267 
12268  def __repr__(self):
12269  r"""__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
12270  return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)
12271 
12272  def _get_as_binary(self):
12273  r"""_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
12274  return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)
12275 
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)
12279 
12280  def __getstate__(self):
12281  p = self._get_as_binary()
12282  if len(self.__dict__) > 1:
12283  d = self.__dict__.copy()
12284  del d['this']
12285  p = (d, p)
12286  return p
12287 
12288  def __setstate__(self, p):
12289  if not hasattr(self, 'this'):
12290  self.__init__()
12291  if isinstance(p, tuple):
12292  d, p = p
12293  self.__dict__.update(d)
12294  return self._set_from_binary(p)
12295 
12296  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
12297 
12298 # Register PrincipalComponentAnalysis5D in _IMP_algebra:
12299 _IMP_algebra.PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
12300 class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
12301  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 6 > class."""
12302 
12303  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12304 
12305  def __init__(self, *args):
12306  r"""
12307  __init__(PrincipalComponentAnalysis6D self) -> PrincipalComponentAnalysis6D
12308  __init__(PrincipalComponentAnalysis6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
12309  """
12310  _IMP_algebra.PrincipalComponentAnalysis6D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis6D(*args))
12311 
12312  def get_principal_components(self):
12313  r"""get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
12314  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)
12315 
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)
12319 
12320  def get_principal_values(self):
12321  r"""get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
12322  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)
12323 
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)
12327 
12328  def get_centroid(self):
12329  r"""get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
12330  return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)
12331 
12332  def set_centroid(self, cntr):
12333  r"""set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
12334  return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)
12335 
12336  def show(self, *args):
12337  r"""show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)"""
12338  return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)
12339 
12340  def __cmp__(self, o):
12341  r"""__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
12342  return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, o)
12343 
12344  def __eq__(self, o):
12345  r"""__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12346  return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)
12347 
12348  def __ne__(self, o):
12349  r"""__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12350  return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)
12351 
12352  def __lt__(self, o):
12353  r"""__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12354  return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)
12355 
12356  def __gt__(self, o):
12357  r"""__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12358  return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)
12359 
12360  def __ge__(self, o):
12361  r"""__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12362  return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)
12363 
12364  def __le__(self, o):
12365  r"""__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12366  return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)
12367 
12368  def __str__(self):
12369  r"""__str__(PrincipalComponentAnalysis6D self) -> std::string"""
12370  return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)
12371 
12372  def __repr__(self):
12373  r"""__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
12374  return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)
12375 
12376  def _get_as_binary(self):
12377  r"""_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
12378  return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)
12379 
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)
12383 
12384  def __getstate__(self):
12385  p = self._get_as_binary()
12386  if len(self.__dict__) > 1:
12387  d = self.__dict__.copy()
12388  del d['this']
12389  p = (d, p)
12390  return p
12391 
12392  def __setstate__(self, p):
12393  if not hasattr(self, 'this'):
12394  self.__init__()
12395  if isinstance(p, tuple):
12396  d, p = p
12397  self.__dict__.update(d)
12398  return self._set_from_binary(p)
12399 
12400  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
12401 
12402 # Register PrincipalComponentAnalysis6D in _IMP_algebra:
12403 _IMP_algebra.PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
12404 class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
12405  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< -1 > class."""
12406 
12407  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12408 
12409  def __init__(self, *args):
12410  r"""
12411  __init__(PrincipalComponentAnalysisKD self) -> PrincipalComponentAnalysisKD
12412  __init__(PrincipalComponentAnalysisKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
12413  """
12414  _IMP_algebra.PrincipalComponentAnalysisKD_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysisKD(*args))
12415 
12416  def get_principal_components(self):
12417  r"""get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
12418  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)
12419 
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)
12423 
12424  def get_principal_values(self):
12425  r"""get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
12426  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)
12427 
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)
12431 
12432  def get_centroid(self):
12433  r"""get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
12434  return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)
12435 
12436  def set_centroid(self, cntr):
12437  r"""set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
12438  return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)
12439 
12440  def show(self, *args):
12441  r"""show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)"""
12442  return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)
12443 
12444  def __cmp__(self, o):
12445  r"""__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
12446  return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, o)
12447 
12448  def __eq__(self, o):
12449  r"""__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12450  return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)
12451 
12452  def __ne__(self, o):
12453  r"""__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12454  return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)
12455 
12456  def __lt__(self, o):
12457  r"""__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12458  return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)
12459 
12460  def __gt__(self, o):
12461  r"""__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12462  return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)
12463 
12464  def __ge__(self, o):
12465  r"""__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12466  return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)
12467 
12468  def __le__(self, o):
12469  r"""__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12470  return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)
12471 
12472  def __str__(self):
12473  r"""__str__(PrincipalComponentAnalysisKD self) -> std::string"""
12474  return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)
12475 
12476  def __repr__(self):
12477  r"""__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
12478  return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)
12479 
12480  def _get_as_binary(self):
12481  r"""_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
12482  return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)
12483 
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)
12487 
12488  def __getstate__(self):
12489  p = self._get_as_binary()
12490  if len(self.__dict__) > 1:
12491  d = self.__dict__.copy()
12492  del d['this']
12493  p = (d, p)
12494  return p
12495 
12496  def __setstate__(self, p):
12497  if not hasattr(self, 'this'):
12498  self.__init__()
12499  if isinstance(p, tuple):
12500  d, p = p
12501  self.__dict__.update(d)
12502  return self._set_from_binary(p)
12503 
12504  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
12505 
12506 # Register PrincipalComponentAnalysisKD in _IMP_algebra:
12507 _IMP_algebra.PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)
12508 
12509 def get_principal_components(*args):
12510  r"""
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
12518  """
12519  return _IMP_algebra.get_principal_components(*args)
12520 
12521 def get_distance(*args):
12522  r"""
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
12543  """
12544  return _IMP_algebra.get_distance(*args)
12545 
12546 def get_squared_distance(*args):
12547  r"""
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
12555  """
12556  return _IMP_algebra.get_squared_distance(*args)
12557 
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)
12561 
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)
12565 
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)
12569 
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)
12573 
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)
12577 
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)
12581 
12582 def get_zero_vector_1d():
12583  r"""get_zero_vector_1d() -> Vector1D"""
12584  return _IMP_algebra.get_zero_vector_1d()
12585 
12586 def get_zero_vector_2d():
12587  r"""get_zero_vector_2d() -> Vector2D"""
12588  return _IMP_algebra.get_zero_vector_2d()
12589 
12590 def get_zero_vector_3d():
12591  r"""get_zero_vector_3d() -> Vector3D"""
12592  return _IMP_algebra.get_zero_vector_3d()
12593 
12594 def get_zero_vector_4d():
12595  r"""get_zero_vector_4d() -> Vector4D"""
12596  return _IMP_algebra.get_zero_vector_4d()
12597 
12598 def get_zero_vector_5d():
12599  r"""get_zero_vector_5d() -> Vector5D"""
12600  return _IMP_algebra.get_zero_vector_5d()
12601 
12602 def get_zero_vector_6d():
12603  r"""get_zero_vector_6d() -> Vector6D"""
12604  return _IMP_algebra.get_zero_vector_6d()
12605 
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)
12609 
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)
12613 
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)
12617 
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)
12621 
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)
12625 
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)
12629 
12630 def get_unit_bounding_box_1d():
12631  r"""get_unit_bounding_box_1d() -> BoundingBox1D"""
12632  return _IMP_algebra.get_unit_bounding_box_1d()
12633 
12634 def get_unit_bounding_box_2d():
12635  r"""get_unit_bounding_box_2d() -> BoundingBox2D"""
12636  return _IMP_algebra.get_unit_bounding_box_2d()
12637 
12638 def get_unit_bounding_box_3d():
12639  r"""get_unit_bounding_box_3d() -> BoundingBox3D"""
12640  return _IMP_algebra.get_unit_bounding_box_3d()
12641 
12642 def get_unit_bounding_box_4d():
12643  r"""get_unit_bounding_box_4d() -> BoundingBox4D"""
12644  return _IMP_algebra.get_unit_bounding_box_4d()
12645 
12646 def get_unit_bounding_box_5d():
12647  r"""get_unit_bounding_box_5d() -> BoundingBox5D"""
12648  return _IMP_algebra.get_unit_bounding_box_5d()
12649 
12650 def get_unit_bounding_box_6d():
12651  r"""get_unit_bounding_box_6d() -> BoundingBox6D"""
12652  return _IMP_algebra.get_unit_bounding_box_6d()
12653 
12654 def get_cube_1d(radius):
12655  r"""get_cube_1d(double radius) -> BoundingBox1D"""
12656  return _IMP_algebra.get_cube_1d(radius)
12657 
12658 def get_cube_2d(radius):
12659  r"""get_cube_2d(double radius) -> BoundingBox2D"""
12660  return _IMP_algebra.get_cube_2d(radius)
12661 
12662 def get_cube_3d(radius):
12663  r"""get_cube_3d(double radius) -> BoundingBox3D"""
12664  return _IMP_algebra.get_cube_3d(radius)
12665 
12666 def get_cube_4d(radius):
12667  r"""get_cube_4d(double radius) -> BoundingBox4D"""
12668  return _IMP_algebra.get_cube_4d(radius)
12669 
12670 def get_cube_5d(radius):
12671  r"""get_cube_5d(double radius) -> BoundingBox5D"""
12672  return _IMP_algebra.get_cube_5d(radius)
12673 
12674 def get_cube_6d(radius):
12675  r"""get_cube_6d(double radius) -> BoundingBox6D"""
12676  return _IMP_algebra.get_cube_6d(radius)
12677 
12678 def get_unit_sphere_1d():
12679  r"""get_unit_sphere_1d() -> Sphere1D"""
12680  return _IMP_algebra.get_unit_sphere_1d()
12681 
12682 def get_unit_sphere_2d():
12683  r"""get_unit_sphere_2d() -> Sphere2D"""
12684  return _IMP_algebra.get_unit_sphere_2d()
12685 
12686 def get_unit_sphere_3d():
12687  r"""get_unit_sphere_3d() -> Sphere3D"""
12688  return _IMP_algebra.get_unit_sphere_3d()
12689 
12690 def get_unit_sphere_4d():
12691  r"""get_unit_sphere_4d() -> Sphere4D"""
12692  return _IMP_algebra.get_unit_sphere_4d()
12693 
12694 def get_unit_sphere_5d():
12695  r"""get_unit_sphere_5d() -> Sphere5D"""
12696  return _IMP_algebra.get_unit_sphere_5d()
12697 
12698 def get_unit_sphere_6d():
12699  r"""get_unit_sphere_6d() -> Sphere6D"""
12700  return _IMP_algebra.get_unit_sphere_6d()
12701 
12702 def get_interiors_intersect(*args):
12703  r"""
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
12718  """
12719  return _IMP_algebra.get_interiors_intersect(*args)
12720 
12721 def get_random_vector_on(*args):
12722  r"""
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
12744  """
12745  return _IMP_algebra.get_random_vector_on(*args)
12746 
12747 def get_random_vector_in(*args):
12748  r"""
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
12764  """
12765  return _IMP_algebra.get_random_vector_in(*args)
12766 
12767 def get_intersection(*args):
12768  r"""
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
12776  """
12777  return _IMP_algebra.get_intersection(*args)
12778 
12779 def get_union(*args):
12780  r"""
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
12788  """
12789  return _IMP_algebra.get_union(*args)
12790 
12791 def get_bounding_box(*args):
12792  r"""
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
12807  """
12808  return _IMP_algebra.get_bounding_box(*args)
12809 
12810 def get_uniform_surface_cover(*args):
12811  r"""
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
12823  """
12824  return _IMP_algebra.get_uniform_surface_cover(*args)
12825 
12827  r"""
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
12835  """
12836  return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
12837 
12838 def get_projected(*args):
12839  r"""
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
12849  """
12850  return _IMP_algebra.get_projected(*args)
12851 
12852 def get_vertices(*args):
12853  r"""
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 >
12868  """
12869  return _IMP_algebra.get_vertices(*args)
12870 
12871 def get_increasing_from_embedded(*args):
12872  r"""
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
12880  """
12881  return _IMP_algebra.get_increasing_from_embedded(*args)
12882 
12883 def get_embedded_from_increasing(*args):
12884  r"""
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
12892  """
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."""
12896 
12897  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12898  __repr__ = _swig_repr
12899 
12900  def __init__(self, *args):
12901  r"""
12902  __init__(_AxisAnglePair self) -> _AxisAnglePair
12903  __init__(_AxisAnglePair self, Vector3D first, double second) -> _AxisAnglePair
12904  __init__(_AxisAnglePair self, _AxisAnglePair other) -> _AxisAnglePair
12905  """
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""")
12909  def __len__(self):
12910  return 2
12911  def __repr__(self):
12912  return str((self.first, self.second))
12913  def __getitem__(self, index):
12914  if not (index % 2):
12915  return self.first
12916  else:
12917  return self.second
12918  def __setitem__(self, index, val):
12919  if not (index % 2):
12920  self.first = val
12921  else:
12922  self.second = val
12923  __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
12924 
12925 # Register _AxisAnglePair in _IMP_algebra:
12926 _IMP_algebra._AxisAnglePair_swigregister(_AxisAnglePair)
12927 
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."""
12933 
12934  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12935  __repr__ = _swig_repr
12936 
12937  def __init__(self, *args):
12938  r"""
12939  __init__(_RotatedVector3DAdjoint self) -> _RotatedVector3DAdjoint
12940  __init__(_RotatedVector3DAdjoint self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
12941  __init__(_RotatedVector3DAdjoint self, _RotatedVector3DAdjoint other) -> _RotatedVector3DAdjoint
12942  """
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)>""")
12946  def __len__(self):
12947  return 2
12948  def __repr__(self):
12949  return str((self.first, self.second))
12950  def __getitem__(self, index):
12951  if not (index % 2):
12952  return self.first
12953  else:
12954  return self.second
12955  def __setitem__(self, index, val):
12956  if not (index % 2):
12957  self.first = val
12958  else:
12959  self.second = val
12960  __swig_destroy__ = _IMP_algebra.delete__RotatedVector3DAdjoint
12961 
12962 # Register _RotatedVector3DAdjoint in _IMP_algebra:
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."""
12966 
12967  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12968  __repr__ = _swig_repr
12969 
12970  def __init__(self, *args):
12971  r"""
12972  __init__(_ComposeRotation3DAdjoint self) -> _ComposeRotation3DAdjoint
12973  __init__(_ComposeRotation3DAdjoint self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
12974  __init__(_ComposeRotation3DAdjoint self, _ComposeRotation3DAdjoint other) -> _ComposeRotation3DAdjoint
12975  """
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)>""")
12979  def __len__(self):
12980  return 2
12981  def __repr__(self):
12982  return str((self.first, self.second))
12983  def __getitem__(self, index):
12984  if not (index % 2):
12985  return self.first
12986  else:
12987  return self.second
12988  def __setitem__(self, index, val):
12989  if not (index % 2):
12990  self.first = val
12991  else:
12992  self.second = val
12993  __swig_destroy__ = _IMP_algebra.delete__ComposeRotation3DAdjoint
12994 
12995 # Register _ComposeRotation3DAdjoint in _IMP_algebra:
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."""
12999 
13000  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13001  __repr__ = _swig_repr
13002 
13003  def __init__(self, *args):
13004  r"""
13005  __init__(_Transformation3DAdjoint self) -> _Transformation3DAdjoint
13006  __init__(_Transformation3DAdjoint self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
13007  __init__(_Transformation3DAdjoint self, _Transformation3DAdjoint other) -> _Transformation3DAdjoint
13008  """
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)>""")
13012  def __len__(self):
13013  return 2
13014  def __repr__(self):
13015  return str((self.first, self.second))
13016  def __getitem__(self, index):
13017  if not (index % 2):
13018  return self.first
13019  else:
13020  return self.second
13021  def __setitem__(self, index, val):
13022  if not (index % 2):
13023  self.first = val
13024  else:
13025  self.second = val
13026  __swig_destroy__ = _IMP_algebra.delete__Transformation3DAdjoint
13027 
13028 # Register _Transformation3DAdjoint in _IMP_algebra:
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."""
13032 
13033  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13034  __repr__ = _swig_repr
13035 
13036  def __init__(self, *args):
13037  r"""
13038  __init__(_TransformedVector3DAdjoint self) -> _TransformedVector3DAdjoint
13039  __init__(_TransformedVector3DAdjoint self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
13040  __init__(_TransformedVector3DAdjoint self, _TransformedVector3DAdjoint other) -> _TransformedVector3DAdjoint
13041  """
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)>)>""")
13045  def __len__(self):
13046  return 2
13047  def __repr__(self):
13048  return str((self.first, self.second))
13049  def __getitem__(self, index):
13050  if not (index % 2):
13051  return self.first
13052  else:
13053  return self.second
13054  def __setitem__(self, index, val):
13055  if not (index % 2):
13056  self.first = val
13057  else:
13058  self.second = val
13059  __swig_destroy__ = _IMP_algebra.delete__TransformedVector3DAdjoint
13060 
13061 # Register _TransformedVector3DAdjoint in _IMP_algebra:
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."""
13065 
13066  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13067  __repr__ = _swig_repr
13068 
13069  def __init__(self, *args):
13070  r"""
13071  __init__(_ComposeTransformation3DAdjoint self) -> _ComposeTransformation3DAdjoint
13072  __init__(_ComposeTransformation3DAdjoint self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
13073  __init__(_ComposeTransformation3DAdjoint self, _ComposeTransformation3DAdjoint other) -> _ComposeTransformation3DAdjoint
13074  """
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)>)>""")
13078  def __len__(self):
13079  return 2
13080  def __repr__(self):
13081  return str((self.first, self.second))
13082  def __getitem__(self, index):
13083  if not (index % 2):
13084  return self.first
13085  else:
13086  return self.second
13087  def __setitem__(self, index, val):
13088  if not (index % 2):
13089  self.first = val
13090  else:
13091  self.second = val
13092  __swig_destroy__ = _IMP_algebra.delete__ComposeTransformation3DAdjoint
13093 
13094 # Register _ComposeTransformation3DAdjoint in _IMP_algebra:
13095 _IMP_algebra._ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)
13096 
13097 def get_rmsd_transforming_first(tr, v0, v1):
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)
13100 
13101 def get_rmsd(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)
13104 
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)
13108 
13109 def get_weighted_rmsd(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)
13112 
13113 LinearFit=LinearFit2D
13114 ParabolicFit=ParabolicFit2D
13115 
13116 
13117 def get_module_version():
13118  r"""get_module_version() -> std::string const"""
13119  return _IMP_algebra.get_module_version()
13120 
13121 def get_example_path(fname):
13122  r"""get_example_path(std::string fname) -> std::string"""
13123  return _IMP_algebra.get_example_path(fname)
13124 
13125 def get_data_path(fname):
13126  r"""get_data_path(std::string fname) -> std::string"""
13127  return _IMP_algebra.get_data_path(fname)
13128 
13129 from . import _version_check
13130 _version_check.check_version(get_module_version())
13131 __version__ = get_module_version()
13132 
13133 
bool get_is_big_endian()
Returns 1 if machine is big endian else 0.
BoundingBoxD<-1 > BoundingBoxKD
Typedef for Python.
Definition: BoundingBoxD.h:183
Rotation3D get_rotation_about_normalized_axis(const Vector3D &axis_norm, double angle)
Definition: Rotation3D.h:390
double get_height(const Surface &s, const XYZR &d)
Get height of sphere above surface.
Definition: Surface.h:129
Transformation2D get_transformation_aligning_pair(const Vector2Ds &set_from, const Vector2Ds &set_to)
Grid3D< float, DenseGridStorage3D< float > > DenseFloatGrid3D
SphereD< 4 > Sphere4D
Typedef for Python.
Definition: SphereD.h:104
SphereD< 3 > Sphere3D
Typedef for Python.
Definition: SphereD.h:104
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)
VectorD< 6 > Vector6D
Definition: VectorD.h:437
BoundingBoxD< 3 > BoundingBox3D
Typedef for Python.
Definition: BoundingBoxD.h:183
Rotation3D get_rotation_from_fixed_xyz(double xr, double yr, double zr)
Initialize a rotation in x-y-z order from three angles.
VectorD< 2 > Vector2D
Definition: VectorD.h:421
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.
Definition: VectorD.h:280
Rotation2D compose(const Rotation2D &a, const Rotation2D &b)
Compose two rotations a and b.
Definition: Rotation2D.h:121
Sphere3D get_enclosing_sphere(const Sphere3Ds &ss)
Return a sphere containing the listed spheres.
VectorD< 5 > Vector5D
Definition: VectorD.h:433
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.
Definition: BoundingBoxD.h:281
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.
Definition: exception.h:122
Make CGAL functionality available to IMP.
Gaussian3D get_gaussian_from_covariance(const Eigen::Matrix3d &covariance, const Vector3D &center)
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.
Definition: BoundingBoxD.h:314
double get_area(const Geometry &)
Compute the area of any surface object.
BoundingBoxD< 5 > BoundingBox5D
Typedef for Python.
Definition: BoundingBoxD.h:183
SphereD< 2 > Sphere2D
Typedef for Python.
Definition: SphereD.h:104
BoundingBoxD< D > get_union(BoundingBoxD< D > a, const BoundingBoxD< D > &b)
Return the union bounding box.
Definition: BoundingBoxD.h:261
double get_squared_distance(const VectorD< D > &v1, const VectorD< D > &v2)
Compute the squared distance between two vectors.
Definition: VectorD.h:205
VT get_unit_vector(VT vt)
Returns a unit vector pointing at the same direction as this vector.
Definition: VectorBaseD.h:251
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.
Definition: Sphere3D.h:35
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.
Definition: Plane3D.h:76
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.
Definition: VectorD.h:240
double get_angle(const Line3D &a, const Line3D &b)
Get angle in radians between two lines around their closest points.
VectorD< 4 > Vector4D
Definition: VectorD.h:429
VectorD< D > get_ones_vector_kd(unsigned int Di, double v=1)
Return a vector of ones (or another constant)
Definition: VectorD.h:313
BoundingBoxD< 2 > BoundingBox2D
Typedef for Python.
Definition: BoundingBoxD.h:183
Rotation3D get_rotation_about_axis(const Vector3D &axis, double angle)
Generate a Rotation3D object from a rotation around an axis.
Definition: Rotation3D.h:416
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.
Definition: BoundingBoxD.h:230
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.
Definition: BoundingBoxD.h:170
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.
Definition: Vector3D.h:31
bool get_interiors_intersect(const BoundingBoxD< D > &a, const BoundingBoxD< D > &b)
Return true if they intersect.
Definition: BoundingBoxD.h:216
VectorD< D > get_increasing_from_embedded(const UnitSimplexD< D > &s, const VectorD< D > &p)
Convert point on simplex from embedded to increasing coordinates.
Definition: UnitSimplexD.h:148
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
Common base class for heavy weight IMP objects.
Definition: Object.h:111
VectorD< D > get_embedded_from_increasing(const UnitSimplexD< D > &s, const VectorD< D > &p)
Convert point on simplex from increasing to embedded coordinates.
Definition: UnitSimplexD.h:162
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.
Definition: BoundingBoxD.h:183
Rotation2D get_identity_rotation_2d()
Build an identity rotation in 2D.
Definition: Rotation2D.h:103
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.
Definition: SphereD.h:104
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.
Definition: SphereD.h:104
BoundingBoxD<-1 > get_unit_bounding_box_kd(unsigned int d)
Box with radius one.
Definition: BoundingBoxD.h:194
Version and module information for Objects.
Definition: VersionInfo.h:29
double get_radius_of_gyration(const Vector3Ds &ps)
Return the radius of gyration of a set of points.
Definition: Vector3D.h:77
std::pair< Vector3D, double > get_axis_and_angle(const Rotation3D &rot)
Decompose a Rotation3D object into a rotation around an axis.
VectorD< 1 > Vector1D
Definition: VectorD.h:417
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.
Definition: SphereD.h:104
Rotation3D get_interpolated(const Rotation3D &a, const Rotation3D &b, double f)
Interpolate between two rotations.
Definition: Rotation3D.h:610
Rotation3D get_rotation_from_vector4d(const VectorD< 4 > &v)
Compute a rotation from an unnormalized quaternion.
Definition: Rotation3D.h:483
BoundingBoxD<-1 > get_cube_kd(unsigned int d, double radius)
Cube with radius of length side.
Definition: BoundingBoxD.h:208
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)
Definition: Rotation2D.h:113
Vector3D get_centroid(const Vector3Ds &ps)
Return the centroid of a set of vectors.
Definition: Vector3D.h:68
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)
VectorD< 3 > Vector3D
Definition: VectorD.h:425
Rotation3D get_identity_rotation_3d()
Return a rotation that does not do anything.
Definition: Rotation3D.h:351
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.
Definition: Vector3D.h:51
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.
VectorD<-1 > VectorKD
Definition: VectorD.h:441
BoundingBoxD< 6 > BoundingBox6D
Typedef for Python.
Definition: BoundingBoxD.h:183
SphereD<-1 > SphereKD
Typedef for Python.
Definition: SphereD.h:104
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.
Definition: BoundingBoxD.h:183
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.
Definition: Rotation2D.h:106