IMP logo
IMP Reference Guide  2.21.0
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 get_distance(self, o):
1338  r"""get_distance(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1339  return _IMP_algebra._VectorBaseKD_get_distance(self, o)
1340 
1341  def __mul__(self, o):
1342  r"""__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1343  return _IMP_algebra._VectorBaseKD___mul__(self, o)
1344 
1345  def __iadd__(self, o):
1346  r"""__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1347  return _IMP_algebra._VectorBaseKD___iadd__(self, o)
1348 
1349  def __isub__(self, o):
1350  r"""__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1351  return _IMP_algebra._VectorBaseKD___isub__(self, o)
1352 
1353  def __itruediv__(self, *args):
1354  return _IMP_algebra._VectorBaseKD___itruediv__(self, *args)
1355  __idiv__ = __itruediv__
1356 
1357 
1358 
1359  def __imul__(self, f):
1360  r"""__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1361  return _IMP_algebra._VectorBaseKD___imul__(self, f)
1362 
1363  def show(self, *args):
1364  r"""
1365  show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
1366  show(_VectorBaseKD self, _ostream out=std::cout)
1367  """
1368  return _IMP_algebra._VectorBaseKD_show(self, *args)
1369 
1370  def get_dimension(self):
1371  r"""get_dimension(_VectorBaseKD self) -> unsigned int"""
1372  return _IMP_algebra._VectorBaseKD_get_dimension(self)
1373  __swig_destroy__ = _IMP_algebra.delete__VectorBaseKD
1374 
1375 # Register _VectorBaseKD in _IMP_algebra:
1376 _IMP_algebra._VectorBaseKD_swigregister(_VectorBaseKD)
1377 class _VectorBase1D(_GeometricPrimitive1D):
1378  r"""Proxy of C++ IMP::algebra::VectorBaseD< 1 > class."""
1379 
1380  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1381  __repr__ = _swig_repr
1382 
1383  def __init__(self):
1384  r"""__init__(_VectorBase1D self) -> _VectorBase1D"""
1385  _IMP_algebra._VectorBase1D_swiginit(self, _IMP_algebra.new__VectorBase1D())
1386 
1387  def get_scalar_product(self, o):
1388  r"""get_scalar_product(_VectorBase1D self, _VectorBase1D o) -> double"""
1389  return _IMP_algebra._VectorBase1D_get_scalar_product(self, o)
1390 
1391  def get_squared_magnitude(self):
1392  r"""get_squared_magnitude(_VectorBase1D self) -> double"""
1393  return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)
1394 
1395  def get_magnitude(self):
1396  r"""get_magnitude(_VectorBase1D self) -> double"""
1397  return _IMP_algebra._VectorBase1D_get_magnitude(self)
1398 
1399  def get_distance(self, o):
1400  r"""get_distance(_VectorBase1D self, _VectorBase1D o) -> double"""
1401  return _IMP_algebra._VectorBase1D_get_distance(self, o)
1402 
1403  def __mul__(self, o):
1404  r"""__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
1405  return _IMP_algebra._VectorBase1D___mul__(self, o)
1406 
1407  def __iadd__(self, o):
1408  r"""__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1409  return _IMP_algebra._VectorBase1D___iadd__(self, o)
1410 
1411  def __isub__(self, o):
1412  r"""__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1413  return _IMP_algebra._VectorBase1D___isub__(self, o)
1414 
1415  def __itruediv__(self, *args):
1416  return _IMP_algebra._VectorBase1D___itruediv__(self, *args)
1417  __idiv__ = __itruediv__
1418 
1419 
1420 
1421  def __imul__(self, f):
1422  r"""__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
1423  return _IMP_algebra._VectorBase1D___imul__(self, f)
1424 
1425  def show(self, *args):
1426  r"""
1427  show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
1428  show(_VectorBase1D self, _ostream out=std::cout)
1429  """
1430  return _IMP_algebra._VectorBase1D_show(self, *args)
1431 
1432  def get_dimension(self):
1433  r"""get_dimension(_VectorBase1D self) -> unsigned int"""
1434  return _IMP_algebra._VectorBase1D_get_dimension(self)
1435  __swig_destroy__ = _IMP_algebra.delete__VectorBase1D
1436 
1437 # Register _VectorBase1D in _IMP_algebra:
1438 _IMP_algebra._VectorBase1D_swigregister(_VectorBase1D)
1439 class _VectorBase2D(_GeometricPrimitive2D):
1440  r"""Proxy of C++ IMP::algebra::VectorBaseD< 2 > class."""
1441 
1442  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1443  __repr__ = _swig_repr
1444 
1445  def __init__(self):
1446  r"""__init__(_VectorBase2D self) -> _VectorBase2D"""
1447  _IMP_algebra._VectorBase2D_swiginit(self, _IMP_algebra.new__VectorBase2D())
1448 
1449  def get_scalar_product(self, o):
1450  r"""get_scalar_product(_VectorBase2D self, _VectorBase2D o) -> double"""
1451  return _IMP_algebra._VectorBase2D_get_scalar_product(self, o)
1452 
1453  def get_squared_magnitude(self):
1454  r"""get_squared_magnitude(_VectorBase2D self) -> double"""
1455  return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)
1456 
1457  def get_magnitude(self):
1458  r"""get_magnitude(_VectorBase2D self) -> double"""
1459  return _IMP_algebra._VectorBase2D_get_magnitude(self)
1460 
1461  def get_distance(self, o):
1462  r"""get_distance(_VectorBase2D self, _VectorBase2D o) -> double"""
1463  return _IMP_algebra._VectorBase2D_get_distance(self, o)
1464 
1465  def __mul__(self, o):
1466  r"""__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
1467  return _IMP_algebra._VectorBase2D___mul__(self, o)
1468 
1469  def __iadd__(self, o):
1470  r"""__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1471  return _IMP_algebra._VectorBase2D___iadd__(self, o)
1472 
1473  def __isub__(self, o):
1474  r"""__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1475  return _IMP_algebra._VectorBase2D___isub__(self, o)
1476 
1477  def __itruediv__(self, *args):
1478  return _IMP_algebra._VectorBase2D___itruediv__(self, *args)
1479  __idiv__ = __itruediv__
1480 
1481 
1482 
1483  def __imul__(self, f):
1484  r"""__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
1485  return _IMP_algebra._VectorBase2D___imul__(self, f)
1486 
1487  def show(self, *args):
1488  r"""
1489  show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
1490  show(_VectorBase2D self, _ostream out=std::cout)
1491  """
1492  return _IMP_algebra._VectorBase2D_show(self, *args)
1493 
1494  def get_dimension(self):
1495  r"""get_dimension(_VectorBase2D self) -> unsigned int"""
1496  return _IMP_algebra._VectorBase2D_get_dimension(self)
1497  __swig_destroy__ = _IMP_algebra.delete__VectorBase2D
1498 
1499 # Register _VectorBase2D in _IMP_algebra:
1500 _IMP_algebra._VectorBase2D_swigregister(_VectorBase2D)
1501 class _VectorBase3D(_GeometricPrimitive3D):
1502  r"""Proxy of C++ IMP::algebra::VectorBaseD< 3 > class."""
1503 
1504  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1505  __repr__ = _swig_repr
1506 
1507  def __init__(self):
1508  r"""__init__(_VectorBase3D self) -> _VectorBase3D"""
1509  _IMP_algebra._VectorBase3D_swiginit(self, _IMP_algebra.new__VectorBase3D())
1510 
1511  def get_scalar_product(self, o):
1512  r"""get_scalar_product(_VectorBase3D self, _VectorBase3D o) -> double"""
1513  return _IMP_algebra._VectorBase3D_get_scalar_product(self, o)
1514 
1515  def get_squared_magnitude(self):
1516  r"""get_squared_magnitude(_VectorBase3D self) -> double"""
1517  return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)
1518 
1519  def get_magnitude(self):
1520  r"""get_magnitude(_VectorBase3D self) -> double"""
1521  return _IMP_algebra._VectorBase3D_get_magnitude(self)
1522 
1523  def get_distance(self, o):
1524  r"""get_distance(_VectorBase3D self, _VectorBase3D o) -> double"""
1525  return _IMP_algebra._VectorBase3D_get_distance(self, o)
1526 
1527  def __mul__(self, o):
1528  r"""__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
1529  return _IMP_algebra._VectorBase3D___mul__(self, o)
1530 
1531  def __iadd__(self, o):
1532  r"""__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1533  return _IMP_algebra._VectorBase3D___iadd__(self, o)
1534 
1535  def __isub__(self, o):
1536  r"""__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1537  return _IMP_algebra._VectorBase3D___isub__(self, o)
1538 
1539  def __itruediv__(self, *args):
1540  return _IMP_algebra._VectorBase3D___itruediv__(self, *args)
1541  __idiv__ = __itruediv__
1542 
1543 
1544 
1545  def __imul__(self, f):
1546  r"""__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
1547  return _IMP_algebra._VectorBase3D___imul__(self, f)
1548 
1549  def show(self, *args):
1550  r"""
1551  show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
1552  show(_VectorBase3D self, _ostream out=std::cout)
1553  """
1554  return _IMP_algebra._VectorBase3D_show(self, *args)
1555 
1556  def get_dimension(self):
1557  r"""get_dimension(_VectorBase3D self) -> unsigned int"""
1558  return _IMP_algebra._VectorBase3D_get_dimension(self)
1559  __swig_destroy__ = _IMP_algebra.delete__VectorBase3D
1560 
1561 # Register _VectorBase3D in _IMP_algebra:
1562 _IMP_algebra._VectorBase3D_swigregister(_VectorBase3D)
1563 class _VectorBase4D(_GeometricPrimitive4D):
1564  r"""Proxy of C++ IMP::algebra::VectorBaseD< 4 > class."""
1565 
1566  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1567  __repr__ = _swig_repr
1568 
1569  def __init__(self):
1570  r"""__init__(_VectorBase4D self) -> _VectorBase4D"""
1571  _IMP_algebra._VectorBase4D_swiginit(self, _IMP_algebra.new__VectorBase4D())
1572 
1573  def get_scalar_product(self, o):
1574  r"""get_scalar_product(_VectorBase4D self, _VectorBase4D o) -> double"""
1575  return _IMP_algebra._VectorBase4D_get_scalar_product(self, o)
1576 
1577  def get_squared_magnitude(self):
1578  r"""get_squared_magnitude(_VectorBase4D self) -> double"""
1579  return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)
1580 
1581  def get_magnitude(self):
1582  r"""get_magnitude(_VectorBase4D self) -> double"""
1583  return _IMP_algebra._VectorBase4D_get_magnitude(self)
1584 
1585  def get_distance(self, o):
1586  r"""get_distance(_VectorBase4D self, _VectorBase4D o) -> double"""
1587  return _IMP_algebra._VectorBase4D_get_distance(self, o)
1588 
1589  def __mul__(self, o):
1590  r"""__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
1591  return _IMP_algebra._VectorBase4D___mul__(self, o)
1592 
1593  def __iadd__(self, o):
1594  r"""__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1595  return _IMP_algebra._VectorBase4D___iadd__(self, o)
1596 
1597  def __isub__(self, o):
1598  r"""__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1599  return _IMP_algebra._VectorBase4D___isub__(self, o)
1600 
1601  def __itruediv__(self, *args):
1602  return _IMP_algebra._VectorBase4D___itruediv__(self, *args)
1603  __idiv__ = __itruediv__
1604 
1605 
1606 
1607  def __imul__(self, f):
1608  r"""__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
1609  return _IMP_algebra._VectorBase4D___imul__(self, f)
1610 
1611  def show(self, *args):
1612  r"""
1613  show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
1614  show(_VectorBase4D self, _ostream out=std::cout)
1615  """
1616  return _IMP_algebra._VectorBase4D_show(self, *args)
1617 
1618  def get_dimension(self):
1619  r"""get_dimension(_VectorBase4D self) -> unsigned int"""
1620  return _IMP_algebra._VectorBase4D_get_dimension(self)
1621  __swig_destroy__ = _IMP_algebra.delete__VectorBase4D
1622 
1623 # Register _VectorBase4D in _IMP_algebra:
1624 _IMP_algebra._VectorBase4D_swigregister(_VectorBase4D)
1625 class _VectorBase5D(_GeometricPrimitive5D):
1626  r"""Proxy of C++ IMP::algebra::VectorBaseD< 5 > class."""
1627 
1628  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1629  __repr__ = _swig_repr
1630 
1631  def __init__(self):
1632  r"""__init__(_VectorBase5D self) -> _VectorBase5D"""
1633  _IMP_algebra._VectorBase5D_swiginit(self, _IMP_algebra.new__VectorBase5D())
1634 
1635  def get_scalar_product(self, o):
1636  r"""get_scalar_product(_VectorBase5D self, _VectorBase5D o) -> double"""
1637  return _IMP_algebra._VectorBase5D_get_scalar_product(self, o)
1638 
1639  def get_squared_magnitude(self):
1640  r"""get_squared_magnitude(_VectorBase5D self) -> double"""
1641  return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)
1642 
1643  def get_magnitude(self):
1644  r"""get_magnitude(_VectorBase5D self) -> double"""
1645  return _IMP_algebra._VectorBase5D_get_magnitude(self)
1646 
1647  def get_distance(self, o):
1648  r"""get_distance(_VectorBase5D self, _VectorBase5D o) -> double"""
1649  return _IMP_algebra._VectorBase5D_get_distance(self, o)
1650 
1651  def __mul__(self, o):
1652  r"""__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
1653  return _IMP_algebra._VectorBase5D___mul__(self, o)
1654 
1655  def __iadd__(self, o):
1656  r"""__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1657  return _IMP_algebra._VectorBase5D___iadd__(self, o)
1658 
1659  def __isub__(self, o):
1660  r"""__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1661  return _IMP_algebra._VectorBase5D___isub__(self, o)
1662 
1663  def __itruediv__(self, *args):
1664  return _IMP_algebra._VectorBase5D___itruediv__(self, *args)
1665  __idiv__ = __itruediv__
1666 
1667 
1668 
1669  def __imul__(self, f):
1670  r"""__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
1671  return _IMP_algebra._VectorBase5D___imul__(self, f)
1672 
1673  def show(self, *args):
1674  r"""
1675  show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
1676  show(_VectorBase5D self, _ostream out=std::cout)
1677  """
1678  return _IMP_algebra._VectorBase5D_show(self, *args)
1679 
1680  def get_dimension(self):
1681  r"""get_dimension(_VectorBase5D self) -> unsigned int"""
1682  return _IMP_algebra._VectorBase5D_get_dimension(self)
1683  __swig_destroy__ = _IMP_algebra.delete__VectorBase5D
1684 
1685 # Register _VectorBase5D in _IMP_algebra:
1686 _IMP_algebra._VectorBase5D_swigregister(_VectorBase5D)
1687 class _VectorBase6D(_GeometricPrimitive6D):
1688  r"""Proxy of C++ IMP::algebra::VectorBaseD< 6 > class."""
1689 
1690  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1691  __repr__ = _swig_repr
1692 
1693  def __init__(self):
1694  r"""__init__(_VectorBase6D self) -> _VectorBase6D"""
1695  _IMP_algebra._VectorBase6D_swiginit(self, _IMP_algebra.new__VectorBase6D())
1696 
1697  def get_scalar_product(self, o):
1698  r"""get_scalar_product(_VectorBase6D self, _VectorBase6D o) -> double"""
1699  return _IMP_algebra._VectorBase6D_get_scalar_product(self, o)
1700 
1701  def get_squared_magnitude(self):
1702  r"""get_squared_magnitude(_VectorBase6D self) -> double"""
1703  return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)
1704 
1705  def get_magnitude(self):
1706  r"""get_magnitude(_VectorBase6D self) -> double"""
1707  return _IMP_algebra._VectorBase6D_get_magnitude(self)
1708 
1709  def get_distance(self, o):
1710  r"""get_distance(_VectorBase6D self, _VectorBase6D o) -> double"""
1711  return _IMP_algebra._VectorBase6D_get_distance(self, o)
1712 
1713  def __mul__(self, o):
1714  r"""__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
1715  return _IMP_algebra._VectorBase6D___mul__(self, o)
1716 
1717  def __iadd__(self, o):
1718  r"""__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1719  return _IMP_algebra._VectorBase6D___iadd__(self, o)
1720 
1721  def __isub__(self, o):
1722  r"""__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1723  return _IMP_algebra._VectorBase6D___isub__(self, o)
1724 
1725  def __itruediv__(self, *args):
1726  return _IMP_algebra._VectorBase6D___itruediv__(self, *args)
1727  __idiv__ = __itruediv__
1728 
1729 
1730 
1731  def __imul__(self, f):
1732  r"""__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
1733  return _IMP_algebra._VectorBase6D___imul__(self, f)
1734 
1735  def show(self, *args):
1736  r"""
1737  show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
1738  show(_VectorBase6D self, _ostream out=std::cout)
1739  """
1740  return _IMP_algebra._VectorBase6D_show(self, *args)
1741 
1742  def get_dimension(self):
1743  r"""get_dimension(_VectorBase6D self) -> unsigned int"""
1744  return _IMP_algebra._VectorBase6D_get_dimension(self)
1745  __swig_destroy__ = _IMP_algebra.delete__VectorBase6D
1746 
1747 # Register _VectorBase6D in _IMP_algebra:
1748 _IMP_algebra._VectorBase6D_swigregister(_VectorBase6D)
1749 
1750 def get_basis_vector_kd(D, coordinate):
1751  r"""get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
1752  return _IMP_algebra.get_basis_vector_kd(D, coordinate)
1753 
1754 def get_zero_vector_kd(D):
1755  r"""get_zero_vector_kd(int D) -> VectorKD"""
1756  return _IMP_algebra.get_zero_vector_kd(D)
1757 
1758 def get_ones_vector_kd(D, v=1):
1759  r"""get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD"""
1760  return _IMP_algebra.get_ones_vector_kd(D, v)
1761 
1762 def get_vector_product(p1, p2):
1763  r"""get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
1764  return _IMP_algebra.get_vector_product(p1, p2)
1765 
1766 def get_orthogonal_vector(v):
1767  r"""get_orthogonal_vector(Vector3D v) -> Vector3D"""
1768  return _IMP_algebra.get_orthogonal_vector(v)
1769 
1770 def get_centroid(ps):
1771  r"""get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
1772  return _IMP_algebra.get_centroid(ps)
1773 
1774 def get_radius_of_gyration(ps):
1775  r"""get_radius_of_gyration(IMP::algebra::Vector3Ds const & ps) -> double"""
1776  return _IMP_algebra.get_radius_of_gyration(ps)
1777 class Rotation3D(_GeometricPrimitive3D):
1778  r"""Proxy of C++ IMP::algebra::Rotation3D class."""
1779 
1780  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1781 
1782  def __init__(self, *args):
1783  r"""
1784  __init__(Rotation3D self, Rotation3D rot) -> Rotation3D
1785  __init__(Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
1786  __init__(Rotation3D self) -> Rotation3D
1787  __init__(Rotation3D self, double a, double b, double c, double d) -> Rotation3D
1788  """
1789  _IMP_algebra.Rotation3D_swiginit(self, _IMP_algebra.new_Rotation3D(*args))
1790  __swig_destroy__ = _IMP_algebra.delete_Rotation3D
1791 
1792  def get_rotated_no_cache(self, o):
1793  r"""get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
1794  return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, o)
1795 
1796  def get_rotated_one_coordinate_no_cache(self, o, coord):
1797  r"""get_rotated_one_coordinate_no_cache(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1798  return _IMP_algebra.Rotation3D_get_rotated_one_coordinate_no_cache(self, o, coord)
1799 
1800  def get_rotated(self, o):
1801  r"""get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
1802  return _IMP_algebra.Rotation3D_get_rotated(self, o)
1803 
1804  def get_rotated_adjoint(self, v, Dw):
1805  r"""get_rotated_adjoint(Rotation3D self, Vector3D v, Vector3D Dw) -> _RotatedVector3DAdjoint"""
1806  return _IMP_algebra.Rotation3D_get_rotated_adjoint(self, v, Dw)
1807 
1808  def get_rotated_one_coordinate(self, o, coord):
1809  r"""get_rotated_one_coordinate(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1810  return _IMP_algebra.Rotation3D_get_rotated_one_coordinate(self, o, coord)
1811 
1812  def get_rotation_matrix_row(self, i):
1813  r"""get_rotation_matrix_row(Rotation3D self, int i) -> Vector3D"""
1814  return _IMP_algebra.Rotation3D_get_rotation_matrix_row(self, i)
1815 
1816  def show(self, *args):
1817  r"""show(Rotation3D self, _ostream out=std::cout)"""
1818  return _IMP_algebra.Rotation3D_show(self, *args)
1819 
1820  def get_inverse(self):
1821  r"""get_inverse(Rotation3D self) -> Rotation3D"""
1822  return _IMP_algebra.Rotation3D_get_inverse(self)
1823 
1824  def get_quaternion(self):
1825  r"""get_quaternion(Rotation3D self) -> Vector4D"""
1826  return _IMP_algebra.Rotation3D_get_quaternion(self)
1827 
1828  def __mul__(self, *args):
1829  r"""
1830  __mul__(Rotation3D self, Vector3D v) -> Vector3D
1831  __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
1832  """
1833  return _IMP_algebra.Rotation3D___mul__(self, *args)
1834 
1835  def __truediv__(self, *args):
1836  return _IMP_algebra.Rotation3D___truediv__(self, *args)
1837  __div__ = __truediv__
1838 
1839 
1840 
1841  def get_gradient_of_rotated(self, v, i, wrt_unnorm=False):
1842  r"""get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=False) -> Vector3D"""
1843  return _IMP_algebra.Rotation3D_get_gradient_of_rotated(self, v, i, wrt_unnorm)
1844 
1845  def get_jacobian_of_rotated(self, v, wrt_unnorm=False):
1846  r"""get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1847  return _IMP_algebra.Rotation3D_get_jacobian_of_rotated(self, v, wrt_unnorm)
1848 
1849  def get_is_valid(self):
1850  r"""get_is_valid(Rotation3D self) -> bool"""
1851  return _IMP_algebra.Rotation3D_get_is_valid(self)
1852 
1853  def __str__(self):
1854  r"""__str__(Rotation3D self) -> std::string"""
1855  return _IMP_algebra.Rotation3D___str__(self)
1856 
1857  def __repr__(self):
1858  r"""__repr__(Rotation3D self) -> std::string"""
1859  return _IMP_algebra.Rotation3D___repr__(self)
1860 
1861  def _get_as_binary(self):
1862  r"""_get_as_binary(Rotation3D self) -> PyObject *"""
1863  return _IMP_algebra.Rotation3D__get_as_binary(self)
1864 
1865  def _set_from_binary(self, p):
1866  r"""_set_from_binary(Rotation3D self, PyObject * p)"""
1867  return _IMP_algebra.Rotation3D__set_from_binary(self, p)
1868 
1869  def __getstate__(self):
1870  p = self._get_as_binary()
1871  if len(self.__dict__) > 1:
1872  d = self.__dict__.copy()
1873  del d['this']
1874  p = (d, p)
1875  return p
1876 
1877  def __setstate__(self, p):
1878  if not hasattr(self, 'this'):
1879  self.__init__()
1880  if isinstance(p, tuple):
1881  d, p = p
1882  self.__dict__.update(d)
1883  return self._set_from_binary(p)
1884 
1885 
1886  __truediv__ = __div__
1887 
1888 
1889 # Register Rotation3D in _IMP_algebra:
1890 _IMP_algebra.Rotation3D_swigregister(Rotation3D)
1891 
1892 def get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm=False):
1893  r"""get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1894  return _IMP_algebra.get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm)
1895 
1896 def get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm=False):
1897  r"""get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd"""
1898  return _IMP_algebra.get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm)
1899 
1901  r"""get_identity_rotation_3d() -> Rotation3D"""
1902  return _IMP_algebra.get_identity_rotation_3d()
1903 
1904 def get_rotation_about_normalized_axis(axis_norm, angle):
1905  r"""get_rotation_about_normalized_axis(Vector3D axis_norm, double angle) -> Rotation3D"""
1906  return _IMP_algebra.get_rotation_about_normalized_axis(axis_norm, angle)
1907 
1908 def get_rotation_about_axis(axis, angle):
1909  r"""get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
1910  return _IMP_algebra.get_rotation_about_axis(axis, angle)
1911 
1913  r"""get_rotation_taking_first_to_second(Vector3D v1, Vector3D v2) -> Rotation3D"""
1914  return _IMP_algebra.get_rotation_taking_first_to_second(v1, v2)
1915 
1916 def get_rotation_from_matrix(*args):
1917  r"""
1918  get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22) -> Rotation3D
1919  get_rotation_from_matrix(Eigen::Matrix3d m) -> Rotation3D
1920  """
1921  return _IMP_algebra.get_rotation_from_matrix(*args)
1922 
1923 def get_random_rotation_3d(*args):
1924  r"""
1925  get_random_rotation_3d() -> Rotation3D
1926  get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
1927  """
1928  return _IMP_algebra.get_random_rotation_3d(*args)
1929 
1930 def get_uniform_cover_rotations_3d(num_points):
1931  r"""get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
1932  return _IMP_algebra.get_uniform_cover_rotations_3d(num_points)
1933 
1935  r"""get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
1936  return _IMP_algebra.get_uniformly_sampled_rotations(delta)
1937 
1939  r"""get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
1940  return _IMP_algebra.get_rotation_from_vector4d(v)
1941 
1942 def get_rotation_from_fixed_xyz(xr, yr, zr):
1943  r"""get_rotation_from_fixed_xyz(double xr, double yr, double zr) -> Rotation3D"""
1944  return _IMP_algebra.get_rotation_from_fixed_xyz(xr, yr, zr)
1945 
1946 def get_rotation_from_fixed_zxz(phi, theta, psi):
1947  r"""get_rotation_from_fixed_zxz(double phi, double theta, double psi) -> Rotation3D"""
1948  return _IMP_algebra.get_rotation_from_fixed_zxz(phi, theta, psi)
1949 
1950 def get_rotation_from_fixed_zyz(Rot, Tilt, Psi):
1951  r"""get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
1952  return _IMP_algebra.get_rotation_from_fixed_zyz(Rot, Tilt, Psi)
1953 class FixedXYZ(_GeometricPrimitive3D):
1954  r"""Proxy of C++ IMP::algebra::FixedXYZ class."""
1955 
1956  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1957 
1958  def __init__(self, *args):
1959  r"""
1960  __init__(FixedXYZ self) -> FixedXYZ
1961  __init__(FixedXYZ self, double x, double y, double z) -> FixedXYZ
1962  """
1963  _IMP_algebra.FixedXYZ_swiginit(self, _IMP_algebra.new_FixedXYZ(*args))
1964 
1965  def get_x(self):
1966  r"""get_x(FixedXYZ self) -> double"""
1967  return _IMP_algebra.FixedXYZ_get_x(self)
1968 
1969  def get_y(self):
1970  r"""get_y(FixedXYZ self) -> double"""
1971  return _IMP_algebra.FixedXYZ_get_y(self)
1972 
1973  def get_z(self):
1974  r"""get_z(FixedXYZ self) -> double"""
1975  return _IMP_algebra.FixedXYZ_get_z(self)
1976 
1977  def show(self, *args):
1978  r"""show(FixedXYZ self, _ostream out=std::cout)"""
1979  return _IMP_algebra.FixedXYZ_show(self, *args)
1980 
1981  def __str__(self):
1982  r"""__str__(FixedXYZ self) -> std::string"""
1983  return _IMP_algebra.FixedXYZ___str__(self)
1984 
1985  def __repr__(self):
1986  r"""__repr__(FixedXYZ self) -> std::string"""
1987  return _IMP_algebra.FixedXYZ___repr__(self)
1988 
1989  def _get_as_binary(self):
1990  r"""_get_as_binary(FixedXYZ self) -> PyObject *"""
1991  return _IMP_algebra.FixedXYZ__get_as_binary(self)
1992 
1993  def _set_from_binary(self, p):
1994  r"""_set_from_binary(FixedXYZ self, PyObject * p)"""
1995  return _IMP_algebra.FixedXYZ__set_from_binary(self, p)
1996 
1997  def __getstate__(self):
1998  p = self._get_as_binary()
1999  if len(self.__dict__) > 1:
2000  d = self.__dict__.copy()
2001  del d['this']
2002  p = (d, p)
2003  return p
2004 
2005  def __setstate__(self, p):
2006  if not hasattr(self, 'this'):
2007  self.__init__()
2008  if isinstance(p, tuple):
2009  d, p = p
2010  self.__dict__.update(d)
2011  return self._set_from_binary(p)
2012 
2013  __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
2014 
2015 # Register FixedXYZ in _IMP_algebra:
2016 _IMP_algebra.FixedXYZ_swigregister(FixedXYZ)
2017 
2019  r"""get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
2020  return _IMP_algebra.get_fixed_xyz_from_rotation(r)
2021 
2022 def get_interpolated(a, b, f):
2023  r"""get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
2024  return _IMP_algebra.get_interpolated(a, b, f)
2025 
2026 def get_rotation_from_x_y_axes(x, y):
2027  r"""get_rotation_from_x_y_axes(Vector3D x, Vector3D y) -> Rotation3D"""
2028  return _IMP_algebra.get_rotation_from_x_y_axes(x, y)
2029 
2030 def get_axis_and_angle(rot):
2031  r"""get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
2032  return _IMP_algebra.get_axis_and_angle(rot)
2033 
2035  r"""get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
2036  return _IMP_algebra.get_unit_bounding_box_kd(d)
2037 
2038 def get_cube_kd(d, radius):
2039  r"""get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
2040  return _IMP_algebra.get_cube_kd(d, radius)
2041 
2042 def get_edges(arg1):
2043  r"""get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
2044  return _IMP_algebra.get_edges(arg1)
2045 class Transformation3D(_GeometricPrimitive3D):
2046  r"""Proxy of C++ IMP::algebra::Transformation3D class."""
2047 
2048  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2049 
2050  def __init__(self, *args):
2051  r"""
2052  __init__(Transformation3D self, Transformation3D arg2) -> Transformation3D
2053  __init__(Transformation3D self) -> Transformation3D
2054  __init__(Transformation3D self, Rotation3D r, Vector3D t=IMP::algebra::Vector3D(0, 0, 0)) -> Transformation3D
2055  __init__(Transformation3D self, Vector3D t) -> Transformation3D
2056  """
2057  _IMP_algebra.Transformation3D_swiginit(self, _IMP_algebra.new_Transformation3D(*args))
2058  __swig_destroy__ = _IMP_algebra.delete_Transformation3D
2059 
2060  def get_transformed(self, o):
2061  r"""get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
2062  return _IMP_algebra.Transformation3D_get_transformed(self, o)
2063 
2064  def get_transformed_adjoint(self, v, Dw):
2065  r"""get_transformed_adjoint(Transformation3D self, Vector3D v, Vector3D Dw) -> _TransformedVector3DAdjoint"""
2066  return _IMP_algebra.Transformation3D_get_transformed_adjoint(self, v, Dw)
2067 
2068  def __mul__(self, *args):
2069  r"""
2070  __mul__(Transformation3D self, Vector3D v) -> Vector3D
2071  __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
2072  """
2073  return _IMP_algebra.Transformation3D___mul__(self, *args)
2074 
2075  def __truediv__(self, *args):
2076  return _IMP_algebra.Transformation3D___truediv__(self, *args)
2077  __div__ = __truediv__
2078 
2079 
2080 
2081  def get_rotation(self):
2082  r"""get_rotation(Transformation3D self) -> Rotation3D"""
2083  return _IMP_algebra.Transformation3D_get_rotation(self)
2084 
2085  def get_translation(self):
2086  r"""get_translation(Transformation3D self) -> Vector3D"""
2087  return _IMP_algebra.Transformation3D_get_translation(self)
2088 
2089  def show(self, *args):
2090  r"""show(Transformation3D self, _ostream out=std::cout)"""
2091  return _IMP_algebra.Transformation3D_show(self, *args)
2092 
2093  def get_inverse(self):
2094  r"""get_inverse(Transformation3D self) -> Transformation3D"""
2095  return _IMP_algebra.Transformation3D_get_inverse(self)
2096 
2097  def get_is_valid(self):
2098  r"""get_is_valid(Transformation3D self) -> bool"""
2099  return _IMP_algebra.Transformation3D_get_is_valid(self)
2100 
2101  def __str__(self):
2102  r"""__str__(Transformation3D self) -> std::string"""
2103  return _IMP_algebra.Transformation3D___str__(self)
2104 
2105  def __repr__(self):
2106  r"""__repr__(Transformation3D self) -> std::string"""
2107  return _IMP_algebra.Transformation3D___repr__(self)
2108 
2109  def _get_as_binary(self):
2110  r"""_get_as_binary(Transformation3D self) -> PyObject *"""
2111  return _IMP_algebra.Transformation3D__get_as_binary(self)
2112 
2113  def _set_from_binary(self, p):
2114  r"""_set_from_binary(Transformation3D self, PyObject * p)"""
2115  return _IMP_algebra.Transformation3D__set_from_binary(self, p)
2116 
2117  def __getstate__(self):
2118  p = self._get_as_binary()
2119  if len(self.__dict__) > 1:
2120  d = self.__dict__.copy()
2121  del d['this']
2122  p = (d, p)
2123  return p
2124 
2125  def __setstate__(self, p):
2126  if not hasattr(self, 'this'):
2127  self.__init__()
2128  if isinstance(p, tuple):
2129  d, p = p
2130  self.__dict__.update(d)
2131  return self._set_from_binary(p)
2132 
2133 
2134  __truediv__ = __div__
2135 
2136 
2137 # Register Transformation3D in _IMP_algebra:
2138 _IMP_algebra.Transformation3D_swigregister(Transformation3D)
2139 
2141  r"""get_identity_transformation_3d() -> Transformation3D"""
2142  return _IMP_algebra.get_identity_transformation_3d()
2143 
2144 def compose_adjoint(*args):
2145  r"""
2146  compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
2147  compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
2148  """
2149  return _IMP_algebra.compose_adjoint(*args)
2150 
2151 def get_transformation_3d(t2d):
2152  r"""get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
2153  return _IMP_algebra.get_transformation_3d(t2d)
2154 
2155 def get_random_local_transformation(origin, max_translation=5., max_angle_in_rad=0.26):
2156  r"""get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D"""
2157  return _IMP_algebra.get_random_local_transformation(origin, max_translation, max_angle_in_rad)
2158 class Rotation2D(_GeometricPrimitive2D):
2159  r"""Proxy of C++ IMP::algebra::Rotation2D class."""
2160 
2161  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2162 
2163  def __init__(self, *args):
2164  r"""
2165  __init__(Rotation2D self) -> Rotation2D
2166  __init__(Rotation2D self, double angle) -> Rotation2D
2167  """
2168  _IMP_algebra.Rotation2D_swiginit(self, _IMP_algebra.new_Rotation2D(*args))
2169 
2170  def get_rotated(self, *args):
2171  r"""
2172  get_rotated(Rotation2D self, Vector2D o) -> Vector2D
2173  get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
2174  """
2175  return _IMP_algebra.Rotation2D_get_rotated(self, *args)
2176 
2177  def get_inverse(self):
2178  r"""get_inverse(Rotation2D self) -> Rotation2D"""
2179  return _IMP_algebra.Rotation2D_get_inverse(self)
2180 
2181  def set_angle(self, angle):
2182  r"""set_angle(Rotation2D self, double angle)"""
2183  return _IMP_algebra.Rotation2D_set_angle(self, angle)
2184 
2185  def get_angle(self):
2186  r"""get_angle(Rotation2D self) -> double"""
2187  return _IMP_algebra.Rotation2D_get_angle(self)
2188 
2189  def show(self, *args):
2190  r"""show(Rotation2D self, _ostream out=std::cout)"""
2191  return _IMP_algebra.Rotation2D_show(self, *args)
2192 
2193  def __str__(self):
2194  r"""__str__(Rotation2D self) -> std::string"""
2195  return _IMP_algebra.Rotation2D___str__(self)
2196 
2197  def __repr__(self):
2198  r"""__repr__(Rotation2D self) -> std::string"""
2199  return _IMP_algebra.Rotation2D___repr__(self)
2200 
2201  def _get_as_binary(self):
2202  r"""_get_as_binary(Rotation2D self) -> PyObject *"""
2203  return _IMP_algebra.Rotation2D__get_as_binary(self)
2204 
2205  def _set_from_binary(self, p):
2206  r"""_set_from_binary(Rotation2D self, PyObject * p)"""
2207  return _IMP_algebra.Rotation2D__set_from_binary(self, p)
2208 
2209  def __getstate__(self):
2210  p = self._get_as_binary()
2211  if len(self.__dict__) > 1:
2212  d = self.__dict__.copy()
2213  del d['this']
2214  p = (d, p)
2215  return p
2216 
2217  def __setstate__(self, p):
2218  if not hasattr(self, 'this'):
2219  self.__init__()
2220  if isinstance(p, tuple):
2221  d, p = p
2222  self.__dict__.update(d)
2223  return self._set_from_binary(p)
2224 
2225  __swig_destroy__ = _IMP_algebra.delete_Rotation2D
2226 
2227 # Register Rotation2D in _IMP_algebra:
2228 _IMP_algebra.Rotation2D_swigregister(Rotation2D)
2229 
2231  r"""get_identity_rotation_2d() -> Rotation2D"""
2232  return _IMP_algebra.get_identity_rotation_2d()
2233 
2235  r"""get_random_rotation_2d() -> Rotation2D"""
2236  return _IMP_algebra.get_random_rotation_2d()
2237 
2238 def get_rotation_to_x_axis(v):
2239  r"""get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
2240  return _IMP_algebra.get_rotation_to_x_axis(v)
2241 class Transformation2D(_GeometricPrimitive2D):
2242  r"""Proxy of C++ IMP::algebra::Transformation2D class."""
2243 
2244  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2245 
2246  def __init__(self, *args):
2247  r"""
2248  __init__(Transformation2D self, Transformation2D arg2) -> Transformation2D
2249  __init__(Transformation2D self) -> Transformation2D
2250  __init__(Transformation2D self, Rotation2D r, Vector2D t=IMP::algebra::Vector2D(0.0, 0.0)) -> Transformation2D
2251  __init__(Transformation2D self, Vector2D t) -> Transformation2D
2252  """
2253  _IMP_algebra.Transformation2D_swiginit(self, _IMP_algebra.new_Transformation2D(*args))
2254  __swig_destroy__ = _IMP_algebra.delete_Transformation2D
2255 
2256  def get_transformed(self, o):
2257  r"""get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
2258  return _IMP_algebra.Transformation2D_get_transformed(self, o)
2259 
2260  def __mul__(self, *args):
2261  r"""
2262  __mul__(Transformation2D self, Vector2D v) -> Vector2D
2263  __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
2264  """
2265  return _IMP_algebra.Transformation2D___mul__(self, *args)
2266 
2267  def __truediv__(self, *args):
2268  return _IMP_algebra.Transformation2D___truediv__(self, *args)
2269  __div__ = __truediv__
2270 
2271 
2272 
2273  def get_rotation(self):
2274  r"""get_rotation(Transformation2D self) -> Rotation2D"""
2275  return _IMP_algebra.Transformation2D_get_rotation(self)
2276 
2277  def set_rotation(self, angle):
2278  r"""set_rotation(Transformation2D self, double angle)"""
2279  return _IMP_algebra.Transformation2D_set_rotation(self, angle)
2280 
2281  def get_translation(self):
2282  r"""get_translation(Transformation2D self) -> Vector2D"""
2283  return _IMP_algebra.Transformation2D_get_translation(self)
2284 
2285  def set_translation(self, v):
2286  r"""set_translation(Transformation2D self, Vector2D v)"""
2287  return _IMP_algebra.Transformation2D_set_translation(self, v)
2288 
2289  def show(self, *args):
2290  r"""show(Transformation2D self, _ostream out=std::cout)"""
2291  return _IMP_algebra.Transformation2D_show(self, *args)
2292 
2293  def get_inverse(self):
2294  r"""get_inverse(Transformation2D self) -> Transformation2D"""
2295  return _IMP_algebra.Transformation2D_get_inverse(self)
2296 
2297  def __str__(self):
2298  r"""__str__(Transformation2D self) -> std::string"""
2299  return _IMP_algebra.Transformation2D___str__(self)
2300 
2301  def __repr__(self):
2302  r"""__repr__(Transformation2D self) -> std::string"""
2303  return _IMP_algebra.Transformation2D___repr__(self)
2304 
2305  def _get_as_binary(self):
2306  r"""_get_as_binary(Transformation2D self) -> PyObject *"""
2307  return _IMP_algebra.Transformation2D__get_as_binary(self)
2308 
2309  def _set_from_binary(self, p):
2310  r"""_set_from_binary(Transformation2D self, PyObject * p)"""
2311  return _IMP_algebra.Transformation2D__set_from_binary(self, p)
2312 
2313  def __getstate__(self):
2314  p = self._get_as_binary()
2315  if len(self.__dict__) > 1:
2316  d = self.__dict__.copy()
2317  del d['this']
2318  p = (d, p)
2319  return p
2320 
2321  def __setstate__(self, p):
2322  if not hasattr(self, 'this'):
2323  self.__init__()
2324  if isinstance(p, tuple):
2325  d, p = p
2326  self.__dict__.update(d)
2327  return self._set_from_binary(p)
2328 
2329 
2330  __truediv__ = __div__
2331 
2332 
2333 # Register Transformation2D in _IMP_algebra:
2334 _IMP_algebra.Transformation2D_swigregister(Transformation2D)
2335 
2337  r"""get_identity_transformation_2d() -> Transformation2D"""
2338  return _IMP_algebra.get_identity_transformation_2d()
2339 
2340 def get_rotation_about_point(*args):
2341  r"""
2342  get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
2343  get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
2344  """
2345  return _IMP_algebra.get_rotation_about_point(*args)
2346 
2347 def compose(*args):
2348  r"""
2349  compose(Rotation3D a, Rotation3D b) -> Rotation3D
2350  compose(Transformation3D a, Transformation3D b) -> Transformation3D
2351  compose(Rotation2D a, Rotation2D b) -> Rotation2D
2352  compose(Transformation2D a, Transformation2D b) -> Transformation2D
2353  """
2354  return _IMP_algebra.compose(*args)
2355 
2356 def get_unit_sphere_kd(d):
2357  r"""get_unit_sphere_kd(unsigned int d) -> SphereKD"""
2358  return _IMP_algebra.get_unit_sphere_kd(d)
2359 
2360 def get_enclosing_sphere(*args):
2361  r"""
2362  get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
2363  get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
2364  """
2365  return _IMP_algebra.get_enclosing_sphere(*args)
2366 
2367 def get_ball_radius_from_volume_3d(volume):
2368  r"""get_ball_radius_from_volume_3d(double volume) -> double"""
2369  return _IMP_algebra.get_ball_radius_from_volume_3d(volume)
2370 
2372  r"""get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
2373  return _IMP_algebra.get_surface_area_and_volume(ss)
2374 
2375 def get_simplified_from_volume(_in, maximum_allowed_error_angstroms):
2376  r"""get_simplified_from_volume(IMP::algebra::Sphere3Ds _in, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
2377  return _IMP_algebra.get_simplified_from_volume(_in, maximum_allowed_error_angstroms)
2378 
2379 def get_triangle_3d(s):
2380  r"""get_triangle_3d(UnitSimplex3D s) -> Triangle3D"""
2381  return _IMP_algebra.get_triangle_3d(s)
2382 class _UnitSimplexBaseKD(_GeometricPrimitiveKD):
2383  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< -1 > class."""
2384 
2385  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2386 
2387  def __init__(self, *args, **kwargs):
2388  raise AttributeError("No constructor defined - class is abstract")
2389  __repr__ = _swig_repr
2390 
2391  def get_dimension(self):
2392  r"""get_dimension(_UnitSimplexBaseKD self) -> int"""
2393  return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)
2394 
2395  def get_barycenter(self):
2396  r"""get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
2397  return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)
2398 
2399  def get_contains(self, *args):
2400  r"""get_contains(_UnitSimplexBaseKD self, VectorKD p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2401  return _IMP_algebra._UnitSimplexBaseKD_get_contains(self, *args)
2402  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBaseKD
2403 
2404 # Register _UnitSimplexBaseKD in _IMP_algebra:
2405 _IMP_algebra._UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
2406 class _UnitSimplexBase1D(_GeometricPrimitive1D):
2407  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 1 > class."""
2408 
2409  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2410 
2411  def __init__(self, *args, **kwargs):
2412  raise AttributeError("No constructor defined - class is abstract")
2413  __repr__ = _swig_repr
2414 
2415  def get_dimension(self):
2416  r"""get_dimension(_UnitSimplexBase1D self) -> int"""
2417  return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)
2418 
2419  def get_barycenter(self):
2420  r"""get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
2421  return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)
2422 
2423  def get_contains(self, *args):
2424  r"""get_contains(_UnitSimplexBase1D self, Vector1D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2425  return _IMP_algebra._UnitSimplexBase1D_get_contains(self, *args)
2426  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase1D
2427 
2428 # Register _UnitSimplexBase1D in _IMP_algebra:
2429 _IMP_algebra._UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
2430 class _UnitSimplexBase2D(_GeometricPrimitive2D):
2431  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 2 > class."""
2432 
2433  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2434 
2435  def __init__(self, *args, **kwargs):
2436  raise AttributeError("No constructor defined - class is abstract")
2437  __repr__ = _swig_repr
2438 
2439  def get_dimension(self):
2440  r"""get_dimension(_UnitSimplexBase2D self) -> int"""
2441  return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)
2442 
2443  def get_barycenter(self):
2444  r"""get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
2445  return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)
2446 
2447  def get_contains(self, *args):
2448  r"""get_contains(_UnitSimplexBase2D self, Vector2D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2449  return _IMP_algebra._UnitSimplexBase2D_get_contains(self, *args)
2450  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase2D
2451 
2452 # Register _UnitSimplexBase2D in _IMP_algebra:
2453 _IMP_algebra._UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
2454 class _UnitSimplexBase3D(_GeometricPrimitive3D):
2455  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 3 > class."""
2456 
2457  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2458 
2459  def __init__(self, *args, **kwargs):
2460  raise AttributeError("No constructor defined - class is abstract")
2461  __repr__ = _swig_repr
2462 
2463  def get_dimension(self):
2464  r"""get_dimension(_UnitSimplexBase3D self) -> int"""
2465  return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)
2466 
2467  def get_barycenter(self):
2468  r"""get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
2469  return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)
2470 
2471  def get_contains(self, *args):
2472  r"""get_contains(_UnitSimplexBase3D self, Vector3D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2473  return _IMP_algebra._UnitSimplexBase3D_get_contains(self, *args)
2474  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase3D
2475 
2476 # Register _UnitSimplexBase3D in _IMP_algebra:
2477 _IMP_algebra._UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
2478 class _UnitSimplexBase4D(_GeometricPrimitive4D):
2479  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 4 > class."""
2480 
2481  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2482 
2483  def __init__(self, *args, **kwargs):
2484  raise AttributeError("No constructor defined - class is abstract")
2485  __repr__ = _swig_repr
2486 
2487  def get_dimension(self):
2488  r"""get_dimension(_UnitSimplexBase4D self) -> int"""
2489  return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)
2490 
2491  def get_barycenter(self):
2492  r"""get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
2493  return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)
2494 
2495  def get_contains(self, *args):
2496  r"""get_contains(_UnitSimplexBase4D self, Vector4D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2497  return _IMP_algebra._UnitSimplexBase4D_get_contains(self, *args)
2498  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase4D
2499 
2500 # Register _UnitSimplexBase4D in _IMP_algebra:
2501 _IMP_algebra._UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
2502 class _UnitSimplexBase5D(_GeometricPrimitive5D):
2503  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 5 > class."""
2504 
2505  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2506 
2507  def __init__(self, *args, **kwargs):
2508  raise AttributeError("No constructor defined - class is abstract")
2509  __repr__ = _swig_repr
2510 
2511  def get_dimension(self):
2512  r"""get_dimension(_UnitSimplexBase5D self) -> int"""
2513  return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)
2514 
2515  def get_barycenter(self):
2516  r"""get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
2517  return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)
2518 
2519  def get_contains(self, *args):
2520  r"""get_contains(_UnitSimplexBase5D self, Vector5D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2521  return _IMP_algebra._UnitSimplexBase5D_get_contains(self, *args)
2522  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase5D
2523 
2524 # Register _UnitSimplexBase5D in _IMP_algebra:
2525 _IMP_algebra._UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
2526 class _UnitSimplexBase6D(_GeometricPrimitive6D):
2527  r"""Proxy of C++ IMP::algebra::UnitSimplexBaseD< 6 > class."""
2528 
2529  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2530 
2531  def __init__(self, *args, **kwargs):
2532  raise AttributeError("No constructor defined - class is abstract")
2533  __repr__ = _swig_repr
2534 
2535  def get_dimension(self):
2536  r"""get_dimension(_UnitSimplexBase6D self) -> int"""
2537  return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)
2538 
2539  def get_barycenter(self):
2540  r"""get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
2541  return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)
2542 
2543  def get_contains(self, *args):
2544  r"""get_contains(_UnitSimplexBase6D self, Vector6D p, double atol=std::numeric_limits< double >::epsilon()) -> bool"""
2545  return _IMP_algebra._UnitSimplexBase6D_get_contains(self, *args)
2546  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase6D
2547 
2548 # Register _UnitSimplexBase6D in _IMP_algebra:
2549 _IMP_algebra._UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
2550 class Vector1D(_VectorBase1D):
2551  r"""Proxy of C++ IMP::algebra::VectorD< 1 > class."""
2552 
2553  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2554 
2555  def get_unit_vector(self):
2556  r"""get_unit_vector(Vector1D self) -> Vector1D"""
2557  return _IMP_algebra.Vector1D_get_unit_vector(self)
2558 
2559  def __truediv__(self, *args):
2560  return _IMP_algebra.Vector1D___truediv__(self, *args)
2561  __div__ = __truediv__
2562 
2563 
2564 
2565  def __neg__(self):
2566  r"""__neg__(Vector1D self) -> Vector1D"""
2567  return _IMP_algebra.Vector1D___neg__(self)
2568 
2569  def __sub__(self, o):
2570  r"""__sub__(Vector1D self, Vector1D o) -> Vector1D"""
2571  return _IMP_algebra.Vector1D___sub__(self, o)
2572 
2573  def __add__(self, ret):
2574  r"""__add__(Vector1D self, Vector1D ret) -> Vector1D"""
2575  return _IMP_algebra.Vector1D___add__(self, ret)
2576 
2577  def __mul__(self, *args):
2578  r"""
2579  __mul__(Vector1D self, double s) -> Vector1D
2580  __mul__(Vector1D self, Vector1D o) -> double
2581  """
2582  return _IMP_algebra.Vector1D___mul__(self, *args)
2583 
2584  def __init__(self, *args):
2585  r"""
2586  __init__(Vector1D self, IMP::Floats const & f) -> Vector1D
2587  __init__(Vector1D self) -> Vector1D
2588  __init__(Vector1D self, double x) -> Vector1D
2589  """
2590  _IMP_algebra.Vector1D_swiginit(self, _IMP_algebra.new_Vector1D(*args))
2591 
2592  def __iadd__(self, *args):
2593  _IMP_algebra.Vector1D___iadd__(self, *args)
2594  return self
2595 
2596 
2597 
2598  def __imul__(self, *args):
2599  _IMP_algebra.Vector1D___imul__(self, *args)
2600  return self
2601 
2602 
2603 
2604  def __idiv__(self, *args):
2605  _IMP_algebra.Vector1D___idiv__(self, *args)
2606  return self
2607 
2608 
2609 
2610  def __isub__(self, *args):
2611  _IMP_algebra.Vector1D___isub__(self, *args)
2612  return self
2613 
2614 
2615 
2616  def __len__(self):
2617  r"""__len__(Vector1D self) -> unsigned int"""
2618  return _IMP_algebra.Vector1D___len__(self)
2619 
2620  def __rmul__(self, f):
2621  r"""__rmul__(Vector1D self, double f) -> Vector1D"""
2622  return _IMP_algebra.Vector1D___rmul__(self, f)
2623 
2624  def __str__(self):
2625  r"""__str__(Vector1D self) -> std::string"""
2626  return _IMP_algebra.Vector1D___str__(self)
2627 
2628  def __repr__(self):
2629  r"""__repr__(Vector1D self) -> std::string"""
2630  return _IMP_algebra.Vector1D___repr__(self)
2631 
2632  def __cmp__(self, arg2):
2633  r"""__cmp__(Vector1D self, Vector1D arg2) -> int"""
2634  return _IMP_algebra.Vector1D___cmp__(self, arg2)
2635 
2636  def __eq__(self, arg2):
2637  r"""__eq__(Vector1D self, Vector1D arg2) -> bool"""
2638  return _IMP_algebra.Vector1D___eq__(self, arg2)
2639 
2640  __truediv__ = __div__
2641  __itruediv__ = __idiv__
2642 
2643 
2644  def _get_as_binary(self):
2645  r"""_get_as_binary(Vector1D self) -> PyObject *"""
2646  return _IMP_algebra.Vector1D__get_as_binary(self)
2647 
2648  def _set_from_binary(self, p):
2649  r"""_set_from_binary(Vector1D self, PyObject * p)"""
2650  return _IMP_algebra.Vector1D__set_from_binary(self, p)
2651 
2652  def __getstate__(self):
2653  p = self._get_as_binary()
2654  if len(self.__dict__) > 1:
2655  d = self.__dict__.copy()
2656  del d['this']
2657  p = (d, p)
2658  return p
2659 
2660  def __setstate__(self, p):
2661  if not hasattr(self, 'this'):
2662  self.__init__()
2663  if isinstance(p, tuple):
2664  d, p = p
2665  self.__dict__.update(d)
2666  return self._set_from_binary(p)
2667 
2668 
2669  def __getitem__(self, index):
2670  r"""__getitem__(Vector1D self, int index) -> double"""
2671  return _IMP_algebra.Vector1D___getitem__(self, index)
2672 
2673  def __setitem__(self, index, val):
2674  r"""__setitem__(Vector1D self, int index, double val)"""
2675  return _IMP_algebra.Vector1D___setitem__(self, index, val)
2676  __swig_destroy__ = _IMP_algebra.delete_Vector1D
2677 
2678 # Register Vector1D in _IMP_algebra:
2679 _IMP_algebra.Vector1D_swigregister(Vector1D)
2680 class Vector2D(_VectorBase2D):
2681  r"""Proxy of C++ IMP::algebra::VectorD< 2 > class."""
2682 
2683  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2684 
2685  def get_unit_vector(self):
2686  r"""get_unit_vector(Vector2D self) -> Vector2D"""
2687  return _IMP_algebra.Vector2D_get_unit_vector(self)
2688 
2689  def __truediv__(self, *args):
2690  return _IMP_algebra.Vector2D___truediv__(self, *args)
2691  __div__ = __truediv__
2692 
2693 
2694 
2695  def __neg__(self):
2696  r"""__neg__(Vector2D self) -> Vector2D"""
2697  return _IMP_algebra.Vector2D___neg__(self)
2698 
2699  def __sub__(self, o):
2700  r"""__sub__(Vector2D self, Vector2D o) -> Vector2D"""
2701  return _IMP_algebra.Vector2D___sub__(self, o)
2702 
2703  def __add__(self, ret):
2704  r"""__add__(Vector2D self, Vector2D ret) -> Vector2D"""
2705  return _IMP_algebra.Vector2D___add__(self, ret)
2706 
2707  def __mul__(self, *args):
2708  r"""
2709  __mul__(Vector2D self, double s) -> Vector2D
2710  __mul__(Vector2D self, Vector2D o) -> double
2711  """
2712  return _IMP_algebra.Vector2D___mul__(self, *args)
2713 
2714  def __init__(self, *args):
2715  r"""
2716  __init__(Vector2D self, IMP::Floats const & f) -> Vector2D
2717  __init__(Vector2D self) -> Vector2D
2718  __init__(Vector2D self, double x, double y) -> Vector2D
2719  """
2720  _IMP_algebra.Vector2D_swiginit(self, _IMP_algebra.new_Vector2D(*args))
2721 
2722  def __iadd__(self, *args):
2723  _IMP_algebra.Vector2D___iadd__(self, *args)
2724  return self
2725 
2726 
2727 
2728  def __imul__(self, *args):
2729  _IMP_algebra.Vector2D___imul__(self, *args)
2730  return self
2731 
2732 
2733 
2734  def __idiv__(self, *args):
2735  _IMP_algebra.Vector2D___idiv__(self, *args)
2736  return self
2737 
2738 
2739 
2740  def __isub__(self, *args):
2741  _IMP_algebra.Vector2D___isub__(self, *args)
2742  return self
2743 
2744 
2745 
2746  def __len__(self):
2747  r"""__len__(Vector2D self) -> unsigned int"""
2748  return _IMP_algebra.Vector2D___len__(self)
2749 
2750  def __rmul__(self, f):
2751  r"""__rmul__(Vector2D self, double f) -> Vector2D"""
2752  return _IMP_algebra.Vector2D___rmul__(self, f)
2753 
2754  def __str__(self):
2755  r"""__str__(Vector2D self) -> std::string"""
2756  return _IMP_algebra.Vector2D___str__(self)
2757 
2758  def __repr__(self):
2759  r"""__repr__(Vector2D self) -> std::string"""
2760  return _IMP_algebra.Vector2D___repr__(self)
2761 
2762  def __cmp__(self, arg2):
2763  r"""__cmp__(Vector2D self, Vector2D arg2) -> int"""
2764  return _IMP_algebra.Vector2D___cmp__(self, arg2)
2765 
2766  def __eq__(self, arg2):
2767  r"""__eq__(Vector2D self, Vector2D arg2) -> bool"""
2768  return _IMP_algebra.Vector2D___eq__(self, arg2)
2769 
2770  __truediv__ = __div__
2771  __itruediv__ = __idiv__
2772 
2773 
2774  def _get_as_binary(self):
2775  r"""_get_as_binary(Vector2D self) -> PyObject *"""
2776  return _IMP_algebra.Vector2D__get_as_binary(self)
2777 
2778  def _set_from_binary(self, p):
2779  r"""_set_from_binary(Vector2D self, PyObject * p)"""
2780  return _IMP_algebra.Vector2D__set_from_binary(self, p)
2781 
2782  def __getstate__(self):
2783  p = self._get_as_binary()
2784  if len(self.__dict__) > 1:
2785  d = self.__dict__.copy()
2786  del d['this']
2787  p = (d, p)
2788  return p
2789 
2790  def __setstate__(self, p):
2791  if not hasattr(self, 'this'):
2792  self.__init__()
2793  if isinstance(p, tuple):
2794  d, p = p
2795  self.__dict__.update(d)
2796  return self._set_from_binary(p)
2797 
2798 
2799  def __getitem__(self, index):
2800  r"""__getitem__(Vector2D self, int index) -> double"""
2801  return _IMP_algebra.Vector2D___getitem__(self, index)
2802 
2803  def __setitem__(self, index, val):
2804  r"""__setitem__(Vector2D self, int index, double val)"""
2805  return _IMP_algebra.Vector2D___setitem__(self, index, val)
2806  __swig_destroy__ = _IMP_algebra.delete_Vector2D
2807 
2808 # Register Vector2D in _IMP_algebra:
2809 _IMP_algebra.Vector2D_swigregister(Vector2D)
2810 class Vector3D(_VectorBase3D):
2811  r"""Proxy of C++ IMP::algebra::VectorD< 3 > class."""
2812 
2813  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2814 
2815  def get_unit_vector(self):
2816  r"""get_unit_vector(Vector3D self) -> Vector3D"""
2817  return _IMP_algebra.Vector3D_get_unit_vector(self)
2818 
2819  def __truediv__(self, *args):
2820  return _IMP_algebra.Vector3D___truediv__(self, *args)
2821  __div__ = __truediv__
2822 
2823 
2824 
2825  def __neg__(self):
2826  r"""__neg__(Vector3D self) -> Vector3D"""
2827  return _IMP_algebra.Vector3D___neg__(self)
2828 
2829  def __sub__(self, o):
2830  r"""__sub__(Vector3D self, Vector3D o) -> Vector3D"""
2831  return _IMP_algebra.Vector3D___sub__(self, o)
2832 
2833  def __add__(self, ret):
2834  r"""__add__(Vector3D self, Vector3D ret) -> Vector3D"""
2835  return _IMP_algebra.Vector3D___add__(self, ret)
2836 
2837  def __mul__(self, *args):
2838  r"""
2839  __mul__(Vector3D self, double s) -> Vector3D
2840  __mul__(Vector3D self, Vector3D o) -> double
2841  """
2842  return _IMP_algebra.Vector3D___mul__(self, *args)
2843 
2844  def __init__(self, *args):
2845  r"""
2846  __init__(Vector3D self, IMP::Floats const & f) -> Vector3D
2847  __init__(Vector3D self) -> Vector3D
2848  __init__(Vector3D self, double x, double y, double z) -> Vector3D
2849  """
2850  _IMP_algebra.Vector3D_swiginit(self, _IMP_algebra.new_Vector3D(*args))
2851 
2852  def __iadd__(self, *args):
2853  _IMP_algebra.Vector3D___iadd__(self, *args)
2854  return self
2855 
2856 
2857 
2858  def __imul__(self, *args):
2859  _IMP_algebra.Vector3D___imul__(self, *args)
2860  return self
2861 
2862 
2863 
2864  def __idiv__(self, *args):
2865  _IMP_algebra.Vector3D___idiv__(self, *args)
2866  return self
2867 
2868 
2869 
2870  def __isub__(self, *args):
2871  _IMP_algebra.Vector3D___isub__(self, *args)
2872  return self
2873 
2874 
2875 
2876  def __len__(self):
2877  r"""__len__(Vector3D self) -> unsigned int"""
2878  return _IMP_algebra.Vector3D___len__(self)
2879 
2880  def __rmul__(self, f):
2881  r"""__rmul__(Vector3D self, double f) -> Vector3D"""
2882  return _IMP_algebra.Vector3D___rmul__(self, f)
2883 
2884  def __str__(self):
2885  r"""__str__(Vector3D self) -> std::string"""
2886  return _IMP_algebra.Vector3D___str__(self)
2887 
2888  def __repr__(self):
2889  r"""__repr__(Vector3D self) -> std::string"""
2890  return _IMP_algebra.Vector3D___repr__(self)
2891 
2892  def __cmp__(self, arg2):
2893  r"""__cmp__(Vector3D self, Vector3D arg2) -> int"""
2894  return _IMP_algebra.Vector3D___cmp__(self, arg2)
2895 
2896  def __eq__(self, arg2):
2897  r"""__eq__(Vector3D self, Vector3D arg2) -> bool"""
2898  return _IMP_algebra.Vector3D___eq__(self, arg2)
2899 
2900  __truediv__ = __div__
2901  __itruediv__ = __idiv__
2902 
2903 
2904  def _get_as_binary(self):
2905  r"""_get_as_binary(Vector3D self) -> PyObject *"""
2906  return _IMP_algebra.Vector3D__get_as_binary(self)
2907 
2908  def _set_from_binary(self, p):
2909  r"""_set_from_binary(Vector3D self, PyObject * p)"""
2910  return _IMP_algebra.Vector3D__set_from_binary(self, p)
2911 
2912  def __getstate__(self):
2913  p = self._get_as_binary()
2914  if len(self.__dict__) > 1:
2915  d = self.__dict__.copy()
2916  del d['this']
2917  p = (d, p)
2918  return p
2919 
2920  def __setstate__(self, p):
2921  if not hasattr(self, 'this'):
2922  self.__init__()
2923  if isinstance(p, tuple):
2924  d, p = p
2925  self.__dict__.update(d)
2926  return self._set_from_binary(p)
2927 
2928 
2929  def __getitem__(self, index):
2930  r"""__getitem__(Vector3D self, int index) -> double"""
2931  return _IMP_algebra.Vector3D___getitem__(self, index)
2932 
2933  def __setitem__(self, index, val):
2934  r"""__setitem__(Vector3D self, int index, double val)"""
2935  return _IMP_algebra.Vector3D___setitem__(self, index, val)
2936  __swig_destroy__ = _IMP_algebra.delete_Vector3D
2937 
2938 # Register Vector3D in _IMP_algebra:
2939 _IMP_algebra.Vector3D_swigregister(Vector3D)
2940 class Vector4D(_VectorBase4D):
2941  r"""Proxy of C++ IMP::algebra::VectorD< 4 > class."""
2942 
2943  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2944 
2945  def get_unit_vector(self):
2946  r"""get_unit_vector(Vector4D self) -> Vector4D"""
2947  return _IMP_algebra.Vector4D_get_unit_vector(self)
2948 
2949  def __truediv__(self, *args):
2950  return _IMP_algebra.Vector4D___truediv__(self, *args)
2951  __div__ = __truediv__
2952 
2953 
2954 
2955  def __neg__(self):
2956  r"""__neg__(Vector4D self) -> Vector4D"""
2957  return _IMP_algebra.Vector4D___neg__(self)
2958 
2959  def __sub__(self, o):
2960  r"""__sub__(Vector4D self, Vector4D o) -> Vector4D"""
2961  return _IMP_algebra.Vector4D___sub__(self, o)
2962 
2963  def __add__(self, ret):
2964  r"""__add__(Vector4D self, Vector4D ret) -> Vector4D"""
2965  return _IMP_algebra.Vector4D___add__(self, ret)
2966 
2967  def __mul__(self, *args):
2968  r"""
2969  __mul__(Vector4D self, double s) -> Vector4D
2970  __mul__(Vector4D self, Vector4D o) -> double
2971  """
2972  return _IMP_algebra.Vector4D___mul__(self, *args)
2973 
2974  def __init__(self, *args):
2975  r"""
2976  __init__(Vector4D self, IMP::Floats const & f) -> Vector4D
2977  __init__(Vector4D self) -> Vector4D
2978  __init__(Vector4D self, double x0, double x1, double x2, double x3) -> Vector4D
2979  """
2980  _IMP_algebra.Vector4D_swiginit(self, _IMP_algebra.new_Vector4D(*args))
2981 
2982  def __iadd__(self, *args):
2983  _IMP_algebra.Vector4D___iadd__(self, *args)
2984  return self
2985 
2986 
2987 
2988  def __imul__(self, *args):
2989  _IMP_algebra.Vector4D___imul__(self, *args)
2990  return self
2991 
2992 
2993 
2994  def __idiv__(self, *args):
2995  _IMP_algebra.Vector4D___idiv__(self, *args)
2996  return self
2997 
2998 
2999 
3000  def __isub__(self, *args):
3001  _IMP_algebra.Vector4D___isub__(self, *args)
3002  return self
3003 
3004 
3005 
3006  def __len__(self):
3007  r"""__len__(Vector4D self) -> unsigned int"""
3008  return _IMP_algebra.Vector4D___len__(self)
3009 
3010  def __rmul__(self, f):
3011  r"""__rmul__(Vector4D self, double f) -> Vector4D"""
3012  return _IMP_algebra.Vector4D___rmul__(self, f)
3013 
3014  def __str__(self):
3015  r"""__str__(Vector4D self) -> std::string"""
3016  return _IMP_algebra.Vector4D___str__(self)
3017 
3018  def __repr__(self):
3019  r"""__repr__(Vector4D self) -> std::string"""
3020  return _IMP_algebra.Vector4D___repr__(self)
3021 
3022  def __cmp__(self, arg2):
3023  r"""__cmp__(Vector4D self, Vector4D arg2) -> int"""
3024  return _IMP_algebra.Vector4D___cmp__(self, arg2)
3025 
3026  def __eq__(self, arg2):
3027  r"""__eq__(Vector4D self, Vector4D arg2) -> bool"""
3028  return _IMP_algebra.Vector4D___eq__(self, arg2)
3029 
3030  __truediv__ = __div__
3031  __itruediv__ = __idiv__
3032 
3033 
3034  def _get_as_binary(self):
3035  r"""_get_as_binary(Vector4D self) -> PyObject *"""
3036  return _IMP_algebra.Vector4D__get_as_binary(self)
3037 
3038  def _set_from_binary(self, p):
3039  r"""_set_from_binary(Vector4D self, PyObject * p)"""
3040  return _IMP_algebra.Vector4D__set_from_binary(self, p)
3041 
3042  def __getstate__(self):
3043  p = self._get_as_binary()
3044  if len(self.__dict__) > 1:
3045  d = self.__dict__.copy()
3046  del d['this']
3047  p = (d, p)
3048  return p
3049 
3050  def __setstate__(self, p):
3051  if not hasattr(self, 'this'):
3052  self.__init__()
3053  if isinstance(p, tuple):
3054  d, p = p
3055  self.__dict__.update(d)
3056  return self._set_from_binary(p)
3057 
3058 
3059  def __getitem__(self, index):
3060  r"""__getitem__(Vector4D self, int index) -> double"""
3061  return _IMP_algebra.Vector4D___getitem__(self, index)
3062 
3063  def __setitem__(self, index, val):
3064  r"""__setitem__(Vector4D self, int index, double val)"""
3065  return _IMP_algebra.Vector4D___setitem__(self, index, val)
3066  __swig_destroy__ = _IMP_algebra.delete_Vector4D
3067 
3068 # Register Vector4D in _IMP_algebra:
3069 _IMP_algebra.Vector4D_swigregister(Vector4D)
3070 class Vector5D(_VectorBase5D):
3071  r"""Proxy of C++ IMP::algebra::VectorD< 5 > class."""
3072 
3073  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3074 
3075  def get_unit_vector(self):
3076  r"""get_unit_vector(Vector5D self) -> Vector5D"""
3077  return _IMP_algebra.Vector5D_get_unit_vector(self)
3078 
3079  def __truediv__(self, *args):
3080  return _IMP_algebra.Vector5D___truediv__(self, *args)
3081  __div__ = __truediv__
3082 
3083 
3084 
3085  def __neg__(self):
3086  r"""__neg__(Vector5D self) -> Vector5D"""
3087  return _IMP_algebra.Vector5D___neg__(self)
3088 
3089  def __sub__(self, o):
3090  r"""__sub__(Vector5D self, Vector5D o) -> Vector5D"""
3091  return _IMP_algebra.Vector5D___sub__(self, o)
3092 
3093  def __add__(self, ret):
3094  r"""__add__(Vector5D self, Vector5D ret) -> Vector5D"""
3095  return _IMP_algebra.Vector5D___add__(self, ret)
3096 
3097  def __mul__(self, *args):
3098  r"""
3099  __mul__(Vector5D self, double s) -> Vector5D
3100  __mul__(Vector5D self, Vector5D o) -> double
3101  """
3102  return _IMP_algebra.Vector5D___mul__(self, *args)
3103 
3104  def __init__(self, *args):
3105  r"""
3106  __init__(Vector5D self, IMP::Floats const & f) -> Vector5D
3107  __init__(Vector5D self) -> Vector5D
3108  __init__(Vector5D self, double x0, double x1, double x2, double x3, double x4) -> Vector5D
3109  """
3110  _IMP_algebra.Vector5D_swiginit(self, _IMP_algebra.new_Vector5D(*args))
3111 
3112  def __iadd__(self, *args):
3113  _IMP_algebra.Vector5D___iadd__(self, *args)
3114  return self
3115 
3116 
3117 
3118  def __imul__(self, *args):
3119  _IMP_algebra.Vector5D___imul__(self, *args)
3120  return self
3121 
3122 
3123 
3124  def __idiv__(self, *args):
3125  _IMP_algebra.Vector5D___idiv__(self, *args)
3126  return self
3127 
3128 
3129 
3130  def __isub__(self, *args):
3131  _IMP_algebra.Vector5D___isub__(self, *args)
3132  return self
3133 
3134 
3135 
3136  def __len__(self):
3137  r"""__len__(Vector5D self) -> unsigned int"""
3138  return _IMP_algebra.Vector5D___len__(self)
3139 
3140  def __rmul__(self, f):
3141  r"""__rmul__(Vector5D self, double f) -> Vector5D"""
3142  return _IMP_algebra.Vector5D___rmul__(self, f)
3143 
3144  def __str__(self):
3145  r"""__str__(Vector5D self) -> std::string"""
3146  return _IMP_algebra.Vector5D___str__(self)
3147 
3148  def __repr__(self):
3149  r"""__repr__(Vector5D self) -> std::string"""
3150  return _IMP_algebra.Vector5D___repr__(self)
3151 
3152  def __cmp__(self, arg2):
3153  r"""__cmp__(Vector5D self, Vector5D arg2) -> int"""
3154  return _IMP_algebra.Vector5D___cmp__(self, arg2)
3155 
3156  def __eq__(self, arg2):
3157  r"""__eq__(Vector5D self, Vector5D arg2) -> bool"""
3158  return _IMP_algebra.Vector5D___eq__(self, arg2)
3159 
3160  __truediv__ = __div__
3161  __itruediv__ = __idiv__
3162 
3163 
3164  def _get_as_binary(self):
3165  r"""_get_as_binary(Vector5D self) -> PyObject *"""
3166  return _IMP_algebra.Vector5D__get_as_binary(self)
3167 
3168  def _set_from_binary(self, p):
3169  r"""_set_from_binary(Vector5D self, PyObject * p)"""
3170  return _IMP_algebra.Vector5D__set_from_binary(self, p)
3171 
3172  def __getstate__(self):
3173  p = self._get_as_binary()
3174  if len(self.__dict__) > 1:
3175  d = self.__dict__.copy()
3176  del d['this']
3177  p = (d, p)
3178  return p
3179 
3180  def __setstate__(self, p):
3181  if not hasattr(self, 'this'):
3182  self.__init__()
3183  if isinstance(p, tuple):
3184  d, p = p
3185  self.__dict__.update(d)
3186  return self._set_from_binary(p)
3187 
3188 
3189  def __getitem__(self, index):
3190  r"""__getitem__(Vector5D self, int index) -> double"""
3191  return _IMP_algebra.Vector5D___getitem__(self, index)
3192 
3193  def __setitem__(self, index, val):
3194  r"""__setitem__(Vector5D self, int index, double val)"""
3195  return _IMP_algebra.Vector5D___setitem__(self, index, val)
3196  __swig_destroy__ = _IMP_algebra.delete_Vector5D
3197 
3198 # Register Vector5D in _IMP_algebra:
3199 _IMP_algebra.Vector5D_swigregister(Vector5D)
3200 class Vector6D(_VectorBase6D):
3201  r"""Proxy of C++ IMP::algebra::VectorD< 6 > class."""
3202 
3203  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3204 
3205  def get_unit_vector(self):
3206  r"""get_unit_vector(Vector6D self) -> Vector6D"""
3207  return _IMP_algebra.Vector6D_get_unit_vector(self)
3208 
3209  def __truediv__(self, *args):
3210  return _IMP_algebra.Vector6D___truediv__(self, *args)
3211  __div__ = __truediv__
3212 
3213 
3214 
3215  def __neg__(self):
3216  r"""__neg__(Vector6D self) -> Vector6D"""
3217  return _IMP_algebra.Vector6D___neg__(self)
3218 
3219  def __sub__(self, o):
3220  r"""__sub__(Vector6D self, Vector6D o) -> Vector6D"""
3221  return _IMP_algebra.Vector6D___sub__(self, o)
3222 
3223  def __add__(self, ret):
3224  r"""__add__(Vector6D self, Vector6D ret) -> Vector6D"""
3225  return _IMP_algebra.Vector6D___add__(self, ret)
3226 
3227  def __mul__(self, *args):
3228  r"""
3229  __mul__(Vector6D self, double s) -> Vector6D
3230  __mul__(Vector6D self, Vector6D o) -> double
3231  """
3232  return _IMP_algebra.Vector6D___mul__(self, *args)
3233 
3234  def __init__(self, *args):
3235  r"""
3236  __init__(Vector6D self, IMP::Floats const & f) -> Vector6D
3237  __init__(Vector6D self) -> Vector6D
3238  __init__(Vector6D self, double x0, double x1, double x2, double x3, double x4, double x5) -> Vector6D
3239  """
3240  _IMP_algebra.Vector6D_swiginit(self, _IMP_algebra.new_Vector6D(*args))
3241 
3242  def __iadd__(self, *args):
3243  _IMP_algebra.Vector6D___iadd__(self, *args)
3244  return self
3245 
3246 
3247 
3248  def __imul__(self, *args):
3249  _IMP_algebra.Vector6D___imul__(self, *args)
3250  return self
3251 
3252 
3253 
3254  def __idiv__(self, *args):
3255  _IMP_algebra.Vector6D___idiv__(self, *args)
3256  return self
3257 
3258 
3259 
3260  def __isub__(self, *args):
3261  _IMP_algebra.Vector6D___isub__(self, *args)
3262  return self
3263 
3264 
3265 
3266  def __len__(self):
3267  r"""__len__(Vector6D self) -> unsigned int"""
3268  return _IMP_algebra.Vector6D___len__(self)
3269 
3270  def __rmul__(self, f):
3271  r"""__rmul__(Vector6D self, double f) -> Vector6D"""
3272  return _IMP_algebra.Vector6D___rmul__(self, f)
3273 
3274  def __str__(self):
3275  r"""__str__(Vector6D self) -> std::string"""
3276  return _IMP_algebra.Vector6D___str__(self)
3277 
3278  def __repr__(self):
3279  r"""__repr__(Vector6D self) -> std::string"""
3280  return _IMP_algebra.Vector6D___repr__(self)
3281 
3282  def __cmp__(self, arg2):
3283  r"""__cmp__(Vector6D self, Vector6D arg2) -> int"""
3284  return _IMP_algebra.Vector6D___cmp__(self, arg2)
3285 
3286  def __eq__(self, arg2):
3287  r"""__eq__(Vector6D self, Vector6D arg2) -> bool"""
3288  return _IMP_algebra.Vector6D___eq__(self, arg2)
3289 
3290  __truediv__ = __div__
3291  __itruediv__ = __idiv__
3292 
3293 
3294  def _get_as_binary(self):
3295  r"""_get_as_binary(Vector6D self) -> PyObject *"""
3296  return _IMP_algebra.Vector6D__get_as_binary(self)
3297 
3298  def _set_from_binary(self, p):
3299  r"""_set_from_binary(Vector6D self, PyObject * p)"""
3300  return _IMP_algebra.Vector6D__set_from_binary(self, p)
3301 
3302  def __getstate__(self):
3303  p = self._get_as_binary()
3304  if len(self.__dict__) > 1:
3305  d = self.__dict__.copy()
3306  del d['this']
3307  p = (d, p)
3308  return p
3309 
3310  def __setstate__(self, p):
3311  if not hasattr(self, 'this'):
3312  self.__init__()
3313  if isinstance(p, tuple):
3314  d, p = p
3315  self.__dict__.update(d)
3316  return self._set_from_binary(p)
3317 
3318 
3319  def __getitem__(self, index):
3320  r"""__getitem__(Vector6D self, int index) -> double"""
3321  return _IMP_algebra.Vector6D___getitem__(self, index)
3322 
3323  def __setitem__(self, index, val):
3324  r"""__setitem__(Vector6D self, int index, double val)"""
3325  return _IMP_algebra.Vector6D___setitem__(self, index, val)
3326  __swig_destroy__ = _IMP_algebra.delete_Vector6D
3327 
3328 # Register Vector6D in _IMP_algebra:
3329 _IMP_algebra.Vector6D_swigregister(Vector6D)
3330 class VectorKD(_VectorBaseKD):
3331  r"""Proxy of C++ IMP::algebra::VectorD< -1 > class."""
3332 
3333  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3334 
3335  def get_unit_vector(self):
3336  r"""get_unit_vector(VectorKD self) -> VectorKD"""
3337  return _IMP_algebra.VectorKD_get_unit_vector(self)
3338 
3339  def __truediv__(self, *args):
3340  return _IMP_algebra.VectorKD___truediv__(self, *args)
3341  __div__ = __truediv__
3342 
3343 
3344 
3345  def __neg__(self):
3346  r"""__neg__(VectorKD self) -> VectorKD"""
3347  return _IMP_algebra.VectorKD___neg__(self)
3348 
3349  def __sub__(self, o):
3350  r"""__sub__(VectorKD self, VectorKD o) -> VectorKD"""
3351  return _IMP_algebra.VectorKD___sub__(self, o)
3352 
3353  def __add__(self, ret):
3354  r"""__add__(VectorKD self, VectorKD ret) -> VectorKD"""
3355  return _IMP_algebra.VectorKD___add__(self, ret)
3356 
3357  def __mul__(self, *args):
3358  r"""
3359  __mul__(VectorKD self, double s) -> VectorKD
3360  __mul__(VectorKD self, VectorKD o) -> double
3361  """
3362  return _IMP_algebra.VectorKD___mul__(self, *args)
3363 
3364  def __init__(self, *args):
3365  r"""
3366  __init__(VectorKD self, IMP::Floats const & f) -> VectorKD
3367  __init__(VectorKD self) -> VectorKD
3368  __init__(VectorKD self, double x0, double x1=std::numeric_limits< double >::max(), double x2=std::numeric_limits< double >::max(), double x3=std::numeric_limits< double >::max(), double x4=std::numeric_limits< double >::max(), double x5=std::numeric_limits< double >::max()) -> VectorKD
3369  """
3370  _IMP_algebra.VectorKD_swiginit(self, _IMP_algebra.new_VectorKD(*args))
3371 
3372  def __iadd__(self, *args):
3373  _IMP_algebra.VectorKD___iadd__(self, *args)
3374  return self
3375 
3376 
3377 
3378  def __imul__(self, *args):
3379  _IMP_algebra.VectorKD___imul__(self, *args)
3380  return self
3381 
3382 
3383 
3384  def __idiv__(self, *args):
3385  _IMP_algebra.VectorKD___idiv__(self, *args)
3386  return self
3387 
3388 
3389 
3390  def __isub__(self, *args):
3391  _IMP_algebra.VectorKD___isub__(self, *args)
3392  return self
3393 
3394 
3395 
3396  def __len__(self):
3397  r"""__len__(VectorKD self) -> unsigned int"""
3398  return _IMP_algebra.VectorKD___len__(self)
3399 
3400  def __rmul__(self, f):
3401  r"""__rmul__(VectorKD self, double f) -> VectorKD"""
3402  return _IMP_algebra.VectorKD___rmul__(self, f)
3403 
3404  def __str__(self):
3405  r"""__str__(VectorKD self) -> std::string"""
3406  return _IMP_algebra.VectorKD___str__(self)
3407 
3408  def __repr__(self):
3409  r"""__repr__(VectorKD self) -> std::string"""
3410  return _IMP_algebra.VectorKD___repr__(self)
3411 
3412  def __cmp__(self, arg2):
3413  r"""__cmp__(VectorKD self, VectorKD arg2) -> int"""
3414  return _IMP_algebra.VectorKD___cmp__(self, arg2)
3415 
3416  def __eq__(self, arg2):
3417  r"""__eq__(VectorKD self, VectorKD arg2) -> bool"""
3418  return _IMP_algebra.VectorKD___eq__(self, arg2)
3419 
3420  __truediv__ = __div__
3421  __itruediv__ = __idiv__
3422 
3423 
3424  def _get_as_binary(self):
3425  r"""_get_as_binary(VectorKD self) -> PyObject *"""
3426  return _IMP_algebra.VectorKD__get_as_binary(self)
3427 
3428  def _set_from_binary(self, p):
3429  r"""_set_from_binary(VectorKD self, PyObject * p)"""
3430  return _IMP_algebra.VectorKD__set_from_binary(self, p)
3431 
3432  def __getstate__(self):
3433  p = self._get_as_binary()
3434  if len(self.__dict__) > 1:
3435  d = self.__dict__.copy()
3436  del d['this']
3437  p = (d, p)
3438  return p
3439 
3440  def __setstate__(self, p):
3441  if not hasattr(self, 'this'):
3442  self.__init__()
3443  if isinstance(p, tuple):
3444  d, p = p
3445  self.__dict__.update(d)
3446  return self._set_from_binary(p)
3447 
3448 
3449  def __getitem__(self, index):
3450  r"""__getitem__(VectorKD self, int index) -> double"""
3451  return _IMP_algebra.VectorKD___getitem__(self, index)
3452 
3453  def __setitem__(self, index, val):
3454  r"""__setitem__(VectorKD self, int index, double val)"""
3455  return _IMP_algebra.VectorKD___setitem__(self, index, val)
3456  __swig_destroy__ = _IMP_algebra.delete_VectorKD
3457 
3458 # Register VectorKD in _IMP_algebra:
3459 _IMP_algebra.VectorKD_swigregister(VectorKD)
3460 class BoundingBox1D(object):
3461  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 1 > class."""
3462 
3463  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3464 
3465  def get_dimension(self):
3466  r"""get_dimension(BoundingBox1D self) -> unsigned int"""
3467  return _IMP_algebra.BoundingBox1D_get_dimension(self)
3468 
3469  def get_corner(self, i):
3470  r"""get_corner(BoundingBox1D self, unsigned int i) -> Vector1D"""
3471  return _IMP_algebra.BoundingBox1D_get_corner(self, i)
3472 
3473  def get_contains(self, *args):
3474  r"""
3475  get_contains(BoundingBox1D self, Vector1D o) -> bool
3476  get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
3477  """
3478  return _IMP_algebra.BoundingBox1D_get_contains(self, *args)
3479 
3480  def show(self, *args):
3481  r"""show(BoundingBox1D self, _ostream out=std::cout)"""
3482  return _IMP_algebra.BoundingBox1D_show(self, *args)
3483 
3484  def __str__(self):
3485  r"""__str__(BoundingBox1D self) -> std::string"""
3486  return _IMP_algebra.BoundingBox1D___str__(self)
3487 
3488  def __repr__(self):
3489  r"""__repr__(BoundingBox1D self) -> std::string"""
3490  return _IMP_algebra.BoundingBox1D___repr__(self)
3491 
3492  def __cmp__(self, arg2):
3493  r"""__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
3494  return _IMP_algebra.BoundingBox1D___cmp__(self, arg2)
3495 
3496  def __eq__(self, arg2):
3497  r"""__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
3498  return _IMP_algebra.BoundingBox1D___eq__(self, arg2)
3499 
3500  def __init__(self, *args):
3501  r"""
3502  __init__(BoundingBox1D self, unsigned int d) -> BoundingBox1D
3503  __init__(BoundingBox1D self, Vector1D lb, Vector1D ub) -> BoundingBox1D
3504  __init__(BoundingBox1D self, Vector1D v) -> BoundingBox1D
3505  __init__(BoundingBox1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
3506  __init__(BoundingBox1D self) -> BoundingBox1D
3507  """
3508  _IMP_algebra.BoundingBox1D_swiginit(self, _IMP_algebra.new_BoundingBox1D(*args))
3509 
3510  def __getitem__(self, index):
3511  r"""__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
3512  return _IMP_algebra.BoundingBox1D___getitem__(self, index)
3513 
3514  def __iadd__(self, *args):
3515  _IMP_algebra.BoundingBox1D___iadd__(self, *args)
3516  return self
3517 
3518 
3519 
3520  def __len__(self):
3521  r"""__len__(BoundingBox1D self) -> unsigned int"""
3522  return _IMP_algebra.BoundingBox1D___len__(self)
3523 
3524  def __add__(self, *args):
3525  r"""
3526  __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
3527  __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
3528  __add__(BoundingBox1D self, double o) -> BoundingBox1D
3529  """
3530  return _IMP_algebra.BoundingBox1D___add__(self, *args)
3531 
3532  def _get_as_binary(self):
3533  r"""_get_as_binary(BoundingBox1D self) -> PyObject *"""
3534  return _IMP_algebra.BoundingBox1D__get_as_binary(self)
3535 
3536  def _set_from_binary(self, p):
3537  r"""_set_from_binary(BoundingBox1D self, PyObject * p)"""
3538  return _IMP_algebra.BoundingBox1D__set_from_binary(self, p)
3539 
3540  def __getstate__(self):
3541  p = self._get_as_binary()
3542  if len(self.__dict__) > 1:
3543  d = self.__dict__.copy()
3544  del d['this']
3545  p = (d, p)
3546  return p
3547 
3548  def __setstate__(self, p):
3549  if not hasattr(self, 'this'):
3550  self.__init__()
3551  if isinstance(p, tuple):
3552  d, p = p
3553  self.__dict__.update(d)
3554  return self._set_from_binary(p)
3555 
3556  __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
3557 
3558 # Register BoundingBox1D in _IMP_algebra:
3559 _IMP_algebra.BoundingBox1D_swigregister(BoundingBox1D)
3560 class BoundingBox2D(object):
3561  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 2 > class."""
3562 
3563  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3564 
3565  def get_dimension(self):
3566  r"""get_dimension(BoundingBox2D self) -> unsigned int"""
3567  return _IMP_algebra.BoundingBox2D_get_dimension(self)
3568 
3569  def get_corner(self, i):
3570  r"""get_corner(BoundingBox2D self, unsigned int i) -> Vector2D"""
3571  return _IMP_algebra.BoundingBox2D_get_corner(self, i)
3572 
3573  def get_contains(self, *args):
3574  r"""
3575  get_contains(BoundingBox2D self, Vector2D o) -> bool
3576  get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
3577  """
3578  return _IMP_algebra.BoundingBox2D_get_contains(self, *args)
3579 
3580  def show(self, *args):
3581  r"""show(BoundingBox2D self, _ostream out=std::cout)"""
3582  return _IMP_algebra.BoundingBox2D_show(self, *args)
3583 
3584  def __str__(self):
3585  r"""__str__(BoundingBox2D self) -> std::string"""
3586  return _IMP_algebra.BoundingBox2D___str__(self)
3587 
3588  def __repr__(self):
3589  r"""__repr__(BoundingBox2D self) -> std::string"""
3590  return _IMP_algebra.BoundingBox2D___repr__(self)
3591 
3592  def __cmp__(self, arg2):
3593  r"""__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
3594  return _IMP_algebra.BoundingBox2D___cmp__(self, arg2)
3595 
3596  def __eq__(self, arg2):
3597  r"""__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
3598  return _IMP_algebra.BoundingBox2D___eq__(self, arg2)
3599 
3600  def __init__(self, *args):
3601  r"""
3602  __init__(BoundingBox2D self, unsigned int d) -> BoundingBox2D
3603  __init__(BoundingBox2D self, Vector2D lb, Vector2D ub) -> BoundingBox2D
3604  __init__(BoundingBox2D self, Vector2D v) -> BoundingBox2D
3605  __init__(BoundingBox2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
3606  __init__(BoundingBox2D self) -> BoundingBox2D
3607  """
3608  _IMP_algebra.BoundingBox2D_swiginit(self, _IMP_algebra.new_BoundingBox2D(*args))
3609 
3610  def __getitem__(self, index):
3611  r"""__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
3612  return _IMP_algebra.BoundingBox2D___getitem__(self, index)
3613 
3614  def __iadd__(self, *args):
3615  _IMP_algebra.BoundingBox2D___iadd__(self, *args)
3616  return self
3617 
3618 
3619 
3620  def __len__(self):
3621  r"""__len__(BoundingBox2D self) -> unsigned int"""
3622  return _IMP_algebra.BoundingBox2D___len__(self)
3623 
3624  def __add__(self, *args):
3625  r"""
3626  __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
3627  __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
3628  __add__(BoundingBox2D self, double o) -> BoundingBox2D
3629  """
3630  return _IMP_algebra.BoundingBox2D___add__(self, *args)
3631 
3632  def _get_as_binary(self):
3633  r"""_get_as_binary(BoundingBox2D self) -> PyObject *"""
3634  return _IMP_algebra.BoundingBox2D__get_as_binary(self)
3635 
3636  def _set_from_binary(self, p):
3637  r"""_set_from_binary(BoundingBox2D self, PyObject * p)"""
3638  return _IMP_algebra.BoundingBox2D__set_from_binary(self, p)
3639 
3640  def __getstate__(self):
3641  p = self._get_as_binary()
3642  if len(self.__dict__) > 1:
3643  d = self.__dict__.copy()
3644  del d['this']
3645  p = (d, p)
3646  return p
3647 
3648  def __setstate__(self, p):
3649  if not hasattr(self, 'this'):
3650  self.__init__()
3651  if isinstance(p, tuple):
3652  d, p = p
3653  self.__dict__.update(d)
3654  return self._set_from_binary(p)
3655 
3656  __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
3657 
3658 # Register BoundingBox2D in _IMP_algebra:
3659 _IMP_algebra.BoundingBox2D_swigregister(BoundingBox2D)
3660 class BoundingBox3D(object):
3661  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 3 > class."""
3662 
3663  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3664 
3665  def get_dimension(self):
3666  r"""get_dimension(BoundingBox3D self) -> unsigned int"""
3667  return _IMP_algebra.BoundingBox3D_get_dimension(self)
3668 
3669  def get_corner(self, i):
3670  r"""get_corner(BoundingBox3D self, unsigned int i) -> Vector3D"""
3671  return _IMP_algebra.BoundingBox3D_get_corner(self, i)
3672 
3673  def get_contains(self, *args):
3674  r"""
3675  get_contains(BoundingBox3D self, Vector3D o) -> bool
3676  get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
3677  """
3678  return _IMP_algebra.BoundingBox3D_get_contains(self, *args)
3679 
3680  def show(self, *args):
3681  r"""show(BoundingBox3D self, _ostream out=std::cout)"""
3682  return _IMP_algebra.BoundingBox3D_show(self, *args)
3683 
3684  def __str__(self):
3685  r"""__str__(BoundingBox3D self) -> std::string"""
3686  return _IMP_algebra.BoundingBox3D___str__(self)
3687 
3688  def __repr__(self):
3689  r"""__repr__(BoundingBox3D self) -> std::string"""
3690  return _IMP_algebra.BoundingBox3D___repr__(self)
3691 
3692  def __cmp__(self, arg2):
3693  r"""__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
3694  return _IMP_algebra.BoundingBox3D___cmp__(self, arg2)
3695 
3696  def __eq__(self, arg2):
3697  r"""__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
3698  return _IMP_algebra.BoundingBox3D___eq__(self, arg2)
3699 
3700  def __init__(self, *args):
3701  r"""
3702  __init__(BoundingBox3D self, unsigned int d) -> BoundingBox3D
3703  __init__(BoundingBox3D self, Vector3D lb, Vector3D ub) -> BoundingBox3D
3704  __init__(BoundingBox3D self, Vector3D v) -> BoundingBox3D
3705  __init__(BoundingBox3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
3706  __init__(BoundingBox3D self) -> BoundingBox3D
3707  """
3708  _IMP_algebra.BoundingBox3D_swiginit(self, _IMP_algebra.new_BoundingBox3D(*args))
3709 
3710  def __getitem__(self, index):
3711  r"""__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
3712  return _IMP_algebra.BoundingBox3D___getitem__(self, index)
3713 
3714  def __iadd__(self, *args):
3715  _IMP_algebra.BoundingBox3D___iadd__(self, *args)
3716  return self
3717 
3718 
3719 
3720  def __len__(self):
3721  r"""__len__(BoundingBox3D self) -> unsigned int"""
3722  return _IMP_algebra.BoundingBox3D___len__(self)
3723 
3724  def __add__(self, *args):
3725  r"""
3726  __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
3727  __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
3728  __add__(BoundingBox3D self, double o) -> BoundingBox3D
3729  """
3730  return _IMP_algebra.BoundingBox3D___add__(self, *args)
3731 
3732  def _get_as_binary(self):
3733  r"""_get_as_binary(BoundingBox3D self) -> PyObject *"""
3734  return _IMP_algebra.BoundingBox3D__get_as_binary(self)
3735 
3736  def _set_from_binary(self, p):
3737  r"""_set_from_binary(BoundingBox3D self, PyObject * p)"""
3738  return _IMP_algebra.BoundingBox3D__set_from_binary(self, p)
3739 
3740  def __getstate__(self):
3741  p = self._get_as_binary()
3742  if len(self.__dict__) > 1:
3743  d = self.__dict__.copy()
3744  del d['this']
3745  p = (d, p)
3746  return p
3747 
3748  def __setstate__(self, p):
3749  if not hasattr(self, 'this'):
3750  self.__init__()
3751  if isinstance(p, tuple):
3752  d, p = p
3753  self.__dict__.update(d)
3754  return self._set_from_binary(p)
3755 
3756  __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
3757 
3758 # Register BoundingBox3D in _IMP_algebra:
3759 _IMP_algebra.BoundingBox3D_swigregister(BoundingBox3D)
3760 class BoundingBox4D(object):
3761  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 4 > class."""
3762 
3763  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3764 
3765  def get_dimension(self):
3766  r"""get_dimension(BoundingBox4D self) -> unsigned int"""
3767  return _IMP_algebra.BoundingBox4D_get_dimension(self)
3768 
3769  def get_corner(self, i):
3770  r"""get_corner(BoundingBox4D self, unsigned int i) -> Vector4D"""
3771  return _IMP_algebra.BoundingBox4D_get_corner(self, i)
3772 
3773  def get_contains(self, *args):
3774  r"""
3775  get_contains(BoundingBox4D self, Vector4D o) -> bool
3776  get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
3777  """
3778  return _IMP_algebra.BoundingBox4D_get_contains(self, *args)
3779 
3780  def show(self, *args):
3781  r"""show(BoundingBox4D self, _ostream out=std::cout)"""
3782  return _IMP_algebra.BoundingBox4D_show(self, *args)
3783 
3784  def __str__(self):
3785  r"""__str__(BoundingBox4D self) -> std::string"""
3786  return _IMP_algebra.BoundingBox4D___str__(self)
3787 
3788  def __repr__(self):
3789  r"""__repr__(BoundingBox4D self) -> std::string"""
3790  return _IMP_algebra.BoundingBox4D___repr__(self)
3791 
3792  def __cmp__(self, arg2):
3793  r"""__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
3794  return _IMP_algebra.BoundingBox4D___cmp__(self, arg2)
3795 
3796  def __eq__(self, arg2):
3797  r"""__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
3798  return _IMP_algebra.BoundingBox4D___eq__(self, arg2)
3799 
3800  def __init__(self, *args):
3801  r"""
3802  __init__(BoundingBox4D self, unsigned int d) -> BoundingBox4D
3803  __init__(BoundingBox4D self, Vector4D lb, Vector4D ub) -> BoundingBox4D
3804  __init__(BoundingBox4D self, Vector4D v) -> BoundingBox4D
3805  __init__(BoundingBox4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
3806  __init__(BoundingBox4D self) -> BoundingBox4D
3807  """
3808  _IMP_algebra.BoundingBox4D_swiginit(self, _IMP_algebra.new_BoundingBox4D(*args))
3809 
3810  def __getitem__(self, index):
3811  r"""__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
3812  return _IMP_algebra.BoundingBox4D___getitem__(self, index)
3813 
3814  def __iadd__(self, *args):
3815  _IMP_algebra.BoundingBox4D___iadd__(self, *args)
3816  return self
3817 
3818 
3819 
3820  def __len__(self):
3821  r"""__len__(BoundingBox4D self) -> unsigned int"""
3822  return _IMP_algebra.BoundingBox4D___len__(self)
3823 
3824  def __add__(self, *args):
3825  r"""
3826  __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
3827  __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
3828  __add__(BoundingBox4D self, double o) -> BoundingBox4D
3829  """
3830  return _IMP_algebra.BoundingBox4D___add__(self, *args)
3831 
3832  def _get_as_binary(self):
3833  r"""_get_as_binary(BoundingBox4D self) -> PyObject *"""
3834  return _IMP_algebra.BoundingBox4D__get_as_binary(self)
3835 
3836  def _set_from_binary(self, p):
3837  r"""_set_from_binary(BoundingBox4D self, PyObject * p)"""
3838  return _IMP_algebra.BoundingBox4D__set_from_binary(self, p)
3839 
3840  def __getstate__(self):
3841  p = self._get_as_binary()
3842  if len(self.__dict__) > 1:
3843  d = self.__dict__.copy()
3844  del d['this']
3845  p = (d, p)
3846  return p
3847 
3848  def __setstate__(self, p):
3849  if not hasattr(self, 'this'):
3850  self.__init__()
3851  if isinstance(p, tuple):
3852  d, p = p
3853  self.__dict__.update(d)
3854  return self._set_from_binary(p)
3855 
3856  __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
3857 
3858 # Register BoundingBox4D in _IMP_algebra:
3859 _IMP_algebra.BoundingBox4D_swigregister(BoundingBox4D)
3860 class BoundingBox5D(object):
3861  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 5 > class."""
3862 
3863  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3864 
3865  def get_dimension(self):
3866  r"""get_dimension(BoundingBox5D self) -> unsigned int"""
3867  return _IMP_algebra.BoundingBox5D_get_dimension(self)
3868 
3869  def get_corner(self, i):
3870  r"""get_corner(BoundingBox5D self, unsigned int i) -> Vector5D"""
3871  return _IMP_algebra.BoundingBox5D_get_corner(self, i)
3872 
3873  def get_contains(self, *args):
3874  r"""
3875  get_contains(BoundingBox5D self, Vector5D o) -> bool
3876  get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
3877  """
3878  return _IMP_algebra.BoundingBox5D_get_contains(self, *args)
3879 
3880  def show(self, *args):
3881  r"""show(BoundingBox5D self, _ostream out=std::cout)"""
3882  return _IMP_algebra.BoundingBox5D_show(self, *args)
3883 
3884  def __str__(self):
3885  r"""__str__(BoundingBox5D self) -> std::string"""
3886  return _IMP_algebra.BoundingBox5D___str__(self)
3887 
3888  def __repr__(self):
3889  r"""__repr__(BoundingBox5D self) -> std::string"""
3890  return _IMP_algebra.BoundingBox5D___repr__(self)
3891 
3892  def __cmp__(self, arg2):
3893  r"""__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
3894  return _IMP_algebra.BoundingBox5D___cmp__(self, arg2)
3895 
3896  def __eq__(self, arg2):
3897  r"""__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
3898  return _IMP_algebra.BoundingBox5D___eq__(self, arg2)
3899 
3900  def __init__(self, *args):
3901  r"""
3902  __init__(BoundingBox5D self, unsigned int d) -> BoundingBox5D
3903  __init__(BoundingBox5D self, Vector5D lb, Vector5D ub) -> BoundingBox5D
3904  __init__(BoundingBox5D self, Vector5D v) -> BoundingBox5D
3905  __init__(BoundingBox5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
3906  __init__(BoundingBox5D self) -> BoundingBox5D
3907  """
3908  _IMP_algebra.BoundingBox5D_swiginit(self, _IMP_algebra.new_BoundingBox5D(*args))
3909 
3910  def __getitem__(self, index):
3911  r"""__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
3912  return _IMP_algebra.BoundingBox5D___getitem__(self, index)
3913 
3914  def __iadd__(self, *args):
3915  _IMP_algebra.BoundingBox5D___iadd__(self, *args)
3916  return self
3917 
3918 
3919 
3920  def __len__(self):
3921  r"""__len__(BoundingBox5D self) -> unsigned int"""
3922  return _IMP_algebra.BoundingBox5D___len__(self)
3923 
3924  def __add__(self, *args):
3925  r"""
3926  __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
3927  __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
3928  __add__(BoundingBox5D self, double o) -> BoundingBox5D
3929  """
3930  return _IMP_algebra.BoundingBox5D___add__(self, *args)
3931 
3932  def _get_as_binary(self):
3933  r"""_get_as_binary(BoundingBox5D self) -> PyObject *"""
3934  return _IMP_algebra.BoundingBox5D__get_as_binary(self)
3935 
3936  def _set_from_binary(self, p):
3937  r"""_set_from_binary(BoundingBox5D self, PyObject * p)"""
3938  return _IMP_algebra.BoundingBox5D__set_from_binary(self, p)
3939 
3940  def __getstate__(self):
3941  p = self._get_as_binary()
3942  if len(self.__dict__) > 1:
3943  d = self.__dict__.copy()
3944  del d['this']
3945  p = (d, p)
3946  return p
3947 
3948  def __setstate__(self, p):
3949  if not hasattr(self, 'this'):
3950  self.__init__()
3951  if isinstance(p, tuple):
3952  d, p = p
3953  self.__dict__.update(d)
3954  return self._set_from_binary(p)
3955 
3956  __swig_destroy__ = _IMP_algebra.delete_BoundingBox5D
3957 
3958 # Register BoundingBox5D in _IMP_algebra:
3959 _IMP_algebra.BoundingBox5D_swigregister(BoundingBox5D)
3960 class BoundingBox6D(object):
3961  r"""Proxy of C++ IMP::algebra::BoundingBoxD< 6 > class."""
3962 
3963  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3964 
3965  def get_dimension(self):
3966  r"""get_dimension(BoundingBox6D self) -> unsigned int"""
3967  return _IMP_algebra.BoundingBox6D_get_dimension(self)
3968 
3969  def get_corner(self, i):
3970  r"""get_corner(BoundingBox6D self, unsigned int i) -> Vector6D"""
3971  return _IMP_algebra.BoundingBox6D_get_corner(self, i)
3972 
3973  def get_contains(self, *args):
3974  r"""
3975  get_contains(BoundingBox6D self, Vector6D o) -> bool
3976  get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
3977  """
3978  return _IMP_algebra.BoundingBox6D_get_contains(self, *args)
3979 
3980  def show(self, *args):
3981  r"""show(BoundingBox6D self, _ostream out=std::cout)"""
3982  return _IMP_algebra.BoundingBox6D_show(self, *args)
3983 
3984  def __str__(self):
3985  r"""__str__(BoundingBox6D self) -> std::string"""
3986  return _IMP_algebra.BoundingBox6D___str__(self)
3987 
3988  def __repr__(self):
3989  r"""__repr__(BoundingBox6D self) -> std::string"""
3990  return _IMP_algebra.BoundingBox6D___repr__(self)
3991 
3992  def __cmp__(self, arg2):
3993  r"""__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
3994  return _IMP_algebra.BoundingBox6D___cmp__(self, arg2)
3995 
3996  def __eq__(self, arg2):
3997  r"""__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
3998  return _IMP_algebra.BoundingBox6D___eq__(self, arg2)
3999 
4000  def __init__(self, *args):
4001  r"""
4002  __init__(BoundingBox6D self, unsigned int d) -> BoundingBox6D
4003  __init__(BoundingBox6D self, Vector6D lb, Vector6D ub) -> BoundingBox6D
4004  __init__(BoundingBox6D self, Vector6D v) -> BoundingBox6D
4005  __init__(BoundingBox6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
4006  __init__(BoundingBox6D self) -> BoundingBox6D
4007  """
4008  _IMP_algebra.BoundingBox6D_swiginit(self, _IMP_algebra.new_BoundingBox6D(*args))
4009 
4010  def __getitem__(self, index):
4011  r"""__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
4012  return _IMP_algebra.BoundingBox6D___getitem__(self, index)
4013 
4014  def __iadd__(self, *args):
4015  _IMP_algebra.BoundingBox6D___iadd__(self, *args)
4016  return self
4017 
4018 
4019 
4020  def __len__(self):
4021  r"""__len__(BoundingBox6D self) -> unsigned int"""
4022  return _IMP_algebra.BoundingBox6D___len__(self)
4023 
4024  def __add__(self, *args):
4025  r"""
4026  __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
4027  __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
4028  __add__(BoundingBox6D self, double o) -> BoundingBox6D
4029  """
4030  return _IMP_algebra.BoundingBox6D___add__(self, *args)
4031 
4032  def _get_as_binary(self):
4033  r"""_get_as_binary(BoundingBox6D self) -> PyObject *"""
4034  return _IMP_algebra.BoundingBox6D__get_as_binary(self)
4035 
4036  def _set_from_binary(self, p):
4037  r"""_set_from_binary(BoundingBox6D self, PyObject * p)"""
4038  return _IMP_algebra.BoundingBox6D__set_from_binary(self, p)
4039 
4040  def __getstate__(self):
4041  p = self._get_as_binary()
4042  if len(self.__dict__) > 1:
4043  d = self.__dict__.copy()
4044  del d['this']
4045  p = (d, p)
4046  return p
4047 
4048  def __setstate__(self, p):
4049  if not hasattr(self, 'this'):
4050  self.__init__()
4051  if isinstance(p, tuple):
4052  d, p = p
4053  self.__dict__.update(d)
4054  return self._set_from_binary(p)
4055 
4056  __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
4057 
4058 # Register BoundingBox6D in _IMP_algebra:
4059 _IMP_algebra.BoundingBox6D_swigregister(BoundingBox6D)
4060 class BoundingBoxKD(object):
4061  r"""Proxy of C++ IMP::algebra::BoundingBoxD< -1 > class."""
4062 
4063  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4064 
4065  def get_dimension(self):
4066  r"""get_dimension(BoundingBoxKD self) -> unsigned int"""
4067  return _IMP_algebra.BoundingBoxKD_get_dimension(self)
4068 
4069  def get_corner(self, i):
4070  r"""get_corner(BoundingBoxKD self, unsigned int i) -> VectorKD"""
4071  return _IMP_algebra.BoundingBoxKD_get_corner(self, i)
4072 
4073  def get_contains(self, *args):
4074  r"""
4075  get_contains(BoundingBoxKD self, VectorKD o) -> bool
4076  get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
4077  """
4078  return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)
4079 
4080  def show(self, *args):
4081  r"""show(BoundingBoxKD self, _ostream out=std::cout)"""
4082  return _IMP_algebra.BoundingBoxKD_show(self, *args)
4083 
4084  def __str__(self):
4085  r"""__str__(BoundingBoxKD self) -> std::string"""
4086  return _IMP_algebra.BoundingBoxKD___str__(self)
4087 
4088  def __repr__(self):
4089  r"""__repr__(BoundingBoxKD self) -> std::string"""
4090  return _IMP_algebra.BoundingBoxKD___repr__(self)
4091 
4092  def __cmp__(self, arg2):
4093  r"""__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
4094  return _IMP_algebra.BoundingBoxKD___cmp__(self, arg2)
4095 
4096  def __eq__(self, arg2):
4097  r"""__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
4098  return _IMP_algebra.BoundingBoxKD___eq__(self, arg2)
4099 
4100  def __init__(self, *args):
4101  r"""
4102  __init__(BoundingBoxKD self, unsigned int d) -> BoundingBoxKD
4103  __init__(BoundingBoxKD self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
4104  __init__(BoundingBoxKD self, VectorKD v) -> BoundingBoxKD
4105  __init__(BoundingBoxKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
4106  __init__(BoundingBoxKD self) -> BoundingBoxKD
4107  """
4108  _IMP_algebra.BoundingBoxKD_swiginit(self, _IMP_algebra.new_BoundingBoxKD(*args))
4109 
4110  def __getitem__(self, index):
4111  r"""__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
4112  return _IMP_algebra.BoundingBoxKD___getitem__(self, index)
4113 
4114  def __iadd__(self, *args):
4115  _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
4116  return self
4117 
4118 
4119 
4120  def __len__(self):
4121  r"""__len__(BoundingBoxKD self) -> unsigned int"""
4122  return _IMP_algebra.BoundingBoxKD___len__(self)
4123 
4124  def __add__(self, *args):
4125  r"""
4126  __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
4127  __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
4128  __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
4129  """
4130  return _IMP_algebra.BoundingBoxKD___add__(self, *args)
4131 
4132  def _get_as_binary(self):
4133  r"""_get_as_binary(BoundingBoxKD self) -> PyObject *"""
4134  return _IMP_algebra.BoundingBoxKD__get_as_binary(self)
4135 
4136  def _set_from_binary(self, p):
4137  r"""_set_from_binary(BoundingBoxKD self, PyObject * p)"""
4138  return _IMP_algebra.BoundingBoxKD__set_from_binary(self, p)
4139 
4140  def __getstate__(self):
4141  p = self._get_as_binary()
4142  if len(self.__dict__) > 1:
4143  d = self.__dict__.copy()
4144  del d['this']
4145  p = (d, p)
4146  return p
4147 
4148  def __setstate__(self, p):
4149  if not hasattr(self, 'this'):
4150  self.__init__()
4151  if isinstance(p, tuple):
4152  d, p = p
4153  self.__dict__.update(d)
4154  return self._set_from_binary(p)
4155 
4156  __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
4157 
4158 # Register BoundingBoxKD in _IMP_algebra:
4159 _IMP_algebra.BoundingBoxKD_swigregister(BoundingBoxKD)
4160 class Sphere1D(_GeometricPrimitive1D):
4161  r"""Proxy of C++ IMP::algebra::SphereD< 1 > class."""
4162 
4163  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4164 
4165  def __init__(self, *args):
4166  r"""
4167  __init__(Sphere1D self) -> Sphere1D
4168  __init__(Sphere1D self, Vector1D center, double radius) -> Sphere1D
4169  """
4170  _IMP_algebra.Sphere1D_swiginit(self, _IMP_algebra.new_Sphere1D(*args))
4171 
4172  def get_radius(self):
4173  r"""get_radius(Sphere1D self) -> double"""
4174  return _IMP_algebra.Sphere1D_get_radius(self)
4175 
4176  def get_center(self):
4177  r"""get_center(Sphere1D self) -> Vector1D"""
4178  return _IMP_algebra.Sphere1D_get_center(self)
4179 
4180  def get_contains(self, *args):
4181  r"""
4182  get_contains(Sphere1D self, Sphere1D o) -> bool
4183  get_contains(Sphere1D self, Vector1D p) -> bool
4184  """
4185  return _IMP_algebra.Sphere1D_get_contains(self, *args)
4186 
4187  def show(self, *args):
4188  r"""show(Sphere1D self, _ostream out=std::cout)"""
4189  return _IMP_algebra.Sphere1D_show(self, *args)
4190 
4191  def get_dimension(self):
4192  r"""get_dimension(Sphere1D self) -> unsigned int"""
4193  return _IMP_algebra.Sphere1D_get_dimension(self)
4194 
4195  def __str__(self):
4196  r"""__str__(Sphere1D self) -> std::string"""
4197  return _IMP_algebra.Sphere1D___str__(self)
4198 
4199  def __repr__(self):
4200  r"""__repr__(Sphere1D self) -> std::string"""
4201  return _IMP_algebra.Sphere1D___repr__(self)
4202 
4203  def __cmp__(self, arg2):
4204  r"""__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
4205  return _IMP_algebra.Sphere1D___cmp__(self, arg2)
4206 
4207  def __eq__(self, arg2):
4208  r"""__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
4209  return _IMP_algebra.Sphere1D___eq__(self, arg2)
4210 
4211  def _get_as_binary(self):
4212  r"""_get_as_binary(Sphere1D self) -> PyObject *"""
4213  return _IMP_algebra.Sphere1D__get_as_binary(self)
4214 
4215  def _set_from_binary(self, p):
4216  r"""_set_from_binary(Sphere1D self, PyObject * p)"""
4217  return _IMP_algebra.Sphere1D__set_from_binary(self, p)
4218 
4219  def __getstate__(self):
4220  p = self._get_as_binary()
4221  if len(self.__dict__) > 1:
4222  d = self.__dict__.copy()
4223  del d['this']
4224  p = (d, p)
4225  return p
4226 
4227  def __setstate__(self, p):
4228  if not hasattr(self, 'this'):
4229  self.__init__()
4230  if isinstance(p, tuple):
4231  d, p = p
4232  self.__dict__.update(d)
4233  return self._set_from_binary(p)
4234 
4235  __swig_destroy__ = _IMP_algebra.delete_Sphere1D
4236 
4237 # Register Sphere1D in _IMP_algebra:
4238 _IMP_algebra.Sphere1D_swigregister(Sphere1D)
4239 class Sphere2D(_GeometricPrimitive2D):
4240  r"""Proxy of C++ IMP::algebra::SphereD< 2 > class."""
4241 
4242  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4243 
4244  def __init__(self, *args):
4245  r"""
4246  __init__(Sphere2D self) -> Sphere2D
4247  __init__(Sphere2D self, Vector2D center, double radius) -> Sphere2D
4248  """
4249  _IMP_algebra.Sphere2D_swiginit(self, _IMP_algebra.new_Sphere2D(*args))
4250 
4251  def get_radius(self):
4252  r"""get_radius(Sphere2D self) -> double"""
4253  return _IMP_algebra.Sphere2D_get_radius(self)
4254 
4255  def get_center(self):
4256  r"""get_center(Sphere2D self) -> Vector2D"""
4257  return _IMP_algebra.Sphere2D_get_center(self)
4258 
4259  def get_contains(self, *args):
4260  r"""
4261  get_contains(Sphere2D self, Sphere2D o) -> bool
4262  get_contains(Sphere2D self, Vector2D p) -> bool
4263  """
4264  return _IMP_algebra.Sphere2D_get_contains(self, *args)
4265 
4266  def show(self, *args):
4267  r"""show(Sphere2D self, _ostream out=std::cout)"""
4268  return _IMP_algebra.Sphere2D_show(self, *args)
4269 
4270  def get_dimension(self):
4271  r"""get_dimension(Sphere2D self) -> unsigned int"""
4272  return _IMP_algebra.Sphere2D_get_dimension(self)
4273 
4274  def __str__(self):
4275  r"""__str__(Sphere2D self) -> std::string"""
4276  return _IMP_algebra.Sphere2D___str__(self)
4277 
4278  def __repr__(self):
4279  r"""__repr__(Sphere2D self) -> std::string"""
4280  return _IMP_algebra.Sphere2D___repr__(self)
4281 
4282  def __cmp__(self, arg2):
4283  r"""__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
4284  return _IMP_algebra.Sphere2D___cmp__(self, arg2)
4285 
4286  def __eq__(self, arg2):
4287  r"""__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
4288  return _IMP_algebra.Sphere2D___eq__(self, arg2)
4289 
4290  def _get_as_binary(self):
4291  r"""_get_as_binary(Sphere2D self) -> PyObject *"""
4292  return _IMP_algebra.Sphere2D__get_as_binary(self)
4293 
4294  def _set_from_binary(self, p):
4295  r"""_set_from_binary(Sphere2D self, PyObject * p)"""
4296  return _IMP_algebra.Sphere2D__set_from_binary(self, p)
4297 
4298  def __getstate__(self):
4299  p = self._get_as_binary()
4300  if len(self.__dict__) > 1:
4301  d = self.__dict__.copy()
4302  del d['this']
4303  p = (d, p)
4304  return p
4305 
4306  def __setstate__(self, p):
4307  if not hasattr(self, 'this'):
4308  self.__init__()
4309  if isinstance(p, tuple):
4310  d, p = p
4311  self.__dict__.update(d)
4312  return self._set_from_binary(p)
4313 
4314  __swig_destroy__ = _IMP_algebra.delete_Sphere2D
4315 
4316 # Register Sphere2D in _IMP_algebra:
4317 _IMP_algebra.Sphere2D_swigregister(Sphere2D)
4318 class Sphere3D(_GeometricPrimitive3D):
4319  r"""Proxy of C++ IMP::algebra::SphereD< 3 > class."""
4320 
4321  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4322 
4323  def __init__(self, *args):
4324  r"""
4325  __init__(Sphere3D self) -> Sphere3D
4326  __init__(Sphere3D self, Vector3D center, double radius) -> Sphere3D
4327  """
4328  _IMP_algebra.Sphere3D_swiginit(self, _IMP_algebra.new_Sphere3D(*args))
4329 
4330  def get_radius(self):
4331  r"""get_radius(Sphere3D self) -> double"""
4332  return _IMP_algebra.Sphere3D_get_radius(self)
4333 
4334  def get_center(self):
4335  r"""get_center(Sphere3D self) -> Vector3D"""
4336  return _IMP_algebra.Sphere3D_get_center(self)
4337 
4338  def get_contains(self, *args):
4339  r"""
4340  get_contains(Sphere3D self, Sphere3D o) -> bool
4341  get_contains(Sphere3D self, Vector3D p) -> bool
4342  """
4343  return _IMP_algebra.Sphere3D_get_contains(self, *args)
4344 
4345  def show(self, *args):
4346  r"""show(Sphere3D self, _ostream out=std::cout)"""
4347  return _IMP_algebra.Sphere3D_show(self, *args)
4348 
4349  def get_dimension(self):
4350  r"""get_dimension(Sphere3D self) -> unsigned int"""
4351  return _IMP_algebra.Sphere3D_get_dimension(self)
4352 
4353  def __str__(self):
4354  r"""__str__(Sphere3D self) -> std::string"""
4355  return _IMP_algebra.Sphere3D___str__(self)
4356 
4357  def __repr__(self):
4358  r"""__repr__(Sphere3D self) -> std::string"""
4359  return _IMP_algebra.Sphere3D___repr__(self)
4360 
4361  def __cmp__(self, arg2):
4362  r"""__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
4363  return _IMP_algebra.Sphere3D___cmp__(self, arg2)
4364 
4365  def __eq__(self, arg2):
4366  r"""__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
4367  return _IMP_algebra.Sphere3D___eq__(self, arg2)
4368 
4369  def _get_as_binary(self):
4370  r"""_get_as_binary(Sphere3D self) -> PyObject *"""
4371  return _IMP_algebra.Sphere3D__get_as_binary(self)
4372 
4373  def _set_from_binary(self, p):
4374  r"""_set_from_binary(Sphere3D self, PyObject * p)"""
4375  return _IMP_algebra.Sphere3D__set_from_binary(self, p)
4376 
4377  def __getstate__(self):
4378  p = self._get_as_binary()
4379  if len(self.__dict__) > 1:
4380  d = self.__dict__.copy()
4381  del d['this']
4382  p = (d, p)
4383  return p
4384 
4385  def __setstate__(self, p):
4386  if not hasattr(self, 'this'):
4387  self.__init__()
4388  if isinstance(p, tuple):
4389  d, p = p
4390  self.__dict__.update(d)
4391  return self._set_from_binary(p)
4392 
4393  __swig_destroy__ = _IMP_algebra.delete_Sphere3D
4394 
4395 # Register Sphere3D in _IMP_algebra:
4396 _IMP_algebra.Sphere3D_swigregister(Sphere3D)
4397 class Sphere4D(_GeometricPrimitive4D):
4398  r"""Proxy of C++ IMP::algebra::SphereD< 4 > class."""
4399 
4400  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4401 
4402  def __init__(self, *args):
4403  r"""
4404  __init__(Sphere4D self) -> Sphere4D
4405  __init__(Sphere4D self, Vector4D center, double radius) -> Sphere4D
4406  """
4407  _IMP_algebra.Sphere4D_swiginit(self, _IMP_algebra.new_Sphere4D(*args))
4408 
4409  def get_radius(self):
4410  r"""get_radius(Sphere4D self) -> double"""
4411  return _IMP_algebra.Sphere4D_get_radius(self)
4412 
4413  def get_center(self):
4414  r"""get_center(Sphere4D self) -> Vector4D"""
4415  return _IMP_algebra.Sphere4D_get_center(self)
4416 
4417  def get_contains(self, *args):
4418  r"""
4419  get_contains(Sphere4D self, Sphere4D o) -> bool
4420  get_contains(Sphere4D self, Vector4D p) -> bool
4421  """
4422  return _IMP_algebra.Sphere4D_get_contains(self, *args)
4423 
4424  def show(self, *args):
4425  r"""show(Sphere4D self, _ostream out=std::cout)"""
4426  return _IMP_algebra.Sphere4D_show(self, *args)
4427 
4428  def get_dimension(self):
4429  r"""get_dimension(Sphere4D self) -> unsigned int"""
4430  return _IMP_algebra.Sphere4D_get_dimension(self)
4431 
4432  def __str__(self):
4433  r"""__str__(Sphere4D self) -> std::string"""
4434  return _IMP_algebra.Sphere4D___str__(self)
4435 
4436  def __repr__(self):
4437  r"""__repr__(Sphere4D self) -> std::string"""
4438  return _IMP_algebra.Sphere4D___repr__(self)
4439 
4440  def __cmp__(self, arg2):
4441  r"""__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
4442  return _IMP_algebra.Sphere4D___cmp__(self, arg2)
4443 
4444  def __eq__(self, arg2):
4445  r"""__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
4446  return _IMP_algebra.Sphere4D___eq__(self, arg2)
4447 
4448  def _get_as_binary(self):
4449  r"""_get_as_binary(Sphere4D self) -> PyObject *"""
4450  return _IMP_algebra.Sphere4D__get_as_binary(self)
4451 
4452  def _set_from_binary(self, p):
4453  r"""_set_from_binary(Sphere4D self, PyObject * p)"""
4454  return _IMP_algebra.Sphere4D__set_from_binary(self, p)
4455 
4456  def __getstate__(self):
4457  p = self._get_as_binary()
4458  if len(self.__dict__) > 1:
4459  d = self.__dict__.copy()
4460  del d['this']
4461  p = (d, p)
4462  return p
4463 
4464  def __setstate__(self, p):
4465  if not hasattr(self, 'this'):
4466  self.__init__()
4467  if isinstance(p, tuple):
4468  d, p = p
4469  self.__dict__.update(d)
4470  return self._set_from_binary(p)
4471 
4472  __swig_destroy__ = _IMP_algebra.delete_Sphere4D
4473 
4474 # Register Sphere4D in _IMP_algebra:
4475 _IMP_algebra.Sphere4D_swigregister(Sphere4D)
4476 class Sphere5D(_GeometricPrimitive5D):
4477  r"""Proxy of C++ IMP::algebra::SphereD< 5 > class."""
4478 
4479  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4480 
4481  def __init__(self, *args):
4482  r"""
4483  __init__(Sphere5D self) -> Sphere5D
4484  __init__(Sphere5D self, Vector5D center, double radius) -> Sphere5D
4485  """
4486  _IMP_algebra.Sphere5D_swiginit(self, _IMP_algebra.new_Sphere5D(*args))
4487 
4488  def get_radius(self):
4489  r"""get_radius(Sphere5D self) -> double"""
4490  return _IMP_algebra.Sphere5D_get_radius(self)
4491 
4492  def get_center(self):
4493  r"""get_center(Sphere5D self) -> Vector5D"""
4494  return _IMP_algebra.Sphere5D_get_center(self)
4495 
4496  def get_contains(self, *args):
4497  r"""
4498  get_contains(Sphere5D self, Sphere5D o) -> bool
4499  get_contains(Sphere5D self, Vector5D p) -> bool
4500  """
4501  return _IMP_algebra.Sphere5D_get_contains(self, *args)
4502 
4503  def show(self, *args):
4504  r"""show(Sphere5D self, _ostream out=std::cout)"""
4505  return _IMP_algebra.Sphere5D_show(self, *args)
4506 
4507  def get_dimension(self):
4508  r"""get_dimension(Sphere5D self) -> unsigned int"""
4509  return _IMP_algebra.Sphere5D_get_dimension(self)
4510 
4511  def __str__(self):
4512  r"""__str__(Sphere5D self) -> std::string"""
4513  return _IMP_algebra.Sphere5D___str__(self)
4514 
4515  def __repr__(self):
4516  r"""__repr__(Sphere5D self) -> std::string"""
4517  return _IMP_algebra.Sphere5D___repr__(self)
4518 
4519  def __cmp__(self, arg2):
4520  r"""__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
4521  return _IMP_algebra.Sphere5D___cmp__(self, arg2)
4522 
4523  def __eq__(self, arg2):
4524  r"""__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
4525  return _IMP_algebra.Sphere5D___eq__(self, arg2)
4526 
4527  def _get_as_binary(self):
4528  r"""_get_as_binary(Sphere5D self) -> PyObject *"""
4529  return _IMP_algebra.Sphere5D__get_as_binary(self)
4530 
4531  def _set_from_binary(self, p):
4532  r"""_set_from_binary(Sphere5D self, PyObject * p)"""
4533  return _IMP_algebra.Sphere5D__set_from_binary(self, p)
4534 
4535  def __getstate__(self):
4536  p = self._get_as_binary()
4537  if len(self.__dict__) > 1:
4538  d = self.__dict__.copy()
4539  del d['this']
4540  p = (d, p)
4541  return p
4542 
4543  def __setstate__(self, p):
4544  if not hasattr(self, 'this'):
4545  self.__init__()
4546  if isinstance(p, tuple):
4547  d, p = p
4548  self.__dict__.update(d)
4549  return self._set_from_binary(p)
4550 
4551  __swig_destroy__ = _IMP_algebra.delete_Sphere5D
4552 
4553 # Register Sphere5D in _IMP_algebra:
4554 _IMP_algebra.Sphere5D_swigregister(Sphere5D)
4555 class Sphere6D(_GeometricPrimitive6D):
4556  r"""Proxy of C++ IMP::algebra::SphereD< 6 > class."""
4557 
4558  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4559 
4560  def __init__(self, *args):
4561  r"""
4562  __init__(Sphere6D self) -> Sphere6D
4563  __init__(Sphere6D self, Vector6D center, double radius) -> Sphere6D
4564  """
4565  _IMP_algebra.Sphere6D_swiginit(self, _IMP_algebra.new_Sphere6D(*args))
4566 
4567  def get_radius(self):
4568  r"""get_radius(Sphere6D self) -> double"""
4569  return _IMP_algebra.Sphere6D_get_radius(self)
4570 
4571  def get_center(self):
4572  r"""get_center(Sphere6D self) -> Vector6D"""
4573  return _IMP_algebra.Sphere6D_get_center(self)
4574 
4575  def get_contains(self, *args):
4576  r"""
4577  get_contains(Sphere6D self, Sphere6D o) -> bool
4578  get_contains(Sphere6D self, Vector6D p) -> bool
4579  """
4580  return _IMP_algebra.Sphere6D_get_contains(self, *args)
4581 
4582  def show(self, *args):
4583  r"""show(Sphere6D self, _ostream out=std::cout)"""
4584  return _IMP_algebra.Sphere6D_show(self, *args)
4585 
4586  def get_dimension(self):
4587  r"""get_dimension(Sphere6D self) -> unsigned int"""
4588  return _IMP_algebra.Sphere6D_get_dimension(self)
4589 
4590  def __str__(self):
4591  r"""__str__(Sphere6D self) -> std::string"""
4592  return _IMP_algebra.Sphere6D___str__(self)
4593 
4594  def __repr__(self):
4595  r"""__repr__(Sphere6D self) -> std::string"""
4596  return _IMP_algebra.Sphere6D___repr__(self)
4597 
4598  def __cmp__(self, arg2):
4599  r"""__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
4600  return _IMP_algebra.Sphere6D___cmp__(self, arg2)
4601 
4602  def __eq__(self, arg2):
4603  r"""__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
4604  return _IMP_algebra.Sphere6D___eq__(self, arg2)
4605 
4606  def _get_as_binary(self):
4607  r"""_get_as_binary(Sphere6D self) -> PyObject *"""
4608  return _IMP_algebra.Sphere6D__get_as_binary(self)
4609 
4610  def _set_from_binary(self, p):
4611  r"""_set_from_binary(Sphere6D self, PyObject * p)"""
4612  return _IMP_algebra.Sphere6D__set_from_binary(self, p)
4613 
4614  def __getstate__(self):
4615  p = self._get_as_binary()
4616  if len(self.__dict__) > 1:
4617  d = self.__dict__.copy()
4618  del d['this']
4619  p = (d, p)
4620  return p
4621 
4622  def __setstate__(self, p):
4623  if not hasattr(self, 'this'):
4624  self.__init__()
4625  if isinstance(p, tuple):
4626  d, p = p
4627  self.__dict__.update(d)
4628  return self._set_from_binary(p)
4629 
4630  __swig_destroy__ = _IMP_algebra.delete_Sphere6D
4631 
4632 # Register Sphere6D in _IMP_algebra:
4633 _IMP_algebra.Sphere6D_swigregister(Sphere6D)
4634 class SphereKD(_GeometricPrimitiveKD):
4635  r"""Proxy of C++ IMP::algebra::SphereD< -1 > class."""
4636 
4637  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4638 
4639  def __init__(self, *args):
4640  r"""
4641  __init__(SphereKD self) -> SphereKD
4642  __init__(SphereKD self, VectorKD center, double radius) -> SphereKD
4643  """
4644  _IMP_algebra.SphereKD_swiginit(self, _IMP_algebra.new_SphereKD(*args))
4645 
4646  def get_radius(self):
4647  r"""get_radius(SphereKD self) -> double"""
4648  return _IMP_algebra.SphereKD_get_radius(self)
4649 
4650  def get_center(self):
4651  r"""get_center(SphereKD self) -> VectorKD"""
4652  return _IMP_algebra.SphereKD_get_center(self)
4653 
4654  def get_contains(self, *args):
4655  r"""
4656  get_contains(SphereKD self, SphereKD o) -> bool
4657  get_contains(SphereKD self, VectorKD p) -> bool
4658  """
4659  return _IMP_algebra.SphereKD_get_contains(self, *args)
4660 
4661  def show(self, *args):
4662  r"""show(SphereKD self, _ostream out=std::cout)"""
4663  return _IMP_algebra.SphereKD_show(self, *args)
4664 
4665  def get_dimension(self):
4666  r"""get_dimension(SphereKD self) -> unsigned int"""
4667  return _IMP_algebra.SphereKD_get_dimension(self)
4668 
4669  def __str__(self):
4670  r"""__str__(SphereKD self) -> std::string"""
4671  return _IMP_algebra.SphereKD___str__(self)
4672 
4673  def __repr__(self):
4674  r"""__repr__(SphereKD self) -> std::string"""
4675  return _IMP_algebra.SphereKD___repr__(self)
4676 
4677  def __cmp__(self, arg2):
4678  r"""__cmp__(SphereKD self, SphereKD arg2) -> int"""
4679  return _IMP_algebra.SphereKD___cmp__(self, arg2)
4680 
4681  def __eq__(self, arg2):
4682  r"""__eq__(SphereKD self, SphereKD arg2) -> bool"""
4683  return _IMP_algebra.SphereKD___eq__(self, arg2)
4684 
4685  def _get_as_binary(self):
4686  r"""_get_as_binary(SphereKD self) -> PyObject *"""
4687  return _IMP_algebra.SphereKD__get_as_binary(self)
4688 
4689  def _set_from_binary(self, p):
4690  r"""_set_from_binary(SphereKD self, PyObject * p)"""
4691  return _IMP_algebra.SphereKD__set_from_binary(self, p)
4692 
4693  def __getstate__(self):
4694  p = self._get_as_binary()
4695  if len(self.__dict__) > 1:
4696  d = self.__dict__.copy()
4697  del d['this']
4698  p = (d, p)
4699  return p
4700 
4701  def __setstate__(self, p):
4702  if not hasattr(self, 'this'):
4703  self.__init__()
4704  if isinstance(p, tuple):
4705  d, p = p
4706  self.__dict__.update(d)
4707  return self._set_from_binary(p)
4708 
4709  __swig_destroy__ = _IMP_algebra.delete_SphereKD
4710 
4711 # Register SphereKD in _IMP_algebra:
4712 _IMP_algebra.SphereKD_swigregister(SphereKD)
4713 class UnitSimplex1D(_UnitSimplexBase1D):
4714  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 1 > class."""
4715 
4716  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4717 
4718  def __init__(self):
4719  r"""__init__(UnitSimplex1D self) -> UnitSimplex1D"""
4720  _IMP_algebra.UnitSimplex1D_swiginit(self, _IMP_algebra.new_UnitSimplex1D())
4721 
4722  def show(self, *args):
4723  r"""show(UnitSimplex1D self, _ostream out=std::cout)"""
4724  return _IMP_algebra.UnitSimplex1D_show(self, *args)
4725 
4726  def __str__(self):
4727  r"""__str__(UnitSimplex1D self) -> std::string"""
4728  return _IMP_algebra.UnitSimplex1D___str__(self)
4729 
4730  def __repr__(self):
4731  r"""__repr__(UnitSimplex1D self) -> std::string"""
4732  return _IMP_algebra.UnitSimplex1D___repr__(self)
4733 
4734  def __cmp__(self, arg2):
4735  r"""__cmp__(UnitSimplex1D self, UnitSimplex1D arg2) -> int"""
4736  return _IMP_algebra.UnitSimplex1D___cmp__(self, arg2)
4737 
4738  def __eq__(self, arg2):
4739  r"""__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
4740  return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)
4741 
4742  def _get_as_binary(self):
4743  r"""_get_as_binary(UnitSimplex1D self) -> PyObject *"""
4744  return _IMP_algebra.UnitSimplex1D__get_as_binary(self)
4745 
4746  def _set_from_binary(self, p):
4747  r"""_set_from_binary(UnitSimplex1D self, PyObject * p)"""
4748  return _IMP_algebra.UnitSimplex1D__set_from_binary(self, p)
4749 
4750  def __getstate__(self):
4751  p = self._get_as_binary()
4752  if len(self.__dict__) > 1:
4753  d = self.__dict__.copy()
4754  del d['this']
4755  p = (d, p)
4756  return p
4757 
4758  def __setstate__(self, p):
4759  if not hasattr(self, 'this'):
4760  self.__init__()
4761  if isinstance(p, tuple):
4762  d, p = p
4763  self.__dict__.update(d)
4764  return self._set_from_binary(p)
4765 
4766  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D
4767 
4768 # Register UnitSimplex1D in _IMP_algebra:
4769 _IMP_algebra.UnitSimplex1D_swigregister(UnitSimplex1D)
4770 class UnitSimplex2D(_UnitSimplexBase2D):
4771  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 2 > class."""
4772 
4773  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4774 
4775  def __init__(self):
4776  r"""__init__(UnitSimplex2D self) -> UnitSimplex2D"""
4777  _IMP_algebra.UnitSimplex2D_swiginit(self, _IMP_algebra.new_UnitSimplex2D())
4778 
4779  def show(self, *args):
4780  r"""show(UnitSimplex2D self, _ostream out=std::cout)"""
4781  return _IMP_algebra.UnitSimplex2D_show(self, *args)
4782 
4783  def __str__(self):
4784  r"""__str__(UnitSimplex2D self) -> std::string"""
4785  return _IMP_algebra.UnitSimplex2D___str__(self)
4786 
4787  def __repr__(self):
4788  r"""__repr__(UnitSimplex2D self) -> std::string"""
4789  return _IMP_algebra.UnitSimplex2D___repr__(self)
4790 
4791  def __cmp__(self, arg2):
4792  r"""__cmp__(UnitSimplex2D self, UnitSimplex2D arg2) -> int"""
4793  return _IMP_algebra.UnitSimplex2D___cmp__(self, arg2)
4794 
4795  def __eq__(self, arg2):
4796  r"""__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
4797  return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)
4798 
4799  def _get_as_binary(self):
4800  r"""_get_as_binary(UnitSimplex2D self) -> PyObject *"""
4801  return _IMP_algebra.UnitSimplex2D__get_as_binary(self)
4802 
4803  def _set_from_binary(self, p):
4804  r"""_set_from_binary(UnitSimplex2D self, PyObject * p)"""
4805  return _IMP_algebra.UnitSimplex2D__set_from_binary(self, p)
4806 
4807  def __getstate__(self):
4808  p = self._get_as_binary()
4809  if len(self.__dict__) > 1:
4810  d = self.__dict__.copy()
4811  del d['this']
4812  p = (d, p)
4813  return p
4814 
4815  def __setstate__(self, p):
4816  if not hasattr(self, 'this'):
4817  self.__init__()
4818  if isinstance(p, tuple):
4819  d, p = p
4820  self.__dict__.update(d)
4821  return self._set_from_binary(p)
4822 
4823  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D
4824 
4825 # Register UnitSimplex2D in _IMP_algebra:
4826 _IMP_algebra.UnitSimplex2D_swigregister(UnitSimplex2D)
4827 class UnitSimplex3D(_UnitSimplexBase3D):
4828  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 3 > class."""
4829 
4830  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4831 
4832  def __init__(self):
4833  r"""__init__(UnitSimplex3D self) -> UnitSimplex3D"""
4834  _IMP_algebra.UnitSimplex3D_swiginit(self, _IMP_algebra.new_UnitSimplex3D())
4835 
4836  def show(self, *args):
4837  r"""show(UnitSimplex3D self, _ostream out=std::cout)"""
4838  return _IMP_algebra.UnitSimplex3D_show(self, *args)
4839 
4840  def __str__(self):
4841  r"""__str__(UnitSimplex3D self) -> std::string"""
4842  return _IMP_algebra.UnitSimplex3D___str__(self)
4843 
4844  def __repr__(self):
4845  r"""__repr__(UnitSimplex3D self) -> std::string"""
4846  return _IMP_algebra.UnitSimplex3D___repr__(self)
4847 
4848  def __cmp__(self, arg2):
4849  r"""__cmp__(UnitSimplex3D self, UnitSimplex3D arg2) -> int"""
4850  return _IMP_algebra.UnitSimplex3D___cmp__(self, arg2)
4851 
4852  def __eq__(self, arg2):
4853  r"""__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
4854  return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)
4855 
4856  def _get_as_binary(self):
4857  r"""_get_as_binary(UnitSimplex3D self) -> PyObject *"""
4858  return _IMP_algebra.UnitSimplex3D__get_as_binary(self)
4859 
4860  def _set_from_binary(self, p):
4861  r"""_set_from_binary(UnitSimplex3D self, PyObject * p)"""
4862  return _IMP_algebra.UnitSimplex3D__set_from_binary(self, p)
4863 
4864  def __getstate__(self):
4865  p = self._get_as_binary()
4866  if len(self.__dict__) > 1:
4867  d = self.__dict__.copy()
4868  del d['this']
4869  p = (d, p)
4870  return p
4871 
4872  def __setstate__(self, p):
4873  if not hasattr(self, 'this'):
4874  self.__init__()
4875  if isinstance(p, tuple):
4876  d, p = p
4877  self.__dict__.update(d)
4878  return self._set_from_binary(p)
4879 
4880  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D
4881 
4882 # Register UnitSimplex3D in _IMP_algebra:
4883 _IMP_algebra.UnitSimplex3D_swigregister(UnitSimplex3D)
4884 class UnitSimplex4D(_UnitSimplexBase4D):
4885  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 4 > class."""
4886 
4887  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4888 
4889  def __init__(self):
4890  r"""__init__(UnitSimplex4D self) -> UnitSimplex4D"""
4891  _IMP_algebra.UnitSimplex4D_swiginit(self, _IMP_algebra.new_UnitSimplex4D())
4892 
4893  def show(self, *args):
4894  r"""show(UnitSimplex4D self, _ostream out=std::cout)"""
4895  return _IMP_algebra.UnitSimplex4D_show(self, *args)
4896 
4897  def __str__(self):
4898  r"""__str__(UnitSimplex4D self) -> std::string"""
4899  return _IMP_algebra.UnitSimplex4D___str__(self)
4900 
4901  def __repr__(self):
4902  r"""__repr__(UnitSimplex4D self) -> std::string"""
4903  return _IMP_algebra.UnitSimplex4D___repr__(self)
4904 
4905  def __cmp__(self, arg2):
4906  r"""__cmp__(UnitSimplex4D self, UnitSimplex4D arg2) -> int"""
4907  return _IMP_algebra.UnitSimplex4D___cmp__(self, arg2)
4908 
4909  def __eq__(self, arg2):
4910  r"""__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
4911  return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)
4912 
4913  def _get_as_binary(self):
4914  r"""_get_as_binary(UnitSimplex4D self) -> PyObject *"""
4915  return _IMP_algebra.UnitSimplex4D__get_as_binary(self)
4916 
4917  def _set_from_binary(self, p):
4918  r"""_set_from_binary(UnitSimplex4D self, PyObject * p)"""
4919  return _IMP_algebra.UnitSimplex4D__set_from_binary(self, p)
4920 
4921  def __getstate__(self):
4922  p = self._get_as_binary()
4923  if len(self.__dict__) > 1:
4924  d = self.__dict__.copy()
4925  del d['this']
4926  p = (d, p)
4927  return p
4928 
4929  def __setstate__(self, p):
4930  if not hasattr(self, 'this'):
4931  self.__init__()
4932  if isinstance(p, tuple):
4933  d, p = p
4934  self.__dict__.update(d)
4935  return self._set_from_binary(p)
4936 
4937  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D
4938 
4939 # Register UnitSimplex4D in _IMP_algebra:
4940 _IMP_algebra.UnitSimplex4D_swigregister(UnitSimplex4D)
4941 class UnitSimplex5D(_UnitSimplexBase5D):
4942  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 5 > class."""
4943 
4944  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4945 
4946  def __init__(self):
4947  r"""__init__(UnitSimplex5D self) -> UnitSimplex5D"""
4948  _IMP_algebra.UnitSimplex5D_swiginit(self, _IMP_algebra.new_UnitSimplex5D())
4949 
4950  def show(self, *args):
4951  r"""show(UnitSimplex5D self, _ostream out=std::cout)"""
4952  return _IMP_algebra.UnitSimplex5D_show(self, *args)
4953 
4954  def __str__(self):
4955  r"""__str__(UnitSimplex5D self) -> std::string"""
4956  return _IMP_algebra.UnitSimplex5D___str__(self)
4957 
4958  def __repr__(self):
4959  r"""__repr__(UnitSimplex5D self) -> std::string"""
4960  return _IMP_algebra.UnitSimplex5D___repr__(self)
4961 
4962  def __cmp__(self, arg2):
4963  r"""__cmp__(UnitSimplex5D self, UnitSimplex5D arg2) -> int"""
4964  return _IMP_algebra.UnitSimplex5D___cmp__(self, arg2)
4965 
4966  def __eq__(self, arg2):
4967  r"""__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
4968  return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)
4969 
4970  def _get_as_binary(self):
4971  r"""_get_as_binary(UnitSimplex5D self) -> PyObject *"""
4972  return _IMP_algebra.UnitSimplex5D__get_as_binary(self)
4973 
4974  def _set_from_binary(self, p):
4975  r"""_set_from_binary(UnitSimplex5D self, PyObject * p)"""
4976  return _IMP_algebra.UnitSimplex5D__set_from_binary(self, p)
4977 
4978  def __getstate__(self):
4979  p = self._get_as_binary()
4980  if len(self.__dict__) > 1:
4981  d = self.__dict__.copy()
4982  del d['this']
4983  p = (d, p)
4984  return p
4985 
4986  def __setstate__(self, p):
4987  if not hasattr(self, 'this'):
4988  self.__init__()
4989  if isinstance(p, tuple):
4990  d, p = p
4991  self.__dict__.update(d)
4992  return self._set_from_binary(p)
4993 
4994  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D
4995 
4996 # Register UnitSimplex5D in _IMP_algebra:
4997 _IMP_algebra.UnitSimplex5D_swigregister(UnitSimplex5D)
4998 class UnitSimplex6D(_UnitSimplexBase6D):
4999  r"""Proxy of C++ IMP::algebra::UnitSimplexD< 6 > class."""
5000 
5001  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5002 
5003  def __init__(self):
5004  r"""__init__(UnitSimplex6D self) -> UnitSimplex6D"""
5005  _IMP_algebra.UnitSimplex6D_swiginit(self, _IMP_algebra.new_UnitSimplex6D())
5006 
5007  def show(self, *args):
5008  r"""show(UnitSimplex6D self, _ostream out=std::cout)"""
5009  return _IMP_algebra.UnitSimplex6D_show(self, *args)
5010 
5011  def __str__(self):
5012  r"""__str__(UnitSimplex6D self) -> std::string"""
5013  return _IMP_algebra.UnitSimplex6D___str__(self)
5014 
5015  def __repr__(self):
5016  r"""__repr__(UnitSimplex6D self) -> std::string"""
5017  return _IMP_algebra.UnitSimplex6D___repr__(self)
5018 
5019  def __cmp__(self, arg2):
5020  r"""__cmp__(UnitSimplex6D self, UnitSimplex6D arg2) -> int"""
5021  return _IMP_algebra.UnitSimplex6D___cmp__(self, arg2)
5022 
5023  def __eq__(self, arg2):
5024  r"""__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
5025  return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)
5026 
5027  def _get_as_binary(self):
5028  r"""_get_as_binary(UnitSimplex6D self) -> PyObject *"""
5029  return _IMP_algebra.UnitSimplex6D__get_as_binary(self)
5030 
5031  def _set_from_binary(self, p):
5032  r"""_set_from_binary(UnitSimplex6D self, PyObject * p)"""
5033  return _IMP_algebra.UnitSimplex6D__set_from_binary(self, p)
5034 
5035  def __getstate__(self):
5036  p = self._get_as_binary()
5037  if len(self.__dict__) > 1:
5038  d = self.__dict__.copy()
5039  del d['this']
5040  p = (d, p)
5041  return p
5042 
5043  def __setstate__(self, p):
5044  if not hasattr(self, 'this'):
5045  self.__init__()
5046  if isinstance(p, tuple):
5047  d, p = p
5048  self.__dict__.update(d)
5049  return self._set_from_binary(p)
5050 
5051  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D
5052 
5053 # Register UnitSimplex6D in _IMP_algebra:
5054 _IMP_algebra.UnitSimplex6D_swigregister(UnitSimplex6D)
5055 class UnitSimplexKD(_UnitSimplexBaseKD):
5056  r"""Proxy of C++ IMP::algebra::UnitSimplexD< -1 > class."""
5057 
5058  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5059  __repr__ = _swig_repr
5060 
5061  def __init__(self, d=1):
5062  r"""__init__(UnitSimplexKD self, int d=1) -> UnitSimplexKD"""
5063  _IMP_algebra.UnitSimplexKD_swiginit(self, _IMP_algebra.new_UnitSimplexKD(d))
5064 
5065  def show(self, *args):
5066  r"""show(UnitSimplexKD self, _ostream out=std::cout)"""
5067  return _IMP_algebra.UnitSimplexKD_show(self, *args)
5068 
5069  def _get_as_binary(self):
5070  r"""_get_as_binary(UnitSimplexKD self) -> PyObject *"""
5071  return _IMP_algebra.UnitSimplexKD__get_as_binary(self)
5072 
5073  def _set_from_binary(self, p):
5074  r"""_set_from_binary(UnitSimplexKD self, PyObject * p)"""
5075  return _IMP_algebra.UnitSimplexKD__set_from_binary(self, p)
5076 
5077  def __getstate__(self):
5078  p = self._get_as_binary()
5079  if len(self.__dict__) > 1:
5080  d = self.__dict__.copy()
5081  del d['this']
5082  p = (d, p)
5083  return p
5084 
5085  def __setstate__(self, p):
5086  if not hasattr(self, 'this'):
5087  self.__init__()
5088  if isinstance(p, tuple):
5089  d, p = p
5090  self.__dict__.update(d)
5091  return self._set_from_binary(p)
5092 
5093  __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD
5094 
5095 # Register UnitSimplexKD in _IMP_algebra:
5096 _IMP_algebra.UnitSimplexKD_swigregister(UnitSimplexKD)
5097 class ReferenceFrame3D(object):
5098  r"""Proxy of C++ IMP::algebra::ReferenceFrame3D class."""
5099 
5100  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5101 
5102  def __init__(self, *args):
5103  r"""
5104  __init__(ReferenceFrame3D self, ReferenceFrame3D arg2) -> ReferenceFrame3D
5105  __init__(ReferenceFrame3D self) -> ReferenceFrame3D
5106  __init__(ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
5107  """
5108  _IMP_algebra.ReferenceFrame3D_swiginit(self, _IMP_algebra.new_ReferenceFrame3D(*args))
5109  __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
5110 
5111  def get_transformation_to(self):
5112  r"""get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
5113  return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)
5114 
5115  def get_transformation_from(self):
5116  r"""get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
5117  return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)
5118 
5119  def get_global_coordinates(self, v):
5120  r"""get_global_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5121  return _IMP_algebra.ReferenceFrame3D_get_global_coordinates(self, v)
5122 
5123  def get_local_coordinates(self, v):
5124  r"""get_local_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5125  return _IMP_algebra.ReferenceFrame3D_get_local_coordinates(self, v)
5126 
5127  def get_global_reference_frame(self, v):
5128  r"""get_global_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5129  return _IMP_algebra.ReferenceFrame3D_get_global_reference_frame(self, v)
5130 
5131  def get_local_reference_frame(self, v):
5132  r"""get_local_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5133  return _IMP_algebra.ReferenceFrame3D_get_local_reference_frame(self, v)
5134 
5135  def show(self, *args):
5136  r"""show(ReferenceFrame3D self, _ostream out=std::cout)"""
5137  return _IMP_algebra.ReferenceFrame3D_show(self, *args)
5138 
5139  def __str__(self):
5140  r"""__str__(ReferenceFrame3D self) -> std::string"""
5141  return _IMP_algebra.ReferenceFrame3D___str__(self)
5142 
5143  def __repr__(self):
5144  r"""__repr__(ReferenceFrame3D self) -> std::string"""
5145  return _IMP_algebra.ReferenceFrame3D___repr__(self)
5146 
5147  def _get_as_binary(self):
5148  r"""_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
5149  return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)
5150 
5151  def _set_from_binary(self, p):
5152  r"""_set_from_binary(ReferenceFrame3D self, PyObject * p)"""
5153  return _IMP_algebra.ReferenceFrame3D__set_from_binary(self, p)
5154 
5155  def __getstate__(self):
5156  p = self._get_as_binary()
5157  if len(self.__dict__) > 1:
5158  d = self.__dict__.copy()
5159  del d['this']
5160  p = (d, p)
5161  return p
5162 
5163  def __setstate__(self, p):
5164  if not hasattr(self, 'this'):
5165  self.__init__()
5166  if isinstance(p, tuple):
5167  d, p = p
5168  self.__dict__.update(d)
5169  return self._set_from_binary(p)
5170 
5171 
5172 # Register ReferenceFrame3D in _IMP_algebra:
5173 _IMP_algebra.ReferenceFrame3D_swigregister(ReferenceFrame3D)
5174 
5175 def get_transformed(*args):
5176  r"""
5177  get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
5178  get_transformed(Line3D l, Transformation3D tr) -> Line3D
5179  get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
5180  """
5181  return _IMP_algebra.get_transformed(*args)
5182 
5183 def get_transformation_from_first_to_second(a, b):
5184  r"""get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
5185  return _IMP_algebra.get_transformation_from_first_to_second(a, b)
5186 class SphericalVector3D(_GeometricPrimitive3D):
5187  r"""Proxy of C++ IMP::algebra::SphericalVector3D class."""
5188 
5189  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5190 
5191  def __init__(self, *args):
5192  r"""
5193  __init__(SphericalVector3D self) -> SphericalVector3D
5194  __init__(SphericalVector3D self, Vector3D v) -> SphericalVector3D
5195  __init__(SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
5196  """
5197  _IMP_algebra.SphericalVector3D_swiginit(self, _IMP_algebra.new_SphericalVector3D(*args))
5198 
5199  def get_cartesian_coordinates(self):
5200  r"""get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
5201  return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)
5202 
5203  def show(self, *args):
5204  r"""show(SphericalVector3D self, _ostream out=std::cout)"""
5205  return _IMP_algebra.SphericalVector3D_show(self, *args)
5206 
5207  def __str__(self):
5208  r"""__str__(SphericalVector3D self) -> std::string"""
5209  return _IMP_algebra.SphericalVector3D___str__(self)
5210 
5211  def __repr__(self):
5212  r"""__repr__(SphericalVector3D self) -> std::string"""
5213  return _IMP_algebra.SphericalVector3D___repr__(self)
5214 
5215  def _get_as_binary(self):
5216  r"""_get_as_binary(SphericalVector3D self) -> PyObject *"""
5217  return _IMP_algebra.SphericalVector3D__get_as_binary(self)
5218 
5219  def _set_from_binary(self, p):
5220  r"""_set_from_binary(SphericalVector3D self, PyObject * p)"""
5221  return _IMP_algebra.SphericalVector3D__set_from_binary(self, p)
5222 
5223  def __getstate__(self):
5224  p = self._get_as_binary()
5225  if len(self.__dict__) > 1:
5226  d = self.__dict__.copy()
5227  del d['this']
5228  p = (d, p)
5229  return p
5230 
5231  def __setstate__(self, p):
5232  if not hasattr(self, 'this'):
5233  self.__init__()
5234  if isinstance(p, tuple):
5235  d, p = p
5236  self.__dict__.update(d)
5237  return self._set_from_binary(p)
5238 
5239 
5240  def __getitem__(self, index):
5241  r"""__getitem__(SphericalVector3D self, unsigned int index) -> double"""
5242  return _IMP_algebra.SphericalVector3D___getitem__(self, index)
5243 
5244  def __setitem__(self, index, val):
5245  r"""__setitem__(SphericalVector3D self, unsigned int index, double val)"""
5246  return _IMP_algebra.SphericalVector3D___setitem__(self, index, val)
5247  __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D
5248 
5249 # Register SphericalVector3D in _IMP_algebra:
5250 _IMP_algebra.SphericalVector3D_swigregister(SphericalVector3D)
5251 
5252 def get_alignments_from_first_to_second(pca1, pca2):
5253  r"""get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
5254  return _IMP_algebra.get_alignments_from_first_to_second(pca1, pca2)
5255 class Line3D(_GeometricPrimitive3D):
5256  r"""Proxy of C++ IMP::algebra::Line3D class."""
5257 
5258  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5259 
5260  def __init__(self, *args):
5261  r"""
5262  __init__(Line3D self) -> Line3D
5263  __init__(Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
5264  __init__(Line3D self, Segment3D s) -> Line3D
5265  """
5266  _IMP_algebra.Line3D_swiginit(self, _IMP_algebra.new_Line3D(*args))
5267 
5268  def get_direction(self):
5269  r"""get_direction(Line3D self) -> Vector3D"""
5270  return _IMP_algebra.Line3D_get_direction(self)
5271 
5272  def get_point_on_line(self):
5273  r"""get_point_on_line(Line3D self) -> Vector3D"""
5274  return _IMP_algebra.Line3D_get_point_on_line(self)
5275 
5276  def get_moment(self, *args):
5277  r"""
5278  get_moment(Line3D self) -> Vector3D
5279  get_moment(Line3D self, Vector3D v) -> Vector3D
5280  """
5281  return _IMP_algebra.Line3D_get_moment(self, *args)
5282 
5283  def get_reciprocal_product(self, l):
5284  r"""get_reciprocal_product(Line3D self, Line3D l) -> double"""
5285  return _IMP_algebra.Line3D_get_reciprocal_product(self, l)
5286 
5287  def get_opposite(self):
5288  r"""get_opposite(Line3D self) -> Line3D"""
5289  return _IMP_algebra.Line3D_get_opposite(self)
5290 
5291  def get_segment_starting_at(self, v, d):
5292  r"""get_segment_starting_at(Line3D self, Vector3D v, double d) -> Segment3D"""
5293  return _IMP_algebra.Line3D_get_segment_starting_at(self, v, d)
5294 
5295  def show(self, *args):
5296  r"""show(Line3D self, _ostream out=std::cout)"""
5297  return _IMP_algebra.Line3D_show(self, *args)
5298 
5299  def __str__(self):
5300  r"""__str__(Line3D self) -> std::string"""
5301  return _IMP_algebra.Line3D___str__(self)
5302 
5303  def __repr__(self):
5304  r"""__repr__(Line3D self) -> std::string"""
5305  return _IMP_algebra.Line3D___repr__(self)
5306 
5307  def _get_as_binary(self):
5308  r"""_get_as_binary(Line3D self) -> PyObject *"""
5309  return _IMP_algebra.Line3D__get_as_binary(self)
5310 
5311  def _set_from_binary(self, p):
5312  r"""_set_from_binary(Line3D self, PyObject * p)"""
5313  return _IMP_algebra.Line3D__set_from_binary(self, p)
5314 
5315  def __getstate__(self):
5316  p = self._get_as_binary()
5317  if len(self.__dict__) > 1:
5318  d = self.__dict__.copy()
5319  del d['this']
5320  p = (d, p)
5321  return p
5322 
5323  def __setstate__(self, p):
5324  if not hasattr(self, 'this'):
5325  self.__init__()
5326  if isinstance(p, tuple):
5327  d, p = p
5328  self.__dict__.update(d)
5329  return self._set_from_binary(p)
5330 
5331  __swig_destroy__ = _IMP_algebra.delete_Line3D
5332 
5333 # Register Line3D in _IMP_algebra:
5334 _IMP_algebra.Line3D_swigregister(Line3D)
5335 
5336 def get_line_3d_geometry(g):
5337  r"""get_line_3d_geometry(Line3D g) -> Line3D"""
5338  return _IMP_algebra.get_line_3d_geometry(g)
5339 
5340 def get_angle(a, b):
5341  r"""get_angle(Line3D a, Line3D b) -> double"""
5342  return _IMP_algebra.get_angle(a, b)
5343 
5345  r"""get_segment_connecting_first_to_second(Line3D a, Line3D b) -> Segment3D"""
5346  return _IMP_algebra.get_segment_connecting_first_to_second(a, b)
5347 class Segment3D(_GeometricPrimitive3D):
5348  r"""Proxy of C++ IMP::algebra::Segment3D class."""
5349 
5350  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5351 
5352  def __init__(self, *args):
5353  r"""
5354  __init__(Segment3D self) -> Segment3D
5355  __init__(Segment3D self, Vector3D start, Vector3D end) -> Segment3D
5356  """
5357  _IMP_algebra.Segment3D_swiginit(self, _IMP_algebra.new_Segment3D(*args))
5358 
5359  def get_point(self, i):
5360  if i < 0 or i >= 2:
5361  raise IMP.UsageException("Invalid point index")
5362  return _IMP_algebra.Segment3D_get_point(self, i)
5363 
5364 
5365 
5366  def get_middle_point(self):
5367  r"""get_middle_point(Segment3D self) -> Vector3D"""
5368  return _IMP_algebra.Segment3D_get_middle_point(self)
5369 
5370  def get_direction(self):
5371  r"""get_direction(Segment3D self) -> Vector3D"""
5372  return _IMP_algebra.Segment3D_get_direction(self)
5373 
5374  def get_length(self):
5375  r"""get_length(Segment3D self) -> double"""
5376  return _IMP_algebra.Segment3D_get_length(self)
5377 
5378  def show(self, *args):
5379  r"""show(Segment3D self, _ostream out=std::cout)"""
5380  return _IMP_algebra.Segment3D_show(self, *args)
5381 
5382  def __str__(self):
5383  r"""__str__(Segment3D self) -> std::string"""
5384  return _IMP_algebra.Segment3D___str__(self)
5385 
5386  def __repr__(self):
5387  r"""__repr__(Segment3D self) -> std::string"""
5388  return _IMP_algebra.Segment3D___repr__(self)
5389 
5390  def _get_as_binary(self):
5391  r"""_get_as_binary(Segment3D self) -> PyObject *"""
5392  return _IMP_algebra.Segment3D__get_as_binary(self)
5393 
5394  def _set_from_binary(self, p):
5395  r"""_set_from_binary(Segment3D self, PyObject * p)"""
5396  return _IMP_algebra.Segment3D__set_from_binary(self, p)
5397 
5398  def __getstate__(self):
5399  p = self._get_as_binary()
5400  if len(self.__dict__) > 1:
5401  d = self.__dict__.copy()
5402  del d['this']
5403  p = (d, p)
5404  return p
5405 
5406  def __setstate__(self, p):
5407  if not hasattr(self, 'this'):
5408  self.__init__()
5409  if isinstance(p, tuple):
5410  d, p = p
5411  self.__dict__.update(d)
5412  return self._set_from_binary(p)
5413 
5414  __swig_destroy__ = _IMP_algebra.delete_Segment3D
5415 
5416 # Register Segment3D in _IMP_algebra:
5417 _IMP_algebra.Segment3D_swigregister(Segment3D)
5418 
5419 def get_segment_3d_geometry(g):
5420  r"""get_segment_3d_geometry(Segment3D g) -> Segment3D"""
5421  return _IMP_algebra.get_segment_3d_geometry(g)
5422 
5424  r"""get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
5425  return _IMP_algebra.get_relative_projection_on_segment(s, p)
5426 class Triangle3D(_GeometricPrimitive3D):
5427  r"""Proxy of C++ IMP::algebra::Triangle3D class."""
5428 
5429  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5430 
5431  def __init__(self, *args):
5432  r"""
5433  __init__(Triangle3D self) -> Triangle3D
5434  __init__(Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
5435  """
5436  _IMP_algebra.Triangle3D_swiginit(self, _IMP_algebra.new_Triangle3D(*args))
5437 
5438  def get_point(self, i):
5439  r"""get_point(Triangle3D self, unsigned int i) -> Vector3D"""
5440  return _IMP_algebra.Triangle3D_get_point(self, i)
5441 
5442  def show(self, *args):
5443  r"""show(Triangle3D self, _ostream out=std::cout)"""
5444  return _IMP_algebra.Triangle3D_show(self, *args)
5445 
5446  def get_edge_lengths(self):
5447  r"""get_edge_lengths(Triangle3D self) -> IMP::Floats"""
5448  return _IMP_algebra.Triangle3D_get_edge_lengths(self)
5449 
5450  def __str__(self):
5451  r"""__str__(Triangle3D self) -> std::string"""
5452  return _IMP_algebra.Triangle3D___str__(self)
5453 
5454  def __repr__(self):
5455  r"""__repr__(Triangle3D self) -> std::string"""
5456  return _IMP_algebra.Triangle3D___repr__(self)
5457 
5458  def _get_as_binary(self):
5459  r"""_get_as_binary(Triangle3D self) -> PyObject *"""
5460  return _IMP_algebra.Triangle3D__get_as_binary(self)
5461 
5462  def _set_from_binary(self, p):
5463  r"""_set_from_binary(Triangle3D self, PyObject * p)"""
5464  return _IMP_algebra.Triangle3D__set_from_binary(self, p)
5465 
5466  def __getstate__(self):
5467  p = self._get_as_binary()
5468  if len(self.__dict__) > 1:
5469  d = self.__dict__.copy()
5470  del d['this']
5471  p = (d, p)
5472  return p
5473 
5474  def __setstate__(self, p):
5475  if not hasattr(self, 'this'):
5476  self.__init__()
5477  if isinstance(p, tuple):
5478  d, p = p
5479  self.__dict__.update(d)
5480  return self._set_from_binary(p)
5481 
5482  __swig_destroy__ = _IMP_algebra.delete_Triangle3D
5483 
5484 # Register Triangle3D in _IMP_algebra:
5485 _IMP_algebra.Triangle3D_swigregister(Triangle3D)
5486 
5487 def get_largest_triangle(points):
5488  r"""get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
5489  return _IMP_algebra.get_largest_triangle(points)
5490 
5491 def get_transformation_from_first_triangle_to_second(first_tri, second_tri):
5492  r"""get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri) -> Transformation3D"""
5493  return _IMP_algebra.get_transformation_from_first_triangle_to_second(first_tri, second_tri)
5494 
5495 def get_are_colinear(p1, p2, p3):
5496  r"""get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
5497  return _IMP_algebra.get_are_colinear(p1, p2, p3)
5498 class LinearFit2D(_GeometricPrimitive2D):
5499  r"""Proxy of C++ IMP::algebra::LinearFit2D class."""
5500 
5501  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5502 
5503  def __init__(self, *args):
5504  r"""
5505  __init__(LinearFit2D self) -> LinearFit2D
5506  __init__(LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars=IMP::Floats()) -> LinearFit2D
5507  """
5508  _IMP_algebra.LinearFit2D_swiginit(self, _IMP_algebra.new_LinearFit2D(*args))
5509 
5510  def get_fit_error(self):
5511  r"""get_fit_error(LinearFit2D self) -> double"""
5512  return _IMP_algebra.LinearFit2D_get_fit_error(self)
5513 
5514  def get_a(self):
5515  r"""get_a(LinearFit2D self) -> double"""
5516  return _IMP_algebra.LinearFit2D_get_a(self)
5517 
5518  def get_b(self):
5519  r"""get_b(LinearFit2D self) -> double"""
5520  return _IMP_algebra.LinearFit2D_get_b(self)
5521 
5522  def show(self, *args):
5523  r"""show(LinearFit2D self, _ostream out=std::cout)"""
5524  return _IMP_algebra.LinearFit2D_show(self, *args)
5525 
5526  def __str__(self):
5527  r"""__str__(LinearFit2D self) -> std::string"""
5528  return _IMP_algebra.LinearFit2D___str__(self)
5529 
5530  def __repr__(self):
5531  r"""__repr__(LinearFit2D self) -> std::string"""
5532  return _IMP_algebra.LinearFit2D___repr__(self)
5533 
5534  def _get_as_binary(self):
5535  r"""_get_as_binary(LinearFit2D self) -> PyObject *"""
5536  return _IMP_algebra.LinearFit2D__get_as_binary(self)
5537 
5538  def _set_from_binary(self, p):
5539  r"""_set_from_binary(LinearFit2D self, PyObject * p)"""
5540  return _IMP_algebra.LinearFit2D__set_from_binary(self, p)
5541 
5542  def __getstate__(self):
5543  p = self._get_as_binary()
5544  if len(self.__dict__) > 1:
5545  d = self.__dict__.copy()
5546  del d['this']
5547  p = (d, p)
5548  return p
5549 
5550  def __setstate__(self, p):
5551  if not hasattr(self, 'this'):
5552  self.__init__()
5553  if isinstance(p, tuple):
5554  d, p = p
5555  self.__dict__.update(d)
5556  return self._set_from_binary(p)
5557 
5558  __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
5559 
5560 # Register LinearFit2D in _IMP_algebra:
5561 _IMP_algebra.LinearFit2D_swigregister(LinearFit2D)
5562 class ParabolicFit2D(_GeometricPrimitive2D):
5563  r"""Proxy of C++ IMP::algebra::ParabolicFit2D class."""
5564 
5565  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5566 
5567  def __init__(self, *args):
5568  r"""
5569  __init__(ParabolicFit2D self) -> ParabolicFit2D
5570  __init__(ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
5571  """
5572  _IMP_algebra.ParabolicFit2D_swiginit(self, _IMP_algebra.new_ParabolicFit2D(*args))
5573 
5574  def get_fit_error(self):
5575  r"""get_fit_error(ParabolicFit2D self) -> double"""
5576  return _IMP_algebra.ParabolicFit2D_get_fit_error(self)
5577 
5578  def get_a(self):
5579  r"""get_a(ParabolicFit2D self) -> double"""
5580  return _IMP_algebra.ParabolicFit2D_get_a(self)
5581 
5582  def get_b(self):
5583  r"""get_b(ParabolicFit2D self) -> double"""
5584  return _IMP_algebra.ParabolicFit2D_get_b(self)
5585 
5586  def get_c(self):
5587  r"""get_c(ParabolicFit2D self) -> double"""
5588  return _IMP_algebra.ParabolicFit2D_get_c(self)
5589 
5590  def show(self, *args):
5591  r"""show(ParabolicFit2D self, _ostream out=std::cout)"""
5592  return _IMP_algebra.ParabolicFit2D_show(self, *args)
5593 
5594  def __str__(self):
5595  r"""__str__(ParabolicFit2D self) -> std::string"""
5596  return _IMP_algebra.ParabolicFit2D___str__(self)
5597 
5598  def __repr__(self):
5599  r"""__repr__(ParabolicFit2D self) -> std::string"""
5600  return _IMP_algebra.ParabolicFit2D___repr__(self)
5601 
5602  def _get_as_binary(self):
5603  r"""_get_as_binary(ParabolicFit2D self) -> PyObject *"""
5604  return _IMP_algebra.ParabolicFit2D__get_as_binary(self)
5605 
5606  def _set_from_binary(self, p):
5607  r"""_set_from_binary(ParabolicFit2D self, PyObject * p)"""
5608  return _IMP_algebra.ParabolicFit2D__set_from_binary(self, p)
5609 
5610  def __getstate__(self):
5611  p = self._get_as_binary()
5612  if len(self.__dict__) > 1:
5613  d = self.__dict__.copy()
5614  del d['this']
5615  p = (d, p)
5616  return p
5617 
5618  def __setstate__(self, p):
5619  if not hasattr(self, 'this'):
5620  self.__init__()
5621  if isinstance(p, tuple):
5622  d, p = p
5623  self.__dict__.update(d)
5624  return self._set_from_binary(p)
5625 
5626  __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
5627 
5628 # Register ParabolicFit2D in _IMP_algebra:
5629 _IMP_algebra.ParabolicFit2D_swigregister(ParabolicFit2D)
5630 class Plane3D(_GeometricPrimitive3D):
5631  r"""Proxy of C++ IMP::algebra::Plane3D class."""
5632 
5633  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5634 
5635  def __init__(self, *args):
5636  r"""
5637  __init__(Plane3D self) -> Plane3D
5638  __init__(Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
5639  __init__(Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
5640  """
5641  _IMP_algebra.Plane3D_swiginit(self, _IMP_algebra.new_Plane3D(*args))
5642 
5643  def get_point_on_plane(self):
5644  r"""get_point_on_plane(Plane3D self) -> Vector3D"""
5645  return _IMP_algebra.Plane3D_get_point_on_plane(self)
5646 
5647  def get_normal(self):
5648  r"""get_normal(Plane3D self) -> Vector3D"""
5649  return _IMP_algebra.Plane3D_get_normal(self)
5650 
5651  def get_projected(self, p):
5652  r"""get_projected(Plane3D self, Vector3D p) -> Vector3D"""
5653  return _IMP_algebra.Plane3D_get_projected(self, p)
5654 
5655  def get_is_above(self, p):
5656  r"""get_is_above(Plane3D self, Vector3D p) -> bool"""
5657  return _IMP_algebra.Plane3D_get_is_above(self, p)
5658 
5659  def get_is_below(self, p):
5660  r"""get_is_below(Plane3D self, Vector3D p) -> bool"""
5661  return _IMP_algebra.Plane3D_get_is_below(self, p)
5662 
5663  def get_height(self, p):
5664  r"""get_height(Plane3D self, Vector3D p) -> double"""
5665  return _IMP_algebra.Plane3D_get_height(self, p)
5666 
5667  def show(self, *args):
5668  r"""show(Plane3D self, _ostream out=std::cout)"""
5669  return _IMP_algebra.Plane3D_show(self, *args)
5670 
5671  def get_opposite(self):
5672  r"""get_opposite(Plane3D self) -> Plane3D"""
5673  return _IMP_algebra.Plane3D_get_opposite(self)
5674 
5675  def get_distance_from_origin(self):
5676  r"""get_distance_from_origin(Plane3D self) -> double"""
5677  return _IMP_algebra.Plane3D_get_distance_from_origin(self)
5678 
5679  def __str__(self):
5680  r"""__str__(Plane3D self) -> std::string"""
5681  return _IMP_algebra.Plane3D___str__(self)
5682 
5683  def __repr__(self):
5684  r"""__repr__(Plane3D self) -> std::string"""
5685  return _IMP_algebra.Plane3D___repr__(self)
5686 
5687  def _get_as_binary(self):
5688  r"""_get_as_binary(Plane3D self) -> PyObject *"""
5689  return _IMP_algebra.Plane3D__get_as_binary(self)
5690 
5691  def _set_from_binary(self, p):
5692  r"""_set_from_binary(Plane3D self, PyObject * p)"""
5693  return _IMP_algebra.Plane3D__set_from_binary(self, p)
5694 
5695  def __getstate__(self):
5696  p = self._get_as_binary()
5697  if len(self.__dict__) > 1:
5698  d = self.__dict__.copy()
5699  del d['this']
5700  p = (d, p)
5701  return p
5702 
5703  def __setstate__(self, p):
5704  if not hasattr(self, 'this'):
5705  self.__init__()
5706  if isinstance(p, tuple):
5707  d, p = p
5708  self.__dict__.update(d)
5709  return self._set_from_binary(p)
5710 
5711  __swig_destroy__ = _IMP_algebra.delete_Plane3D
5712 
5713 # Register Plane3D in _IMP_algebra:
5714 _IMP_algebra.Plane3D_swigregister(Plane3D)
5715 
5716 def get_reflected(pln, p):
5717  r"""get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
5718  return _IMP_algebra.get_reflected(pln, p)
5719 
5720 def get_plane_3d_geometry(g):
5721  r"""get_plane_3d_geometry(Plane3D g) -> Plane3D"""
5722  return _IMP_algebra.get_plane_3d_geometry(g)
5723 class Reflection3D(_GeometricPrimitive3D):
5724  r"""Proxy of C++ IMP::algebra::Reflection3D class."""
5725 
5726  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5727 
5728  def __init__(self, *args):
5729  r"""
5730  __init__(Reflection3D self) -> Reflection3D
5731  __init__(Reflection3D self, Plane3D pl) -> Reflection3D
5732  """
5733  _IMP_algebra.Reflection3D_swiginit(self, _IMP_algebra.new_Reflection3D(*args))
5734 
5735  def get_reflected(self, v):
5736  r"""get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
5737  return _IMP_algebra.Reflection3D_get_reflected(self, v)
5738 
5739  def show(self, *args):
5740  r"""show(Reflection3D self, _ostream out=std::cout)"""
5741  return _IMP_algebra.Reflection3D_show(self, *args)
5742 
5743  def __str__(self):
5744  r"""__str__(Reflection3D self) -> std::string"""
5745  return _IMP_algebra.Reflection3D___str__(self)
5746 
5747  def __repr__(self):
5748  r"""__repr__(Reflection3D self) -> std::string"""
5749  return _IMP_algebra.Reflection3D___repr__(self)
5750 
5751  def _get_as_binary(self):
5752  r"""_get_as_binary(Reflection3D self) -> PyObject *"""
5753  return _IMP_algebra.Reflection3D__get_as_binary(self)
5754 
5755  def _set_from_binary(self, p):
5756  r"""_set_from_binary(Reflection3D self, PyObject * p)"""
5757  return _IMP_algebra.Reflection3D__set_from_binary(self, p)
5758 
5759  def __getstate__(self):
5760  p = self._get_as_binary()
5761  if len(self.__dict__) > 1:
5762  d = self.__dict__.copy()
5763  del d['this']
5764  p = (d, p)
5765  return p
5766 
5767  def __setstate__(self, p):
5768  if not hasattr(self, 'this'):
5769  self.__init__()
5770  if isinstance(p, tuple):
5771  d, p = p
5772  self.__dict__.update(d)
5773  return self._set_from_binary(p)
5774 
5775  __swig_destroy__ = _IMP_algebra.delete_Reflection3D
5776 
5777 # Register Reflection3D in _IMP_algebra:
5778 _IMP_algebra.Reflection3D_swigregister(Reflection3D)
5779 class Cylinder3D(_GeometricPrimitive3D):
5780  r"""Proxy of C++ IMP::algebra::Cylinder3D class."""
5781 
5782  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5783 
5784  def __init__(self, *args):
5785  r"""
5786  __init__(Cylinder3D self) -> Cylinder3D
5787  __init__(Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
5788  """
5789  _IMP_algebra.Cylinder3D_swiginit(self, _IMP_algebra.new_Cylinder3D(*args))
5790 
5791  def get_radius(self):
5792  r"""get_radius(Cylinder3D self) -> double"""
5793  return _IMP_algebra.Cylinder3D_get_radius(self)
5794 
5795  def get_segment(self):
5796  r"""get_segment(Cylinder3D self) -> Segment3D"""
5797  return _IMP_algebra.Cylinder3D_get_segment(self)
5798 
5799  def get_surface_point_at(self, relative_height, angle):
5800  r"""get_surface_point_at(Cylinder3D self, double relative_height, double angle) -> Vector3D"""
5801  return _IMP_algebra.Cylinder3D_get_surface_point_at(self, relative_height, angle)
5802 
5803  def get_inner_point_at(self, relative_height, relative_radius, angle):
5804  r"""get_inner_point_at(Cylinder3D self, double relative_height, double relative_radius, double angle) -> Vector3D"""
5805  return _IMP_algebra.Cylinder3D_get_inner_point_at(self, relative_height, relative_radius, angle)
5806 
5807  def show(self, *args):
5808  r"""show(Cylinder3D self, _ostream out=std::cout)"""
5809  return _IMP_algebra.Cylinder3D_show(self, *args)
5810 
5811  def __str__(self):
5812  r"""__str__(Cylinder3D self) -> std::string"""
5813  return _IMP_algebra.Cylinder3D___str__(self)
5814 
5815  def __repr__(self):
5816  r"""__repr__(Cylinder3D self) -> std::string"""
5817  return _IMP_algebra.Cylinder3D___repr__(self)
5818 
5819  def _get_as_binary(self):
5820  r"""_get_as_binary(Cylinder3D self) -> PyObject *"""
5821  return _IMP_algebra.Cylinder3D__get_as_binary(self)
5822 
5823  def _set_from_binary(self, p):
5824  r"""_set_from_binary(Cylinder3D self, PyObject * p)"""
5825  return _IMP_algebra.Cylinder3D__set_from_binary(self, p)
5826 
5827  def __getstate__(self):
5828  p = self._get_as_binary()
5829  if len(self.__dict__) > 1:
5830  d = self.__dict__.copy()
5831  del d['this']
5832  p = (d, p)
5833  return p
5834 
5835  def __setstate__(self, p):
5836  if not hasattr(self, 'this'):
5837  self.__init__()
5838  if isinstance(p, tuple):
5839  d, p = p
5840  self.__dict__.update(d)
5841  return self._set_from_binary(p)
5842 
5843  __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
5844 
5845 # Register Cylinder3D in _IMP_algebra:
5846 _IMP_algebra.Cylinder3D_swigregister(Cylinder3D)
5847 
5848 def get_cylinder_3d_geometry(g):
5849  r"""get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
5850  return _IMP_algebra.get_cylinder_3d_geometry(g)
5851 class Ellipsoid3D(_GeometricPrimitive3D):
5852  r"""Proxy of C++ IMP::algebra::Ellipsoid3D class."""
5853 
5854  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5855 
5856  def __init__(self, *args):
5857  r"""
5858  __init__(Ellipsoid3D self) -> Ellipsoid3D
5859  __init__(Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
5860  __init__(Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
5861  """
5862  _IMP_algebra.Ellipsoid3D_swiginit(self, _IMP_algebra.new_Ellipsoid3D(*args))
5863 
5864  def get_radii(self):
5865  r"""get_radii(Ellipsoid3D self) -> Vector3D"""
5866  return _IMP_algebra.Ellipsoid3D_get_radii(self)
5867 
5868  def get_reference_frame(self):
5869  r"""get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
5870  return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)
5871 
5872  def show(self, *args):
5873  r"""show(Ellipsoid3D self, _ostream out=std::cout)"""
5874  return _IMP_algebra.Ellipsoid3D_show(self, *args)
5875 
5876  def __str__(self):
5877  r"""__str__(Ellipsoid3D self) -> std::string"""
5878  return _IMP_algebra.Ellipsoid3D___str__(self)
5879 
5880  def __repr__(self):
5881  r"""__repr__(Ellipsoid3D self) -> std::string"""
5882  return _IMP_algebra.Ellipsoid3D___repr__(self)
5883 
5884  def _get_as_binary(self):
5885  r"""_get_as_binary(Ellipsoid3D self) -> PyObject *"""
5886  return _IMP_algebra.Ellipsoid3D__get_as_binary(self)
5887 
5888  def _set_from_binary(self, p):
5889  r"""_set_from_binary(Ellipsoid3D self, PyObject * p)"""
5890  return _IMP_algebra.Ellipsoid3D__set_from_binary(self, p)
5891 
5892  def __getstate__(self):
5893  p = self._get_as_binary()
5894  if len(self.__dict__) > 1:
5895  d = self.__dict__.copy()
5896  del d['this']
5897  p = (d, p)
5898  return p
5899 
5900  def __setstate__(self, p):
5901  if not hasattr(self, 'this'):
5902  self.__init__()
5903  if isinstance(p, tuple):
5904  d, p = p
5905  self.__dict__.update(d)
5906  return self._set_from_binary(p)
5907 
5908  __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
5909 
5910 # Register Ellipsoid3D in _IMP_algebra:
5911 _IMP_algebra.Ellipsoid3D_swigregister(Ellipsoid3D)
5912 
5913 def get_ellipsoid_3d_geometry(g):
5914  r"""get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
5915  return _IMP_algebra.get_ellipsoid_3d_geometry(g)
5916 class ConnollySurfacePoint(object):
5917  r"""Proxy of C++ IMP::algebra::ConnollySurfacePoint class."""
5918 
5919  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5920 
5921  def __init__(self, *args):
5922  r"""
5923  __init__(ConnollySurfacePoint self) -> ConnollySurfacePoint
5924  __init__(ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
5925  """
5926  _IMP_algebra.ConnollySurfacePoint_swiginit(self, _IMP_algebra.new_ConnollySurfacePoint(*args))
5927 
5928  def get_atom(self, i):
5929  r"""get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
5930  return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)
5931 
5932  def get_surface_point(self):
5933  r"""get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
5934  return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)
5935 
5936  def get_area(self):
5937  r"""get_area(ConnollySurfacePoint self) -> double"""
5938  return _IMP_algebra.ConnollySurfacePoint_get_area(self)
5939 
5940  def get_normal(self):
5941  r"""get_normal(ConnollySurfacePoint self) -> Vector3D"""
5942  return _IMP_algebra.ConnollySurfacePoint_get_normal(self)
5943 
5944  def show(self, *args):
5945  r"""show(ConnollySurfacePoint self, _ostream out=std::cout)"""
5946  return _IMP_algebra.ConnollySurfacePoint_show(self, *args)
5947 
5948  def __str__(self):
5949  r"""__str__(ConnollySurfacePoint self) -> std::string"""
5950  return _IMP_algebra.ConnollySurfacePoint___str__(self)
5951 
5952  def __repr__(self):
5953  r"""__repr__(ConnollySurfacePoint self) -> std::string"""
5954  return _IMP_algebra.ConnollySurfacePoint___repr__(self)
5955 
5956  def _get_as_binary(self):
5957  r"""_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
5958  return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)
5959 
5960  def _set_from_binary(self, p):
5961  r"""_set_from_binary(ConnollySurfacePoint self, PyObject * p)"""
5962  return _IMP_algebra.ConnollySurfacePoint__set_from_binary(self, p)
5963 
5964  def __getstate__(self):
5965  p = self._get_as_binary()
5966  if len(self.__dict__) > 1:
5967  d = self.__dict__.copy()
5968  del d['this']
5969  p = (d, p)
5970  return p
5971 
5972  def __setstate__(self, p):
5973  if not hasattr(self, 'this'):
5974  self.__init__()
5975  if isinstance(p, tuple):
5976  d, p = p
5977  self.__dict__.update(d)
5978  return self._set_from_binary(p)
5979 
5980  __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
5981 
5982 # Register ConnollySurfacePoint in _IMP_algebra:
5983 _IMP_algebra.ConnollySurfacePoint_swigregister(ConnollySurfacePoint)
5984 
5985 def get_connolly_surface(spheres, density, probe_radius):
5986  r"""get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
5987  return _IMP_algebra.get_connolly_surface(spheres, density, probe_radius)
5988 class LogEmbedding3D(object):
5989  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 3 > class."""
5990 
5991  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5992 
5993  def __init__(self, *args):
5994  r"""
5995  __init__(LogEmbedding3D self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
5996  __init__(LogEmbedding3D self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
5997  __init__(LogEmbedding3D self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
5998  __init__(LogEmbedding3D self) -> LogEmbedding3D
5999  """
6000  _IMP_algebra.LogEmbedding3D_swiginit(self, _IMP_algebra.new_LogEmbedding3D(*args))
6001 
6002  def set_origin(self, o):
6003  r"""set_origin(LogEmbedding3D self, Vector3D o)"""
6004  return _IMP_algebra.LogEmbedding3D_set_origin(self, o)
6005 
6006  def get_origin(self):
6007  r"""get_origin(LogEmbedding3D self) -> Vector3D"""
6008  return _IMP_algebra.LogEmbedding3D_get_origin(self)
6009 
6010  def get_dimension(self):
6011  r"""get_dimension(LogEmbedding3D self) -> unsigned int"""
6012  return _IMP_algebra.LogEmbedding3D_get_dimension(self)
6013 
6014  def set_unit_cell(self, *args):
6015  r"""
6016  set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
6017  set_unit_cell(LogEmbedding3D self, Vector3D o)
6018  """
6019  return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)
6020 
6021  def get_unit_cell(self):
6022  r"""get_unit_cell(LogEmbedding3D self) -> Vector3D"""
6023  return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)
6024 
6025  def get_extended_index(self, o):
6026  r"""get_extended_index(LogEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
6027  return _IMP_algebra.LogEmbedding3D_get_extended_index(self, o)
6028 
6029  def get_index(self, o):
6030  r"""get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
6031  return _IMP_algebra.LogEmbedding3D_get_index(self, o)
6032 
6033  def get_center(self, *args):
6034  r"""
6035  get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
6036  get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
6037  """
6038  return _IMP_algebra.LogEmbedding3D_get_center(self, *args)
6039 
6040  def get_bounding_box(self, *args):
6041  r"""
6042  get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
6043  get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
6044  """
6045  return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)
6046 
6047  def show(self, *args):
6048  r"""show(LogEmbedding3D self, _ostream out=std::cout)"""
6049  return _IMP_algebra.LogEmbedding3D_show(self, *args)
6050 
6051  def __str__(self):
6052  r"""__str__(LogEmbedding3D self) -> std::string"""
6053  return _IMP_algebra.LogEmbedding3D___str__(self)
6054 
6055  def __repr__(self):
6056  r"""__repr__(LogEmbedding3D self) -> std::string"""
6057  return _IMP_algebra.LogEmbedding3D___repr__(self)
6058 
6059  def __cmp__(self, arg2):
6060  r"""__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
6061  return _IMP_algebra.LogEmbedding3D___cmp__(self, arg2)
6062 
6063  def __eq__(self, arg2):
6064  r"""__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
6065  return _IMP_algebra.LogEmbedding3D___eq__(self, arg2)
6066 
6067  def _get_as_binary(self):
6068  r"""_get_as_binary(LogEmbedding3D self) -> PyObject *"""
6069  return _IMP_algebra.LogEmbedding3D__get_as_binary(self)
6070 
6071  def _set_from_binary(self, p):
6072  r"""_set_from_binary(LogEmbedding3D self, PyObject * p)"""
6073  return _IMP_algebra.LogEmbedding3D__set_from_binary(self, p)
6074 
6075  def __getstate__(self):
6076  p = self._get_as_binary()
6077  if len(self.__dict__) > 1:
6078  d = self.__dict__.copy()
6079  del d['this']
6080  p = (d, p)
6081  return p
6082 
6083  def __setstate__(self, p):
6084  if not hasattr(self, 'this'):
6085  self.__init__()
6086  if isinstance(p, tuple):
6087  d, p = p
6088  self.__dict__.update(d)
6089  return self._set_from_binary(p)
6090 
6091  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
6092 
6093 # Register LogEmbedding3D in _IMP_algebra:
6094 _IMP_algebra.LogEmbedding3D_swigregister(LogEmbedding3D)
6095 class LogEmbeddingKD(object):
6096  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< -1 > class."""
6097 
6098  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6099 
6100  def __init__(self, *args):
6101  r"""
6102  __init__(LogEmbeddingKD self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
6103  __init__(LogEmbeddingKD self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
6104  __init__(LogEmbeddingKD self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
6105  __init__(LogEmbeddingKD self) -> LogEmbeddingKD
6106  """
6107  _IMP_algebra.LogEmbeddingKD_swiginit(self, _IMP_algebra.new_LogEmbeddingKD(*args))
6108 
6109  def set_origin(self, o):
6110  r"""set_origin(LogEmbeddingKD self, VectorKD o)"""
6111  return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)
6112 
6113  def get_origin(self):
6114  r"""get_origin(LogEmbeddingKD self) -> VectorKD"""
6115  return _IMP_algebra.LogEmbeddingKD_get_origin(self)
6116 
6117  def get_dimension(self):
6118  r"""get_dimension(LogEmbeddingKD self) -> unsigned int"""
6119  return _IMP_algebra.LogEmbeddingKD_get_dimension(self)
6120 
6121  def set_unit_cell(self, *args):
6122  r"""
6123  set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
6124  set_unit_cell(LogEmbeddingKD self, VectorKD o)
6125  """
6126  return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)
6127 
6128  def get_unit_cell(self):
6129  r"""get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
6130  return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)
6131 
6132  def get_extended_index(self, o):
6133  r"""get_extended_index(LogEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
6134  return _IMP_algebra.LogEmbeddingKD_get_extended_index(self, o)
6135 
6136  def get_index(self, o):
6137  r"""get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
6138  return _IMP_algebra.LogEmbeddingKD_get_index(self, o)
6139 
6140  def get_center(self, *args):
6141  r"""
6142  get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
6143  get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
6144  """
6145  return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)
6146 
6147  def get_bounding_box(self, *args):
6148  r"""
6149  get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
6150  get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
6151  """
6152  return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)
6153 
6154  def show(self, *args):
6155  r"""show(LogEmbeddingKD self, _ostream out=std::cout)"""
6156  return _IMP_algebra.LogEmbeddingKD_show(self, *args)
6157 
6158  def __str__(self):
6159  r"""__str__(LogEmbeddingKD self) -> std::string"""
6160  return _IMP_algebra.LogEmbeddingKD___str__(self)
6161 
6162  def __repr__(self):
6163  r"""__repr__(LogEmbeddingKD self) -> std::string"""
6164  return _IMP_algebra.LogEmbeddingKD___repr__(self)
6165 
6166  def __cmp__(self, arg2):
6167  r"""__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
6168  return _IMP_algebra.LogEmbeddingKD___cmp__(self, arg2)
6169 
6170  def __eq__(self, arg2):
6171  r"""__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
6172  return _IMP_algebra.LogEmbeddingKD___eq__(self, arg2)
6173 
6174  def _get_as_binary(self):
6175  r"""_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
6176  return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)
6177 
6178  def _set_from_binary(self, p):
6179  r"""_set_from_binary(LogEmbeddingKD self, PyObject * p)"""
6180  return _IMP_algebra.LogEmbeddingKD__set_from_binary(self, p)
6181 
6182  def __getstate__(self):
6183  p = self._get_as_binary()
6184  if len(self.__dict__) > 1:
6185  d = self.__dict__.copy()
6186  del d['this']
6187  p = (d, p)
6188  return p
6189 
6190  def __setstate__(self, p):
6191  if not hasattr(self, 'this'):
6192  self.__init__()
6193  if isinstance(p, tuple):
6194  d, p = p
6195  self.__dict__.update(d)
6196  return self._set_from_binary(p)
6197 
6198  __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
6199 
6200 # Register LogEmbeddingKD in _IMP_algebra:
6201 _IMP_algebra.LogEmbeddingKD_swigregister(LogEmbeddingKD)
6202 class DenseFloatLogGridKD(object):
6203  r"""Proxy of C++ IMP::algebra::DenseFloatLogGridKD class."""
6204 
6205  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6206 
6207  def __init__(self, sz, le):
6208  r"""__init__(DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
6209  _IMP_algebra.DenseFloatLogGridKD_swiginit(self, _IMP_algebra.new_DenseFloatLogGridKD(sz, le))
6210 
6211  def add_voxel(self, i, q):
6212  r"""add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
6213  return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, i, q)
6214 
6215  def __getitem__(self, *args):
6216  r"""
6217  __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
6218  __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
6219  """
6220  return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)
6221 
6222  def __setitem__(self, *args):
6223  r"""
6224  __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
6225  __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
6226  """
6227  return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)
6228 
6229  def get_bounding_box(self, *args):
6230  r"""
6231  get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6232  get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
6233  """
6234  return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)
6235 
6236  def get_indexes(self, *args):
6237  r"""
6238  get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6239  get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6240  """
6241  return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)
6242 
6243  def get_all_indexes(self):
6244  r"""get_all_indexes(DenseFloatLogGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >"""
6245  return _IMP_algebra.DenseFloatLogGridKD_get_all_indexes(self)
6246 
6247  def get_extended_indexes(self, *args):
6248  r"""
6249  get_extended_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6250  get_extended_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6251  """
6252  return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)
6253 
6254  def get_center(self, *args):
6255  r"""
6256  get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6257  get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
6258  """
6259  return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)
6260 
6261  def get_extended_index(self, v):
6262  r"""get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6263  return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, v)
6264 
6265  def get_index(self, v):
6266  r"""get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6267  return _IMP_algebra.DenseFloatLogGridKD_get_index(self, v)
6268 
6269  def get_origin(self):
6270  r"""get_origin(DenseFloatLogGridKD self) -> VectorKD"""
6271  return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)
6272 
6273  def get_dimension(self):
6274  r"""get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
6275  return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)
6276 
6277  def get_unit_cell(self):
6278  r"""get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
6279  return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)
6280 
6281  def get_has_index(self, v):
6282  r"""get_has_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> bool"""
6283  return _IMP_algebra.DenseFloatLogGridKD_get_has_index(self, v)
6284 
6285  def __str__(self):
6286  r"""__str__(DenseFloatLogGridKD self) -> std::string"""
6287  return _IMP_algebra.DenseFloatLogGridKD___str__(self)
6288 
6289  def __repr__(self):
6290  r"""__repr__(DenseFloatLogGridKD self) -> std::string"""
6291  return _IMP_algebra.DenseFloatLogGridKD___repr__(self)
6292 
6293  def show(self, *args):
6294  r"""show(DenseFloatLogGridKD self, _ostream out=std::cout)"""
6295  return _IMP_algebra.DenseFloatLogGridKD_show(self, *args)
6296  __swig_destroy__ = _IMP_algebra.delete_DenseFloatLogGridKD
6297 
6298 # Register DenseFloatLogGridKD in _IMP_algebra:
6299 _IMP_algebra.DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
6300 class DenseIntLogGrid3D(object):
6301  r"""Proxy of C++ IMP::algebra::DenseIntLogGrid3D class."""
6302 
6303  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6304 
6305  def __init__(self, sz, le):
6306  r"""__init__(DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
6307  _IMP_algebra.DenseIntLogGrid3D_swiginit(self, _IMP_algebra.new_DenseIntLogGrid3D(sz, le))
6308 
6309  def add_voxel(self, i, q):
6310  r"""add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6311  return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, i, q)
6312 
6313  def __getitem__(self, *args):
6314  r"""
6315  __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
6316  __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
6317  """
6318  return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)
6319 
6320  def __setitem__(self, *args):
6321  r"""
6322  __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
6323  __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
6324  """
6325  return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)
6326 
6327  def get_bounding_box(self, *args):
6328  r"""
6329  get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6330  get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
6331  """
6332  return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)
6333 
6334  def get_indexes(self, *args):
6335  r"""
6336  get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6337  get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6338  """
6339  return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)
6340 
6341  def get_all_indexes(self):
6342  r"""get_all_indexes(DenseIntLogGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6343  return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)
6344 
6345  def get_extended_indexes(self, *args):
6346  r"""
6347  get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6348  get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6349  """
6350  return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)
6351 
6352  def get_center(self, *args):
6353  r"""
6354  get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6355  get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
6356  """
6357  return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)
6358 
6359  def get_extended_index(self, v):
6360  r"""get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6361  return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, v)
6362 
6363  def get_index(self, v):
6364  r"""get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6365  return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)
6366 
6367  def get_origin(self):
6368  r"""get_origin(DenseIntLogGrid3D self) -> Vector3D"""
6369  return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)
6370 
6371  def get_dimension(self):
6372  r"""get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
6373  return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)
6374 
6375  def get_unit_cell(self):
6376  r"""get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
6377  return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)
6378 
6379  def get_has_index(self, v):
6380  r"""get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
6381  return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, v)
6382 
6383  def __str__(self):
6384  r"""__str__(DenseIntLogGrid3D self) -> std::string"""
6385  return _IMP_algebra.DenseIntLogGrid3D___str__(self)
6386 
6387  def __repr__(self):
6388  r"""__repr__(DenseIntLogGrid3D self) -> std::string"""
6389  return _IMP_algebra.DenseIntLogGrid3D___repr__(self)
6390 
6391  def show(self, *args):
6392  r"""show(DenseIntLogGrid3D self, _ostream out=std::cout)"""
6393  return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)
6394  __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D
6395 
6396 # Register DenseIntLogGrid3D in _IMP_algebra:
6397 _IMP_algebra.DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
6398 class DenseDoubleGrid3D(object):
6399  r"""Proxy of C++ IMP::algebra::DenseGrid3D< double > class."""
6400 
6401  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6402 
6403  def __init__(self, *args):
6404  r"""
6405  __init__(DenseDoubleGrid3D self, double side, BoundingBox3D bb, double _def=double()) -> DenseDoubleGrid3D
6406  __init__(DenseDoubleGrid3D self) -> DenseDoubleGrid3D
6407  """
6408  _IMP_algebra.DenseDoubleGrid3D_swiginit(self, _IMP_algebra.new_DenseDoubleGrid3D(*args))
6409 
6410  def add_voxel(self, i, q):
6411  r"""add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
6412  return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, i, q)
6413 
6414  def __getitem__(self, *args):
6415  r"""
6416  __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
6417  __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
6418  """
6419  return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)
6420 
6421  def __setitem__(self, *args):
6422  r"""
6423  __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
6424  __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
6425  """
6426  return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)
6427 
6428  def get_bounding_box(self, *args):
6429  r"""
6430  get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6431  get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
6432  """
6433  return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)
6434 
6435  def get_indexes(self, *args):
6436  r"""
6437  get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6438  get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6439  """
6440  return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)
6441 
6442  def get_all_indexes(self):
6443  r"""get_all_indexes(DenseDoubleGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6444  return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)
6445 
6446  def get_extended_indexes(self, *args):
6447  r"""
6448  get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6449  get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6450  """
6451  return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)
6452 
6453  def get_center(self, *args):
6454  r"""
6455  get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6456  get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
6457  """
6458  return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)
6459 
6460  def get_extended_index(self, v):
6461  r"""get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6462  return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, v)
6463 
6464  def get_index(self, v):
6465  r"""get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6466  return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)
6467 
6468  def get_origin(self):
6469  r"""get_origin(DenseDoubleGrid3D self) -> Vector3D"""
6470  return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)
6471 
6472  def get_dimension(self):
6473  r"""get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
6474  return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)
6475 
6476  def get_unit_cell(self):
6477  r"""get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
6478  return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)
6479 
6480  def get_has_index(self, v):
6481  r"""get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
6482  return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, v)
6483 
6484  def __str__(self):
6485  r"""__str__(DenseDoubleGrid3D self) -> std::string"""
6486  return _IMP_algebra.DenseDoubleGrid3D___str__(self)
6487 
6488  def __repr__(self):
6489  r"""__repr__(DenseDoubleGrid3D self) -> std::string"""
6490  return _IMP_algebra.DenseDoubleGrid3D___repr__(self)
6491 
6492  def show(self, *args):
6493  r"""show(DenseDoubleGrid3D self, _ostream out=std::cout)"""
6494  return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)
6495  __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D
6496 
6497 # Register DenseDoubleGrid3D in _IMP_algebra:
6498 _IMP_algebra.DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
6499 class DenseFloatGrid3D(object):
6500  r"""Proxy of C++ IMP::algebra::DenseGrid3D< float > class."""
6501 
6502  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6503 
6504  def __init__(self, *args):
6505  r"""
6506  __init__(DenseFloatGrid3D self, double side, BoundingBox3D bb, float _def=float()) -> DenseFloatGrid3D
6507  __init__(DenseFloatGrid3D self) -> DenseFloatGrid3D
6508  """
6509  _IMP_algebra.DenseFloatGrid3D_swiginit(self, _IMP_algebra.new_DenseFloatGrid3D(*args))
6510 
6511  def add_voxel(self, i, q):
6512  r"""add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
6513  return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, i, q)
6514 
6515  def __getitem__(self, *args):
6516  r"""
6517  __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
6518  __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
6519  """
6520  return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)
6521 
6522  def __setitem__(self, *args):
6523  r"""
6524  __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
6525  __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
6526  """
6527  return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)
6528 
6529  def get_bounding_box(self, *args):
6530  r"""
6531  get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6532  get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
6533  """
6534  return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)
6535 
6536  def get_indexes(self, *args):
6537  r"""
6538  get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6539  get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6540  """
6541  return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)
6542 
6543  def get_all_indexes(self):
6544  r"""get_all_indexes(DenseFloatGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6545  return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)
6546 
6547  def get_extended_indexes(self, *args):
6548  r"""
6549  get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6550  get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6551  """
6552  return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)
6553 
6554  def get_center(self, *args):
6555  r"""
6556  get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6557  get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
6558  """
6559  return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)
6560 
6561  def get_extended_index(self, v):
6562  r"""get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6563  return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, v)
6564 
6565  def get_index(self, v):
6566  r"""get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6567  return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)
6568 
6569  def get_origin(self):
6570  r"""get_origin(DenseFloatGrid3D self) -> Vector3D"""
6571  return _IMP_algebra.DenseFloatGrid3D_get_origin(self)
6572 
6573  def get_dimension(self):
6574  r"""get_dimension(DenseFloatGrid3D self) -> unsigned int"""
6575  return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)
6576 
6577  def get_unit_cell(self):
6578  r"""get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
6579  return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)
6580 
6581  def get_has_index(self, v):
6582  r"""get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
6583  return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, v)
6584 
6585  def __str__(self):
6586  r"""__str__(DenseFloatGrid3D self) -> std::string"""
6587  return _IMP_algebra.DenseFloatGrid3D___str__(self)
6588 
6589  def __repr__(self):
6590  r"""__repr__(DenseFloatGrid3D self) -> std::string"""
6591  return _IMP_algebra.DenseFloatGrid3D___repr__(self)
6592 
6593  def show(self, *args):
6594  r"""show(DenseFloatGrid3D self, _ostream out=std::cout)"""
6595  return _IMP_algebra.DenseFloatGrid3D_show(self, *args)
6596  __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D
6597 
6598 # Register DenseFloatGrid3D in _IMP_algebra:
6599 _IMP_algebra.DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
6600 class SparseUnboundedIntGrid3D(object):
6601  r"""Proxy of C++ IMP::algebra::SparseUnboundedGrid3D< int > class."""
6602 
6603  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6604 
6605  def __init__(self, *args):
6606  r"""
6607  __init__(SparseUnboundedIntGrid3D self, double side, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6608  __init__(SparseUnboundedIntGrid3D self, Vector3D sides, Vector3D origin, int _def=int()) -> SparseUnboundedIntGrid3D
6609  __init__(SparseUnboundedIntGrid3D self) -> SparseUnboundedIntGrid3D
6610  """
6611  _IMP_algebra.SparseUnboundedIntGrid3D_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGrid3D(*args))
6612 
6613  def add_voxel(self, i, q):
6614  r"""add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
6615  return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, i, q)
6616 
6617  def __getitem__(self, *args):
6618  r"""
6619  __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
6620  __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
6621  """
6622  return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)
6623 
6624  def __setitem__(self, *args):
6625  r"""
6626  __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
6627  __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
6628  """
6629  return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)
6630 
6631  def get_bounding_box(self, *args):
6632  r"""
6633  get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
6634  get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
6635  """
6636  return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)
6637 
6638  def get_indexes(self, *args):
6639  r"""
6640  get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6641  get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >
6642  """
6643  return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)
6644 
6645  def get_all_indexes(self):
6646  r"""get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 >,std::allocator< IMP::algebra::GridIndexD< 3 > > >"""
6647  return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)
6648 
6649  def get_extended_indexes(self, *args):
6650  r"""
6651  get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6652  get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 >,std::allocator< IMP::algebra::ExtendedGridIndexD< 3 > > >
6653  """
6654  return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)
6655 
6656  def get_center(self, *args):
6657  r"""
6658  get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
6659  get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
6660  """
6661  return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)
6662 
6663  def get_extended_index(self, v):
6664  r"""get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
6665  return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, v)
6666 
6667  def get_index(self, v):
6668  r"""get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
6669  return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)
6670 
6671  def get_origin(self):
6672  r"""get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
6673  return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)
6674 
6675  def get_dimension(self):
6676  r"""get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
6677  return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)
6678 
6679  def get_unit_cell(self):
6680  r"""get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
6681  return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)
6682 
6683  def get_has_index(self, v):
6684  r"""get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
6685  return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, v)
6686 
6687  def __str__(self):
6688  r"""__str__(SparseUnboundedIntGrid3D self) -> std::string"""
6689  return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)
6690 
6691  def __repr__(self):
6692  r"""__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
6693  return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)
6694 
6695  def show(self, *args):
6696  r"""show(SparseUnboundedIntGrid3D self, _ostream out=std::cout)"""
6697  return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)
6698  __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D
6699 
6700 # Register SparseUnboundedIntGrid3D in _IMP_algebra:
6701 _IMP_algebra.SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
6702 class SparseUnboundedIntGridKD(object):
6703  r"""Proxy of C++ IMP::algebra::SparseUnboundedGridD< -1,int > class."""
6704 
6705  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6706 
6707  def __init__(self, *args):
6708  r"""
6709  __init__(SparseUnboundedIntGridKD self, double side, VectorKD origin, int _def=int()) -> SparseUnboundedIntGridKD
6710  __init__(SparseUnboundedIntGridKD self) -> SparseUnboundedIntGridKD
6711  """
6712  _IMP_algebra.SparseUnboundedIntGridKD_swiginit(self, _IMP_algebra.new_SparseUnboundedIntGridKD(*args))
6713 
6714  def add_voxel(self, i, q):
6715  r"""add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
6716  return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, i, q)
6717 
6718  def __getitem__(self, *args):
6719  r"""
6720  __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
6721  __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
6722  """
6723  return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)
6724 
6725  def __setitem__(self, *args):
6726  r"""
6727  __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
6728  __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
6729  """
6730  return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)
6731 
6732  def get_bounding_box(self, *args):
6733  r"""
6734  get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
6735  get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
6736  """
6737  return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)
6738 
6739  def get_indexes(self, *args):
6740  r"""
6741  get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6742  get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >
6743  """
6744  return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)
6745 
6746  def get_all_indexes(self):
6747  r"""get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 >,std::allocator< IMP::algebra::GridIndexD< -1 > > >"""
6748  return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)
6749 
6750  def get_extended_indexes(self, *args):
6751  r"""
6752  get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6753  get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 >,std::allocator< IMP::algebra::ExtendedGridIndexD< -1 > > >
6754  """
6755  return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)
6756 
6757  def get_center(self, *args):
6758  r"""
6759  get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
6760  get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
6761  """
6762  return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)
6763 
6764  def get_extended_index(self, v):
6765  r"""get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
6766  return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, v)
6767 
6768  def get_index(self, v):
6769  r"""get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
6770  return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)
6771 
6772  def get_origin(self):
6773  r"""get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
6774  return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)
6775 
6776  def get_dimension(self):
6777  r"""get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
6778  return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)
6779 
6780  def get_unit_cell(self):
6781  r"""get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
6782  return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)
6783 
6784  def get_has_index(self, v):
6785  r"""get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
6786  return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, v)
6787 
6788  def __str__(self):
6789  r"""__str__(SparseUnboundedIntGridKD self) -> std::string"""
6790  return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)
6791 
6792  def __repr__(self):
6793  r"""__repr__(SparseUnboundedIntGridKD self) -> std::string"""
6794  return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)
6795 
6796  def show(self, *args):
6797  r"""show(SparseUnboundedIntGridKD self, _ostream out=std::cout)"""
6798  return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)
6799  __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD
6800 
6801 # Register SparseUnboundedIntGridKD in _IMP_algebra:
6802 _IMP_algebra.SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
6803 class GridIndex1D(IMP._Value):
6804  r"""Proxy of C++ IMP::algebra::GridIndexD< 1 > class."""
6805 
6806  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6807 
6808  def __init__(self, *args):
6809  r"""
6810  __init__(GridIndex1D self) -> GridIndex1D
6811  __init__(GridIndex1D self, int x) -> GridIndex1D
6812  __init__(GridIndex1D self, int x, int y) -> GridIndex1D
6813  __init__(GridIndex1D self, int x, int y, int z) -> GridIndex1D
6814  __init__(GridIndex1D self, int i, int j, int k, int l) -> GridIndex1D
6815  __init__(GridIndex1D self, int i, int j, int k, int l, int m) -> GridIndex1D
6816  __init__(GridIndex1D self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
6817  """
6818  _IMP_algebra.GridIndex1D_swiginit(self, _IMP_algebra.new_GridIndex1D(*args))
6819 
6820  def get_dimension(self):
6821  r"""get_dimension(GridIndex1D self) -> unsigned int"""
6822  return _IMP_algebra.GridIndex1D_get_dimension(self)
6823 
6824  def __getitem__(self, i):
6825  r"""__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
6826  return _IMP_algebra.GridIndex1D___getitem__(self, i)
6827 
6828  def show(self, *args):
6829  r"""show(GridIndex1D self, _ostream out=std::cout)"""
6830  return _IMP_algebra.GridIndex1D_show(self, *args)
6831 
6832  def __len__(self):
6833  r"""__len__(GridIndex1D self) -> unsigned int"""
6834  return _IMP_algebra.GridIndex1D___len__(self)
6835 
6836  def __cmp__(self, o):
6837  r"""__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
6838  return _IMP_algebra.GridIndex1D___cmp__(self, o)
6839 
6840  def __eq__(self, o):
6841  r"""__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
6842  return _IMP_algebra.GridIndex1D___eq__(self, o)
6843 
6844  def __ne__(self, o):
6845  r"""__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
6846  return _IMP_algebra.GridIndex1D___ne__(self, o)
6847 
6848  def __lt__(self, o):
6849  r"""__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
6850  return _IMP_algebra.GridIndex1D___lt__(self, o)
6851 
6852  def __gt__(self, o):
6853  r"""__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
6854  return _IMP_algebra.GridIndex1D___gt__(self, o)
6855 
6856  def __ge__(self, o):
6857  r"""__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
6858  return _IMP_algebra.GridIndex1D___ge__(self, o)
6859 
6860  def __le__(self, o):
6861  r"""__le__(GridIndex1D self, GridIndex1D o) -> bool"""
6862  return _IMP_algebra.GridIndex1D___le__(self, o)
6863 
6864  def __hash__(self):
6865  r"""__hash__(GridIndex1D self) -> std::size_t"""
6866  return _IMP_algebra.GridIndex1D___hash__(self)
6867 
6868  def __str__(self):
6869  r"""__str__(GridIndex1D self) -> std::string"""
6870  return _IMP_algebra.GridIndex1D___str__(self)
6871 
6872  def __repr__(self):
6873  r"""__repr__(GridIndex1D self) -> std::string"""
6874  return _IMP_algebra.GridIndex1D___repr__(self)
6875 
6876  def _get_as_binary(self):
6877  r"""_get_as_binary(GridIndex1D self) -> PyObject *"""
6878  return _IMP_algebra.GridIndex1D__get_as_binary(self)
6879 
6880  def _set_from_binary(self, p):
6881  r"""_set_from_binary(GridIndex1D self, PyObject * p)"""
6882  return _IMP_algebra.GridIndex1D__set_from_binary(self, p)
6883 
6884  def __getstate__(self):
6885  p = self._get_as_binary()
6886  if len(self.__dict__) > 1:
6887  d = self.__dict__.copy()
6888  del d['this']
6889  p = (d, p)
6890  return p
6891 
6892  def __setstate__(self, p):
6893  if not hasattr(self, 'this'):
6894  self.__init__()
6895  if isinstance(p, tuple):
6896  d, p = p
6897  self.__dict__.update(d)
6898  return self._set_from_binary(p)
6899 
6900  __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
6901 
6902 # Register GridIndex1D in _IMP_algebra:
6903 _IMP_algebra.GridIndex1D_swigregister(GridIndex1D)
6904 class GridIndex2D(IMP._Value):
6905  r"""Proxy of C++ IMP::algebra::GridIndexD< 2 > class."""
6906 
6907  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6908 
6909  def __init__(self, *args):
6910  r"""
6911  __init__(GridIndex2D self) -> GridIndex2D
6912  __init__(GridIndex2D self, int x) -> GridIndex2D
6913  __init__(GridIndex2D self, int x, int y) -> GridIndex2D
6914  __init__(GridIndex2D self, int x, int y, int z) -> GridIndex2D
6915  __init__(GridIndex2D self, int i, int j, int k, int l) -> GridIndex2D
6916  __init__(GridIndex2D self, int i, int j, int k, int l, int m) -> GridIndex2D
6917  __init__(GridIndex2D self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
6918  """
6919  _IMP_algebra.GridIndex2D_swiginit(self, _IMP_algebra.new_GridIndex2D(*args))
6920 
6921  def get_dimension(self):
6922  r"""get_dimension(GridIndex2D self) -> unsigned int"""
6923  return _IMP_algebra.GridIndex2D_get_dimension(self)
6924 
6925  def __getitem__(self, i):
6926  r"""__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
6927  return _IMP_algebra.GridIndex2D___getitem__(self, i)
6928 
6929  def show(self, *args):
6930  r"""show(GridIndex2D self, _ostream out=std::cout)"""
6931  return _IMP_algebra.GridIndex2D_show(self, *args)
6932 
6933  def __len__(self):
6934  r"""__len__(GridIndex2D self) -> unsigned int"""
6935  return _IMP_algebra.GridIndex2D___len__(self)
6936 
6937  def __cmp__(self, o):
6938  r"""__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
6939  return _IMP_algebra.GridIndex2D___cmp__(self, o)
6940 
6941  def __eq__(self, o):
6942  r"""__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
6943  return _IMP_algebra.GridIndex2D___eq__(self, o)
6944 
6945  def __ne__(self, o):
6946  r"""__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
6947  return _IMP_algebra.GridIndex2D___ne__(self, o)
6948 
6949  def __lt__(self, o):
6950  r"""__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
6951  return _IMP_algebra.GridIndex2D___lt__(self, o)
6952 
6953  def __gt__(self, o):
6954  r"""__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
6955  return _IMP_algebra.GridIndex2D___gt__(self, o)
6956 
6957  def __ge__(self, o):
6958  r"""__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
6959  return _IMP_algebra.GridIndex2D___ge__(self, o)
6960 
6961  def __le__(self, o):
6962  r"""__le__(GridIndex2D self, GridIndex2D o) -> bool"""
6963  return _IMP_algebra.GridIndex2D___le__(self, o)
6964 
6965  def __hash__(self):
6966  r"""__hash__(GridIndex2D self) -> std::size_t"""
6967  return _IMP_algebra.GridIndex2D___hash__(self)
6968 
6969  def __str__(self):
6970  r"""__str__(GridIndex2D self) -> std::string"""
6971  return _IMP_algebra.GridIndex2D___str__(self)
6972 
6973  def __repr__(self):
6974  r"""__repr__(GridIndex2D self) -> std::string"""
6975  return _IMP_algebra.GridIndex2D___repr__(self)
6976 
6977  def _get_as_binary(self):
6978  r"""_get_as_binary(GridIndex2D self) -> PyObject *"""
6979  return _IMP_algebra.GridIndex2D__get_as_binary(self)
6980 
6981  def _set_from_binary(self, p):
6982  r"""_set_from_binary(GridIndex2D self, PyObject * p)"""
6983  return _IMP_algebra.GridIndex2D__set_from_binary(self, p)
6984 
6985  def __getstate__(self):
6986  p = self._get_as_binary()
6987  if len(self.__dict__) > 1:
6988  d = self.__dict__.copy()
6989  del d['this']
6990  p = (d, p)
6991  return p
6992 
6993  def __setstate__(self, p):
6994  if not hasattr(self, 'this'):
6995  self.__init__()
6996  if isinstance(p, tuple):
6997  d, p = p
6998  self.__dict__.update(d)
6999  return self._set_from_binary(p)
7000 
7001  __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
7002 
7003 # Register GridIndex2D in _IMP_algebra:
7004 _IMP_algebra.GridIndex2D_swigregister(GridIndex2D)
7005 class GridIndex3D(IMP._Value):
7006  r"""Proxy of C++ IMP::algebra::GridIndexD< 3 > class."""
7007 
7008  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7009 
7010  def __init__(self, *args):
7011  r"""
7012  __init__(GridIndex3D self) -> GridIndex3D
7013  __init__(GridIndex3D self, int x) -> GridIndex3D
7014  __init__(GridIndex3D self, int x, int y) -> GridIndex3D
7015  __init__(GridIndex3D self, int x, int y, int z) -> GridIndex3D
7016  __init__(GridIndex3D self, int i, int j, int k, int l) -> GridIndex3D
7017  __init__(GridIndex3D self, int i, int j, int k, int l, int m) -> GridIndex3D
7018  __init__(GridIndex3D self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
7019  """
7020  _IMP_algebra.GridIndex3D_swiginit(self, _IMP_algebra.new_GridIndex3D(*args))
7021 
7022  def get_dimension(self):
7023  r"""get_dimension(GridIndex3D self) -> unsigned int"""
7024  return _IMP_algebra.GridIndex3D_get_dimension(self)
7025 
7026  def __getitem__(self, i):
7027  r"""__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
7028  return _IMP_algebra.GridIndex3D___getitem__(self, i)
7029 
7030  def show(self, *args):
7031  r"""show(GridIndex3D self, _ostream out=std::cout)"""
7032  return _IMP_algebra.GridIndex3D_show(self, *args)
7033 
7034  def __len__(self):
7035  r"""__len__(GridIndex3D self) -> unsigned int"""
7036  return _IMP_algebra.GridIndex3D___len__(self)
7037 
7038  def __cmp__(self, o):
7039  r"""__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
7040  return _IMP_algebra.GridIndex3D___cmp__(self, o)
7041 
7042  def __eq__(self, o):
7043  r"""__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
7044  return _IMP_algebra.GridIndex3D___eq__(self, o)
7045 
7046  def __ne__(self, o):
7047  r"""__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
7048  return _IMP_algebra.GridIndex3D___ne__(self, o)
7049 
7050  def __lt__(self, o):
7051  r"""__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
7052  return _IMP_algebra.GridIndex3D___lt__(self, o)
7053 
7054  def __gt__(self, o):
7055  r"""__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
7056  return _IMP_algebra.GridIndex3D___gt__(self, o)
7057 
7058  def __ge__(self, o):
7059  r"""__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
7060  return _IMP_algebra.GridIndex3D___ge__(self, o)
7061 
7062  def __le__(self, o):
7063  r"""__le__(GridIndex3D self, GridIndex3D o) -> bool"""
7064  return _IMP_algebra.GridIndex3D___le__(self, o)
7065 
7066  def __hash__(self):
7067  r"""__hash__(GridIndex3D self) -> std::size_t"""
7068  return _IMP_algebra.GridIndex3D___hash__(self)
7069 
7070  def __str__(self):
7071  r"""__str__(GridIndex3D self) -> std::string"""
7072  return _IMP_algebra.GridIndex3D___str__(self)
7073 
7074  def __repr__(self):
7075  r"""__repr__(GridIndex3D self) -> std::string"""
7076  return _IMP_algebra.GridIndex3D___repr__(self)
7077 
7078  def _get_as_binary(self):
7079  r"""_get_as_binary(GridIndex3D self) -> PyObject *"""
7080  return _IMP_algebra.GridIndex3D__get_as_binary(self)
7081 
7082  def _set_from_binary(self, p):
7083  r"""_set_from_binary(GridIndex3D self, PyObject * p)"""
7084  return _IMP_algebra.GridIndex3D__set_from_binary(self, p)
7085 
7086  def __getstate__(self):
7087  p = self._get_as_binary()
7088  if len(self.__dict__) > 1:
7089  d = self.__dict__.copy()
7090  del d['this']
7091  p = (d, p)
7092  return p
7093 
7094  def __setstate__(self, p):
7095  if not hasattr(self, 'this'):
7096  self.__init__()
7097  if isinstance(p, tuple):
7098  d, p = p
7099  self.__dict__.update(d)
7100  return self._set_from_binary(p)
7101 
7102  __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
7103 
7104 # Register GridIndex3D in _IMP_algebra:
7105 _IMP_algebra.GridIndex3D_swigregister(GridIndex3D)
7106 class GridIndex4D(IMP._Value):
7107  r"""Proxy of C++ IMP::algebra::GridIndexD< 4 > class."""
7108 
7109  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7110 
7111  def __init__(self, *args):
7112  r"""
7113  __init__(GridIndex4D self) -> GridIndex4D
7114  __init__(GridIndex4D self, int x) -> GridIndex4D
7115  __init__(GridIndex4D self, int x, int y) -> GridIndex4D
7116  __init__(GridIndex4D self, int x, int y, int z) -> GridIndex4D
7117  __init__(GridIndex4D self, int i, int j, int k, int l) -> GridIndex4D
7118  __init__(GridIndex4D self, int i, int j, int k, int l, int m) -> GridIndex4D
7119  __init__(GridIndex4D self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
7120  """
7121  _IMP_algebra.GridIndex4D_swiginit(self, _IMP_algebra.new_GridIndex4D(*args))
7122 
7123  def get_dimension(self):
7124  r"""get_dimension(GridIndex4D self) -> unsigned int"""
7125  return _IMP_algebra.GridIndex4D_get_dimension(self)
7126 
7127  def __getitem__(self, i):
7128  r"""__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
7129  return _IMP_algebra.GridIndex4D___getitem__(self, i)
7130 
7131  def show(self, *args):
7132  r"""show(GridIndex4D self, _ostream out=std::cout)"""
7133  return _IMP_algebra.GridIndex4D_show(self, *args)
7134 
7135  def __len__(self):
7136  r"""__len__(GridIndex4D self) -> unsigned int"""
7137  return _IMP_algebra.GridIndex4D___len__(self)
7138 
7139  def __cmp__(self, o):
7140  r"""__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
7141  return _IMP_algebra.GridIndex4D___cmp__(self, o)
7142 
7143  def __eq__(self, o):
7144  r"""__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
7145  return _IMP_algebra.GridIndex4D___eq__(self, o)
7146 
7147  def __ne__(self, o):
7148  r"""__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
7149  return _IMP_algebra.GridIndex4D___ne__(self, o)
7150 
7151  def __lt__(self, o):
7152  r"""__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
7153  return _IMP_algebra.GridIndex4D___lt__(self, o)
7154 
7155  def __gt__(self, o):
7156  r"""__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
7157  return _IMP_algebra.GridIndex4D___gt__(self, o)
7158 
7159  def __ge__(self, o):
7160  r"""__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
7161  return _IMP_algebra.GridIndex4D___ge__(self, o)
7162 
7163  def __le__(self, o):
7164  r"""__le__(GridIndex4D self, GridIndex4D o) -> bool"""
7165  return _IMP_algebra.GridIndex4D___le__(self, o)
7166 
7167  def __hash__(self):
7168  r"""__hash__(GridIndex4D self) -> std::size_t"""
7169  return _IMP_algebra.GridIndex4D___hash__(self)
7170 
7171  def __str__(self):
7172  r"""__str__(GridIndex4D self) -> std::string"""
7173  return _IMP_algebra.GridIndex4D___str__(self)
7174 
7175  def __repr__(self):
7176  r"""__repr__(GridIndex4D self) -> std::string"""
7177  return _IMP_algebra.GridIndex4D___repr__(self)
7178 
7179  def _get_as_binary(self):
7180  r"""_get_as_binary(GridIndex4D self) -> PyObject *"""
7181  return _IMP_algebra.GridIndex4D__get_as_binary(self)
7182 
7183  def _set_from_binary(self, p):
7184  r"""_set_from_binary(GridIndex4D self, PyObject * p)"""
7185  return _IMP_algebra.GridIndex4D__set_from_binary(self, p)
7186 
7187  def __getstate__(self):
7188  p = self._get_as_binary()
7189  if len(self.__dict__) > 1:
7190  d = self.__dict__.copy()
7191  del d['this']
7192  p = (d, p)
7193  return p
7194 
7195  def __setstate__(self, p):
7196  if not hasattr(self, 'this'):
7197  self.__init__()
7198  if isinstance(p, tuple):
7199  d, p = p
7200  self.__dict__.update(d)
7201  return self._set_from_binary(p)
7202 
7203  __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
7204 
7205 # Register GridIndex4D in _IMP_algebra:
7206 _IMP_algebra.GridIndex4D_swigregister(GridIndex4D)
7207 class GridIndex5D(IMP._Value):
7208  r"""Proxy of C++ IMP::algebra::GridIndexD< 5 > class."""
7209 
7210  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7211 
7212  def __init__(self, *args):
7213  r"""
7214  __init__(GridIndex5D self) -> GridIndex5D
7215  __init__(GridIndex5D self, int x) -> GridIndex5D
7216  __init__(GridIndex5D self, int x, int y) -> GridIndex5D
7217  __init__(GridIndex5D self, int x, int y, int z) -> GridIndex5D
7218  __init__(GridIndex5D self, int i, int j, int k, int l) -> GridIndex5D
7219  __init__(GridIndex5D self, int i, int j, int k, int l, int m) -> GridIndex5D
7220  __init__(GridIndex5D self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
7221  """
7222  _IMP_algebra.GridIndex5D_swiginit(self, _IMP_algebra.new_GridIndex5D(*args))
7223 
7224  def get_dimension(self):
7225  r"""get_dimension(GridIndex5D self) -> unsigned int"""
7226  return _IMP_algebra.GridIndex5D_get_dimension(self)
7227 
7228  def __getitem__(self, i):
7229  r"""__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
7230  return _IMP_algebra.GridIndex5D___getitem__(self, i)
7231 
7232  def show(self, *args):
7233  r"""show(GridIndex5D self, _ostream out=std::cout)"""
7234  return _IMP_algebra.GridIndex5D_show(self, *args)
7235 
7236  def __len__(self):
7237  r"""__len__(GridIndex5D self) -> unsigned int"""
7238  return _IMP_algebra.GridIndex5D___len__(self)
7239 
7240  def __cmp__(self, o):
7241  r"""__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
7242  return _IMP_algebra.GridIndex5D___cmp__(self, o)
7243 
7244  def __eq__(self, o):
7245  r"""__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
7246  return _IMP_algebra.GridIndex5D___eq__(self, o)
7247 
7248  def __ne__(self, o):
7249  r"""__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
7250  return _IMP_algebra.GridIndex5D___ne__(self, o)
7251 
7252  def __lt__(self, o):
7253  r"""__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
7254  return _IMP_algebra.GridIndex5D___lt__(self, o)
7255 
7256  def __gt__(self, o):
7257  r"""__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
7258  return _IMP_algebra.GridIndex5D___gt__(self, o)
7259 
7260  def __ge__(self, o):
7261  r"""__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
7262  return _IMP_algebra.GridIndex5D___ge__(self, o)
7263 
7264  def __le__(self, o):
7265  r"""__le__(GridIndex5D self, GridIndex5D o) -> bool"""
7266  return _IMP_algebra.GridIndex5D___le__(self, o)
7267 
7268  def __hash__(self):
7269  r"""__hash__(GridIndex5D self) -> std::size_t"""
7270  return _IMP_algebra.GridIndex5D___hash__(self)
7271 
7272  def __str__(self):
7273  r"""__str__(GridIndex5D self) -> std::string"""
7274  return _IMP_algebra.GridIndex5D___str__(self)
7275 
7276  def __repr__(self):
7277  r"""__repr__(GridIndex5D self) -> std::string"""
7278  return _IMP_algebra.GridIndex5D___repr__(self)
7279 
7280  def _get_as_binary(self):
7281  r"""_get_as_binary(GridIndex5D self) -> PyObject *"""
7282  return _IMP_algebra.GridIndex5D__get_as_binary(self)
7283 
7284  def _set_from_binary(self, p):
7285  r"""_set_from_binary(GridIndex5D self, PyObject * p)"""
7286  return _IMP_algebra.GridIndex5D__set_from_binary(self, p)
7287 
7288  def __getstate__(self):
7289  p = self._get_as_binary()
7290  if len(self.__dict__) > 1:
7291  d = self.__dict__.copy()
7292  del d['this']
7293  p = (d, p)
7294  return p
7295 
7296  def __setstate__(self, p):
7297  if not hasattr(self, 'this'):
7298  self.__init__()
7299  if isinstance(p, tuple):
7300  d, p = p
7301  self.__dict__.update(d)
7302  return self._set_from_binary(p)
7303 
7304  __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
7305 
7306 # Register GridIndex5D in _IMP_algebra:
7307 _IMP_algebra.GridIndex5D_swigregister(GridIndex5D)
7308 class GridIndex6D(IMP._Value):
7309  r"""Proxy of C++ IMP::algebra::GridIndexD< 6 > class."""
7310 
7311  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7312 
7313  def __init__(self, *args):
7314  r"""
7315  __init__(GridIndex6D self) -> GridIndex6D
7316  __init__(GridIndex6D self, int x) -> GridIndex6D
7317  __init__(GridIndex6D self, int x, int y) -> GridIndex6D
7318  __init__(GridIndex6D self, int x, int y, int z) -> GridIndex6D
7319  __init__(GridIndex6D self, int i, int j, int k, int l) -> GridIndex6D
7320  __init__(GridIndex6D self, int i, int j, int k, int l, int m) -> GridIndex6D
7321  __init__(GridIndex6D self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
7322  """
7323  _IMP_algebra.GridIndex6D_swiginit(self, _IMP_algebra.new_GridIndex6D(*args))
7324 
7325  def get_dimension(self):
7326  r"""get_dimension(GridIndex6D self) -> unsigned int"""
7327  return _IMP_algebra.GridIndex6D_get_dimension(self)
7328 
7329  def __getitem__(self, i):
7330  r"""__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
7331  return _IMP_algebra.GridIndex6D___getitem__(self, i)
7332 
7333  def show(self, *args):
7334  r"""show(GridIndex6D self, _ostream out=std::cout)"""
7335  return _IMP_algebra.GridIndex6D_show(self, *args)
7336 
7337  def __len__(self):
7338  r"""__len__(GridIndex6D self) -> unsigned int"""
7339  return _IMP_algebra.GridIndex6D___len__(self)
7340 
7341  def __cmp__(self, o):
7342  r"""__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
7343  return _IMP_algebra.GridIndex6D___cmp__(self, o)
7344 
7345  def __eq__(self, o):
7346  r"""__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
7347  return _IMP_algebra.GridIndex6D___eq__(self, o)
7348 
7349  def __ne__(self, o):
7350  r"""__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
7351  return _IMP_algebra.GridIndex6D___ne__(self, o)
7352 
7353  def __lt__(self, o):
7354  r"""__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
7355  return _IMP_algebra.GridIndex6D___lt__(self, o)
7356 
7357  def __gt__(self, o):
7358  r"""__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
7359  return _IMP_algebra.GridIndex6D___gt__(self, o)
7360 
7361  def __ge__(self, o):
7362  r"""__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
7363  return _IMP_algebra.GridIndex6D___ge__(self, o)
7364 
7365  def __le__(self, o):
7366  r"""__le__(GridIndex6D self, GridIndex6D o) -> bool"""
7367  return _IMP_algebra.GridIndex6D___le__(self, o)
7368 
7369  def __hash__(self):
7370  r"""__hash__(GridIndex6D self) -> std::size_t"""
7371  return _IMP_algebra.GridIndex6D___hash__(self)
7372 
7373  def __str__(self):
7374  r"""__str__(GridIndex6D self) -> std::string"""
7375  return _IMP_algebra.GridIndex6D___str__(self)
7376 
7377  def __repr__(self):
7378  r"""__repr__(GridIndex6D self) -> std::string"""
7379  return _IMP_algebra.GridIndex6D___repr__(self)
7380 
7381  def _get_as_binary(self):
7382  r"""_get_as_binary(GridIndex6D self) -> PyObject *"""
7383  return _IMP_algebra.GridIndex6D__get_as_binary(self)
7384 
7385  def _set_from_binary(self, p):
7386  r"""_set_from_binary(GridIndex6D self, PyObject * p)"""
7387  return _IMP_algebra.GridIndex6D__set_from_binary(self, p)
7388 
7389  def __getstate__(self):
7390  p = self._get_as_binary()
7391  if len(self.__dict__) > 1:
7392  d = self.__dict__.copy()
7393  del d['this']
7394  p = (d, p)
7395  return p
7396 
7397  def __setstate__(self, p):
7398  if not hasattr(self, 'this'):
7399  self.__init__()
7400  if isinstance(p, tuple):
7401  d, p = p
7402  self.__dict__.update(d)
7403  return self._set_from_binary(p)
7404 
7405  __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
7406 
7407 # Register GridIndex6D in _IMP_algebra:
7408 _IMP_algebra.GridIndex6D_swigregister(GridIndex6D)
7409 class GridIndexKD(IMP._Value):
7410  r"""Proxy of C++ IMP::algebra::GridIndexD< -1 > class."""
7411 
7412  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7413 
7414  def __init__(self, *args):
7415  r"""
7416  __init__(GridIndexKD self) -> GridIndexKD
7417  __init__(GridIndexKD self, int x) -> GridIndexKD
7418  __init__(GridIndexKD self, int x, int y) -> GridIndexKD
7419  __init__(GridIndexKD self, int x, int y, int z) -> GridIndexKD
7420  __init__(GridIndexKD self, int i, int j, int k, int l) -> GridIndexKD
7421  __init__(GridIndexKD self, int i, int j, int k, int l, int m) -> GridIndexKD
7422  __init__(GridIndexKD self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
7423  """
7424  _IMP_algebra.GridIndexKD_swiginit(self, _IMP_algebra.new_GridIndexKD(*args))
7425 
7426  def get_dimension(self):
7427  r"""get_dimension(GridIndexKD self) -> unsigned int"""
7428  return _IMP_algebra.GridIndexKD_get_dimension(self)
7429 
7430  def __getitem__(self, i):
7431  r"""__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
7432  return _IMP_algebra.GridIndexKD___getitem__(self, i)
7433 
7434  def show(self, *args):
7435  r"""show(GridIndexKD self, _ostream out=std::cout)"""
7436  return _IMP_algebra.GridIndexKD_show(self, *args)
7437 
7438  def __len__(self):
7439  r"""__len__(GridIndexKD self) -> unsigned int"""
7440  return _IMP_algebra.GridIndexKD___len__(self)
7441 
7442  def __cmp__(self, o):
7443  r"""__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
7444  return _IMP_algebra.GridIndexKD___cmp__(self, o)
7445 
7446  def __eq__(self, o):
7447  r"""__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
7448  return _IMP_algebra.GridIndexKD___eq__(self, o)
7449 
7450  def __ne__(self, o):
7451  r"""__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
7452  return _IMP_algebra.GridIndexKD___ne__(self, o)
7453 
7454  def __lt__(self, o):
7455  r"""__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
7456  return _IMP_algebra.GridIndexKD___lt__(self, o)
7457 
7458  def __gt__(self, o):
7459  r"""__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
7460  return _IMP_algebra.GridIndexKD___gt__(self, o)
7461 
7462  def __ge__(self, o):
7463  r"""__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
7464  return _IMP_algebra.GridIndexKD___ge__(self, o)
7465 
7466  def __le__(self, o):
7467  r"""__le__(GridIndexKD self, GridIndexKD o) -> bool"""
7468  return _IMP_algebra.GridIndexKD___le__(self, o)
7469 
7470  def __hash__(self):
7471  r"""__hash__(GridIndexKD self) -> std::size_t"""
7472  return _IMP_algebra.GridIndexKD___hash__(self)
7473 
7474  def __str__(self):
7475  r"""__str__(GridIndexKD self) -> std::string"""
7476  return _IMP_algebra.GridIndexKD___str__(self)
7477 
7478  def __repr__(self):
7479  r"""__repr__(GridIndexKD self) -> std::string"""
7480  return _IMP_algebra.GridIndexKD___repr__(self)
7481 
7482  def _get_as_binary(self):
7483  r"""_get_as_binary(GridIndexKD self) -> PyObject *"""
7484  return _IMP_algebra.GridIndexKD__get_as_binary(self)
7485 
7486  def _set_from_binary(self, p):
7487  r"""_set_from_binary(GridIndexKD self, PyObject * p)"""
7488  return _IMP_algebra.GridIndexKD__set_from_binary(self, p)
7489 
7490  def __getstate__(self):
7491  p = self._get_as_binary()
7492  if len(self.__dict__) > 1:
7493  d = self.__dict__.copy()
7494  del d['this']
7495  p = (d, p)
7496  return p
7497 
7498  def __setstate__(self, p):
7499  if not hasattr(self, 'this'):
7500  self.__init__()
7501  if isinstance(p, tuple):
7502  d, p = p
7503  self.__dict__.update(d)
7504  return self._set_from_binary(p)
7505 
7506  __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
7507 
7508 # Register GridIndexKD in _IMP_algebra:
7509 _IMP_algebra.GridIndexKD_swigregister(GridIndexKD)
7510 class ExtendedGridIndex1D(IMP._Value):
7511  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 1 > class."""
7512 
7513  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7514 
7515  def __init__(self, *args):
7516  r"""
7517  __init__(ExtendedGridIndex1D self, IMP::Ints vals) -> ExtendedGridIndex1D
7518  __init__(ExtendedGridIndex1D self, int x) -> ExtendedGridIndex1D
7519  __init__(ExtendedGridIndex1D self, int x, int y) -> ExtendedGridIndex1D
7520  __init__(ExtendedGridIndex1D self, int x, int y, int z) -> ExtendedGridIndex1D
7521  __init__(ExtendedGridIndex1D self, int i, int j, int k, int l) -> ExtendedGridIndex1D
7522  __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
7523  __init__(ExtendedGridIndex1D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
7524  __init__(ExtendedGridIndex1D self) -> ExtendedGridIndex1D
7525  """
7526  _IMP_algebra.ExtendedGridIndex1D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex1D(*args))
7527 
7528  def get_dimension(self):
7529  r"""get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
7530  return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)
7531 
7532  def __cmp__(self, o):
7533  r"""__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
7534  return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, o)
7535 
7536  def __eq__(self, o):
7537  r"""__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7538  return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)
7539 
7540  def __ne__(self, o):
7541  r"""__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7542  return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)
7543 
7544  def __lt__(self, o):
7545  r"""__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7546  return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)
7547 
7548  def __gt__(self, o):
7549  r"""__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7550  return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)
7551 
7552  def __ge__(self, o):
7553  r"""__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7554  return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)
7555 
7556  def __le__(self, o):
7557  r"""__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
7558  return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)
7559 
7560  def __setitem__(self, i, v):
7561  r"""__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
7562  return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, i, v)
7563 
7564  def __getitem__(self, i):
7565  r"""__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
7566  return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)
7567 
7568  def show(self, *args):
7569  r"""show(ExtendedGridIndex1D self, _ostream out=std::cout)"""
7570  return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)
7571 
7572  def __len__(self):
7573  r"""__len__(ExtendedGridIndex1D self) -> unsigned int"""
7574  return _IMP_algebra.ExtendedGridIndex1D___len__(self)
7575 
7576  def __hash__(self):
7577  r"""__hash__(ExtendedGridIndex1D self) -> std::size_t"""
7578  return _IMP_algebra.ExtendedGridIndex1D___hash__(self)
7579 
7580  def get_uniform_offset(self, ii):
7581  r"""get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
7582  return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, ii)
7583 
7584  def get_offset(self, i, j, k):
7585  r"""get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
7586  return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, i, j, k)
7587 
7588  def __str__(self):
7589  r"""__str__(ExtendedGridIndex1D self) -> std::string"""
7590  return _IMP_algebra.ExtendedGridIndex1D___str__(self)
7591 
7592  def __repr__(self):
7593  r"""__repr__(ExtendedGridIndex1D self) -> std::string"""
7594  return _IMP_algebra.ExtendedGridIndex1D___repr__(self)
7595 
7596  def _get_as_binary(self):
7597  r"""_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
7598  return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)
7599 
7600  def _set_from_binary(self, p):
7601  r"""_set_from_binary(ExtendedGridIndex1D self, PyObject * p)"""
7602  return _IMP_algebra.ExtendedGridIndex1D__set_from_binary(self, p)
7603 
7604  def __getstate__(self):
7605  p = self._get_as_binary()
7606  if len(self.__dict__) > 1:
7607  d = self.__dict__.copy()
7608  del d['this']
7609  p = (d, p)
7610  return p
7611 
7612  def __setstate__(self, p):
7613  if not hasattr(self, 'this'):
7614  self.__init__()
7615  if isinstance(p, tuple):
7616  d, p = p
7617  self.__dict__.update(d)
7618  return self._set_from_binary(p)
7619 
7620  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
7621 
7622 # Register ExtendedGridIndex1D in _IMP_algebra:
7623 _IMP_algebra.ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
7624 class ExtendedGridIndex2D(IMP._Value):
7625  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 2 > class."""
7626 
7627  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7628 
7629  def __init__(self, *args):
7630  r"""
7631  __init__(ExtendedGridIndex2D self, IMP::Ints vals) -> ExtendedGridIndex2D
7632  __init__(ExtendedGridIndex2D self, int x) -> ExtendedGridIndex2D
7633  __init__(ExtendedGridIndex2D self, int x, int y) -> ExtendedGridIndex2D
7634  __init__(ExtendedGridIndex2D self, int x, int y, int z) -> ExtendedGridIndex2D
7635  __init__(ExtendedGridIndex2D self, int i, int j, int k, int l) -> ExtendedGridIndex2D
7636  __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
7637  __init__(ExtendedGridIndex2D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
7638  __init__(ExtendedGridIndex2D self) -> ExtendedGridIndex2D
7639  """
7640  _IMP_algebra.ExtendedGridIndex2D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex2D(*args))
7641 
7642  def get_dimension(self):
7643  r"""get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
7644  return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)
7645 
7646  def __cmp__(self, o):
7647  r"""__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
7648  return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, o)
7649 
7650  def __eq__(self, o):
7651  r"""__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7652  return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)
7653 
7654  def __ne__(self, o):
7655  r"""__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7656  return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)
7657 
7658  def __lt__(self, o):
7659  r"""__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7660  return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)
7661 
7662  def __gt__(self, o):
7663  r"""__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7664  return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)
7665 
7666  def __ge__(self, o):
7667  r"""__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7668  return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)
7669 
7670  def __le__(self, o):
7671  r"""__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
7672  return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)
7673 
7674  def __setitem__(self, i, v):
7675  r"""__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
7676  return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, i, v)
7677 
7678  def __getitem__(self, i):
7679  r"""__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
7680  return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)
7681 
7682  def show(self, *args):
7683  r"""show(ExtendedGridIndex2D self, _ostream out=std::cout)"""
7684  return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)
7685 
7686  def __len__(self):
7687  r"""__len__(ExtendedGridIndex2D self) -> unsigned int"""
7688  return _IMP_algebra.ExtendedGridIndex2D___len__(self)
7689 
7690  def __hash__(self):
7691  r"""__hash__(ExtendedGridIndex2D self) -> std::size_t"""
7692  return _IMP_algebra.ExtendedGridIndex2D___hash__(self)
7693 
7694  def get_uniform_offset(self, ii):
7695  r"""get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
7696  return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, ii)
7697 
7698  def get_offset(self, i, j, k):
7699  r"""get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
7700  return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, i, j, k)
7701 
7702  def __str__(self):
7703  r"""__str__(ExtendedGridIndex2D self) -> std::string"""
7704  return _IMP_algebra.ExtendedGridIndex2D___str__(self)
7705 
7706  def __repr__(self):
7707  r"""__repr__(ExtendedGridIndex2D self) -> std::string"""
7708  return _IMP_algebra.ExtendedGridIndex2D___repr__(self)
7709 
7710  def _get_as_binary(self):
7711  r"""_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
7712  return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)
7713 
7714  def _set_from_binary(self, p):
7715  r"""_set_from_binary(ExtendedGridIndex2D self, PyObject * p)"""
7716  return _IMP_algebra.ExtendedGridIndex2D__set_from_binary(self, p)
7717 
7718  def __getstate__(self):
7719  p = self._get_as_binary()
7720  if len(self.__dict__) > 1:
7721  d = self.__dict__.copy()
7722  del d['this']
7723  p = (d, p)
7724  return p
7725 
7726  def __setstate__(self, p):
7727  if not hasattr(self, 'this'):
7728  self.__init__()
7729  if isinstance(p, tuple):
7730  d, p = p
7731  self.__dict__.update(d)
7732  return self._set_from_binary(p)
7733 
7734  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
7735 
7736 # Register ExtendedGridIndex2D in _IMP_algebra:
7737 _IMP_algebra.ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
7738 class ExtendedGridIndex3D(IMP._Value):
7739  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 3 > class."""
7740 
7741  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7742 
7743  def __init__(self, *args):
7744  r"""
7745  __init__(ExtendedGridIndex3D self, IMP::Ints vals) -> ExtendedGridIndex3D
7746  __init__(ExtendedGridIndex3D self, int x) -> ExtendedGridIndex3D
7747  __init__(ExtendedGridIndex3D self, int x, int y) -> ExtendedGridIndex3D
7748  __init__(ExtendedGridIndex3D self, int x, int y, int z) -> ExtendedGridIndex3D
7749  __init__(ExtendedGridIndex3D self, int i, int j, int k, int l) -> ExtendedGridIndex3D
7750  __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
7751  __init__(ExtendedGridIndex3D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
7752  __init__(ExtendedGridIndex3D self) -> ExtendedGridIndex3D
7753  """
7754  _IMP_algebra.ExtendedGridIndex3D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex3D(*args))
7755 
7756  def get_dimension(self):
7757  r"""get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
7758  return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)
7759 
7760  def __cmp__(self, o):
7761  r"""__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
7762  return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, o)
7763 
7764  def __eq__(self, o):
7765  r"""__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7766  return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)
7767 
7768  def __ne__(self, o):
7769  r"""__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7770  return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)
7771 
7772  def __lt__(self, o):
7773  r"""__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7774  return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)
7775 
7776  def __gt__(self, o):
7777  r"""__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7778  return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)
7779 
7780  def __ge__(self, o):
7781  r"""__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7782  return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)
7783 
7784  def __le__(self, o):
7785  r"""__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
7786  return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)
7787 
7788  def __setitem__(self, i, v):
7789  r"""__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
7790  return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, i, v)
7791 
7792  def __getitem__(self, i):
7793  r"""__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
7794  return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)
7795 
7796  def show(self, *args):
7797  r"""show(ExtendedGridIndex3D self, _ostream out=std::cout)"""
7798  return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)
7799 
7800  def __len__(self):
7801  r"""__len__(ExtendedGridIndex3D self) -> unsigned int"""
7802  return _IMP_algebra.ExtendedGridIndex3D___len__(self)
7803 
7804  def __hash__(self):
7805  r"""__hash__(ExtendedGridIndex3D self) -> std::size_t"""
7806  return _IMP_algebra.ExtendedGridIndex3D___hash__(self)
7807 
7808  def get_uniform_offset(self, ii):
7809  r"""get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
7810  return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, ii)
7811 
7812  def get_offset(self, i, j, k):
7813  r"""get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
7814  return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, i, j, k)
7815 
7816  def __str__(self):
7817  r"""__str__(ExtendedGridIndex3D self) -> std::string"""
7818  return _IMP_algebra.ExtendedGridIndex3D___str__(self)
7819 
7820  def __repr__(self):
7821  r"""__repr__(ExtendedGridIndex3D self) -> std::string"""
7822  return _IMP_algebra.ExtendedGridIndex3D___repr__(self)
7823 
7824  def _get_as_binary(self):
7825  r"""_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
7826  return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)
7827 
7828  def _set_from_binary(self, p):
7829  r"""_set_from_binary(ExtendedGridIndex3D self, PyObject * p)"""
7830  return _IMP_algebra.ExtendedGridIndex3D__set_from_binary(self, p)
7831 
7832  def __getstate__(self):
7833  p = self._get_as_binary()
7834  if len(self.__dict__) > 1:
7835  d = self.__dict__.copy()
7836  del d['this']
7837  p = (d, p)
7838  return p
7839 
7840  def __setstate__(self, p):
7841  if not hasattr(self, 'this'):
7842  self.__init__()
7843  if isinstance(p, tuple):
7844  d, p = p
7845  self.__dict__.update(d)
7846  return self._set_from_binary(p)
7847 
7848  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
7849 
7850 # Register ExtendedGridIndex3D in _IMP_algebra:
7851 _IMP_algebra.ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
7852 class ExtendedGridIndex4D(IMP._Value):
7853  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 4 > class."""
7854 
7855  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7856 
7857  def __init__(self, *args):
7858  r"""
7859  __init__(ExtendedGridIndex4D self, IMP::Ints vals) -> ExtendedGridIndex4D
7860  __init__(ExtendedGridIndex4D self, int x) -> ExtendedGridIndex4D
7861  __init__(ExtendedGridIndex4D self, int x, int y) -> ExtendedGridIndex4D
7862  __init__(ExtendedGridIndex4D self, int x, int y, int z) -> ExtendedGridIndex4D
7863  __init__(ExtendedGridIndex4D self, int i, int j, int k, int l) -> ExtendedGridIndex4D
7864  __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
7865  __init__(ExtendedGridIndex4D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
7866  __init__(ExtendedGridIndex4D self) -> ExtendedGridIndex4D
7867  """
7868  _IMP_algebra.ExtendedGridIndex4D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex4D(*args))
7869 
7870  def get_dimension(self):
7871  r"""get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
7872  return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)
7873 
7874  def __cmp__(self, o):
7875  r"""__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
7876  return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, o)
7877 
7878  def __eq__(self, o):
7879  r"""__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7880  return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)
7881 
7882  def __ne__(self, o):
7883  r"""__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7884  return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)
7885 
7886  def __lt__(self, o):
7887  r"""__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7888  return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)
7889 
7890  def __gt__(self, o):
7891  r"""__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7892  return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)
7893 
7894  def __ge__(self, o):
7895  r"""__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7896  return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)
7897 
7898  def __le__(self, o):
7899  r"""__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
7900  return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)
7901 
7902  def __setitem__(self, i, v):
7903  r"""__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
7904  return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, i, v)
7905 
7906  def __getitem__(self, i):
7907  r"""__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
7908  return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)
7909 
7910  def show(self, *args):
7911  r"""show(ExtendedGridIndex4D self, _ostream out=std::cout)"""
7912  return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)
7913 
7914  def __len__(self):
7915  r"""__len__(ExtendedGridIndex4D self) -> unsigned int"""
7916  return _IMP_algebra.ExtendedGridIndex4D___len__(self)
7917 
7918  def __hash__(self):
7919  r"""__hash__(ExtendedGridIndex4D self) -> std::size_t"""
7920  return _IMP_algebra.ExtendedGridIndex4D___hash__(self)
7921 
7922  def get_uniform_offset(self, ii):
7923  r"""get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
7924  return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, ii)
7925 
7926  def get_offset(self, i, j, k):
7927  r"""get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
7928  return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, i, j, k)
7929 
7930  def __str__(self):
7931  r"""__str__(ExtendedGridIndex4D self) -> std::string"""
7932  return _IMP_algebra.ExtendedGridIndex4D___str__(self)
7933 
7934  def __repr__(self):
7935  r"""__repr__(ExtendedGridIndex4D self) -> std::string"""
7936  return _IMP_algebra.ExtendedGridIndex4D___repr__(self)
7937 
7938  def _get_as_binary(self):
7939  r"""_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
7940  return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)
7941 
7942  def _set_from_binary(self, p):
7943  r"""_set_from_binary(ExtendedGridIndex4D self, PyObject * p)"""
7944  return _IMP_algebra.ExtendedGridIndex4D__set_from_binary(self, p)
7945 
7946  def __getstate__(self):
7947  p = self._get_as_binary()
7948  if len(self.__dict__) > 1:
7949  d = self.__dict__.copy()
7950  del d['this']
7951  p = (d, p)
7952  return p
7953 
7954  def __setstate__(self, p):
7955  if not hasattr(self, 'this'):
7956  self.__init__()
7957  if isinstance(p, tuple):
7958  d, p = p
7959  self.__dict__.update(d)
7960  return self._set_from_binary(p)
7961 
7962  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
7963 
7964 # Register ExtendedGridIndex4D in _IMP_algebra:
7965 _IMP_algebra.ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
7966 class ExtendedGridIndex5D(IMP._Value):
7967  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 5 > class."""
7968 
7969  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
7970 
7971  def __init__(self, *args):
7972  r"""
7973  __init__(ExtendedGridIndex5D self, IMP::Ints vals) -> ExtendedGridIndex5D
7974  __init__(ExtendedGridIndex5D self, int x) -> ExtendedGridIndex5D
7975  __init__(ExtendedGridIndex5D self, int x, int y) -> ExtendedGridIndex5D
7976  __init__(ExtendedGridIndex5D self, int x, int y, int z) -> ExtendedGridIndex5D
7977  __init__(ExtendedGridIndex5D self, int i, int j, int k, int l) -> ExtendedGridIndex5D
7978  __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
7979  __init__(ExtendedGridIndex5D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
7980  __init__(ExtendedGridIndex5D self) -> ExtendedGridIndex5D
7981  """
7982  _IMP_algebra.ExtendedGridIndex5D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex5D(*args))
7983 
7984  def get_dimension(self):
7985  r"""get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
7986  return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)
7987 
7988  def __cmp__(self, o):
7989  r"""__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
7990  return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, o)
7991 
7992  def __eq__(self, o):
7993  r"""__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7994  return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)
7995 
7996  def __ne__(self, o):
7997  r"""__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
7998  return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)
7999 
8000  def __lt__(self, o):
8001  r"""__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8002  return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)
8003 
8004  def __gt__(self, o):
8005  r"""__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8006  return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)
8007 
8008  def __ge__(self, o):
8009  r"""__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8010  return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)
8011 
8012  def __le__(self, o):
8013  r"""__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
8014  return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)
8015 
8016  def __setitem__(self, i, v):
8017  r"""__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
8018  return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, i, v)
8019 
8020  def __getitem__(self, i):
8021  r"""__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
8022  return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)
8023 
8024  def show(self, *args):
8025  r"""show(ExtendedGridIndex5D self, _ostream out=std::cout)"""
8026  return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)
8027 
8028  def __len__(self):
8029  r"""__len__(ExtendedGridIndex5D self) -> unsigned int"""
8030  return _IMP_algebra.ExtendedGridIndex5D___len__(self)
8031 
8032  def __hash__(self):
8033  r"""__hash__(ExtendedGridIndex5D self) -> std::size_t"""
8034  return _IMP_algebra.ExtendedGridIndex5D___hash__(self)
8035 
8036  def get_uniform_offset(self, ii):
8037  r"""get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
8038  return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, ii)
8039 
8040  def get_offset(self, i, j, k):
8041  r"""get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
8042  return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, i, j, k)
8043 
8044  def __str__(self):
8045  r"""__str__(ExtendedGridIndex5D self) -> std::string"""
8046  return _IMP_algebra.ExtendedGridIndex5D___str__(self)
8047 
8048  def __repr__(self):
8049  r"""__repr__(ExtendedGridIndex5D self) -> std::string"""
8050  return _IMP_algebra.ExtendedGridIndex5D___repr__(self)
8051 
8052  def _get_as_binary(self):
8053  r"""_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
8054  return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)
8055 
8056  def _set_from_binary(self, p):
8057  r"""_set_from_binary(ExtendedGridIndex5D self, PyObject * p)"""
8058  return _IMP_algebra.ExtendedGridIndex5D__set_from_binary(self, p)
8059 
8060  def __getstate__(self):
8061  p = self._get_as_binary()
8062  if len(self.__dict__) > 1:
8063  d = self.__dict__.copy()
8064  del d['this']
8065  p = (d, p)
8066  return p
8067 
8068  def __setstate__(self, p):
8069  if not hasattr(self, 'this'):
8070  self.__init__()
8071  if isinstance(p, tuple):
8072  d, p = p
8073  self.__dict__.update(d)
8074  return self._set_from_binary(p)
8075 
8076  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
8077 
8078 # Register ExtendedGridIndex5D in _IMP_algebra:
8079 _IMP_algebra.ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
8080 class ExtendedGridIndex6D(IMP._Value):
8081  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< 6 > class."""
8082 
8083  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8084 
8085  def __init__(self, *args):
8086  r"""
8087  __init__(ExtendedGridIndex6D self, IMP::Ints vals) -> ExtendedGridIndex6D
8088  __init__(ExtendedGridIndex6D self, int x) -> ExtendedGridIndex6D
8089  __init__(ExtendedGridIndex6D self, int x, int y) -> ExtendedGridIndex6D
8090  __init__(ExtendedGridIndex6D self, int x, int y, int z) -> ExtendedGridIndex6D
8091  __init__(ExtendedGridIndex6D self, int i, int j, int k, int l) -> ExtendedGridIndex6D
8092  __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
8093  __init__(ExtendedGridIndex6D self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
8094  __init__(ExtendedGridIndex6D self) -> ExtendedGridIndex6D
8095  """
8096  _IMP_algebra.ExtendedGridIndex6D_swiginit(self, _IMP_algebra.new_ExtendedGridIndex6D(*args))
8097 
8098  def get_dimension(self):
8099  r"""get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
8100  return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)
8101 
8102  def __cmp__(self, o):
8103  r"""__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
8104  return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, o)
8105 
8106  def __eq__(self, o):
8107  r"""__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8108  return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)
8109 
8110  def __ne__(self, o):
8111  r"""__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8112  return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)
8113 
8114  def __lt__(self, o):
8115  r"""__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8116  return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)
8117 
8118  def __gt__(self, o):
8119  r"""__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8120  return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)
8121 
8122  def __ge__(self, o):
8123  r"""__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8124  return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)
8125 
8126  def __le__(self, o):
8127  r"""__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
8128  return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)
8129 
8130  def __setitem__(self, i, v):
8131  r"""__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
8132  return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, i, v)
8133 
8134  def __getitem__(self, i):
8135  r"""__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
8136  return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)
8137 
8138  def show(self, *args):
8139  r"""show(ExtendedGridIndex6D self, _ostream out=std::cout)"""
8140  return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)
8141 
8142  def __len__(self):
8143  r"""__len__(ExtendedGridIndex6D self) -> unsigned int"""
8144  return _IMP_algebra.ExtendedGridIndex6D___len__(self)
8145 
8146  def __hash__(self):
8147  r"""__hash__(ExtendedGridIndex6D self) -> std::size_t"""
8148  return _IMP_algebra.ExtendedGridIndex6D___hash__(self)
8149 
8150  def get_uniform_offset(self, ii):
8151  r"""get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
8152  return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, ii)
8153 
8154  def get_offset(self, i, j, k):
8155  r"""get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
8156  return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, i, j, k)
8157 
8158  def __str__(self):
8159  r"""__str__(ExtendedGridIndex6D self) -> std::string"""
8160  return _IMP_algebra.ExtendedGridIndex6D___str__(self)
8161 
8162  def __repr__(self):
8163  r"""__repr__(ExtendedGridIndex6D self) -> std::string"""
8164  return _IMP_algebra.ExtendedGridIndex6D___repr__(self)
8165 
8166  def _get_as_binary(self):
8167  r"""_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
8168  return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)
8169 
8170  def _set_from_binary(self, p):
8171  r"""_set_from_binary(ExtendedGridIndex6D self, PyObject * p)"""
8172  return _IMP_algebra.ExtendedGridIndex6D__set_from_binary(self, p)
8173 
8174  def __getstate__(self):
8175  p = self._get_as_binary()
8176  if len(self.__dict__) > 1:
8177  d = self.__dict__.copy()
8178  del d['this']
8179  p = (d, p)
8180  return p
8181 
8182  def __setstate__(self, p):
8183  if not hasattr(self, 'this'):
8184  self.__init__()
8185  if isinstance(p, tuple):
8186  d, p = p
8187  self.__dict__.update(d)
8188  return self._set_from_binary(p)
8189 
8190  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
8191 
8192 # Register ExtendedGridIndex6D in _IMP_algebra:
8193 _IMP_algebra.ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
8194 class ExtendedGridIndexKD(IMP._Value):
8195  r"""Proxy of C++ IMP::algebra::ExtendedGridIndexD< -1 > class."""
8196 
8197  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8198 
8199  def __init__(self, *args):
8200  r"""
8201  __init__(ExtendedGridIndexKD self, IMP::Ints vals) -> ExtendedGridIndexKD
8202  __init__(ExtendedGridIndexKD self, int x) -> ExtendedGridIndexKD
8203  __init__(ExtendedGridIndexKD self, int x, int y) -> ExtendedGridIndexKD
8204  __init__(ExtendedGridIndexKD self, int x, int y, int z) -> ExtendedGridIndexKD
8205  __init__(ExtendedGridIndexKD self, int i, int j, int k, int l) -> ExtendedGridIndexKD
8206  __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
8207  __init__(ExtendedGridIndexKD self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
8208  __init__(ExtendedGridIndexKD self) -> ExtendedGridIndexKD
8209  """
8210  _IMP_algebra.ExtendedGridIndexKD_swiginit(self, _IMP_algebra.new_ExtendedGridIndexKD(*args))
8211 
8212  def get_dimension(self):
8213  r"""get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
8214  return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)
8215 
8216  def __cmp__(self, o):
8217  r"""__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
8218  return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, o)
8219 
8220  def __eq__(self, o):
8221  r"""__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8222  return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)
8223 
8224  def __ne__(self, o):
8225  r"""__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8226  return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)
8227 
8228  def __lt__(self, o):
8229  r"""__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8230  return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)
8231 
8232  def __gt__(self, o):
8233  r"""__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8234  return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)
8235 
8236  def __ge__(self, o):
8237  r"""__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8238  return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)
8239 
8240  def __le__(self, o):
8241  r"""__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
8242  return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)
8243 
8244  def __setitem__(self, i, v):
8245  r"""__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
8246  return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, i, v)
8247 
8248  def __getitem__(self, i):
8249  r"""__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
8250  return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)
8251 
8252  def show(self, *args):
8253  r"""show(ExtendedGridIndexKD self, _ostream out=std::cout)"""
8254  return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)
8255 
8256  def __len__(self):
8257  r"""__len__(ExtendedGridIndexKD self) -> unsigned int"""
8258  return _IMP_algebra.ExtendedGridIndexKD___len__(self)
8259 
8260  def __hash__(self):
8261  r"""__hash__(ExtendedGridIndexKD self) -> std::size_t"""
8262  return _IMP_algebra.ExtendedGridIndexKD___hash__(self)
8263 
8264  def get_uniform_offset(self, ii):
8265  r"""get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
8266  return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, ii)
8267 
8268  def get_offset(self, i, j, k):
8269  r"""get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
8270  return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, i, j, k)
8271 
8272  def __str__(self):
8273  r"""__str__(ExtendedGridIndexKD self) -> std::string"""
8274  return _IMP_algebra.ExtendedGridIndexKD___str__(self)
8275 
8276  def __repr__(self):
8277  r"""__repr__(ExtendedGridIndexKD self) -> std::string"""
8278  return _IMP_algebra.ExtendedGridIndexKD___repr__(self)
8279 
8280  def _get_as_binary(self):
8281  r"""_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
8282  return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)
8283 
8284  def _set_from_binary(self, p):
8285  r"""_set_from_binary(ExtendedGridIndexKD self, PyObject * p)"""
8286  return _IMP_algebra.ExtendedGridIndexKD__set_from_binary(self, p)
8287 
8288  def __getstate__(self):
8289  p = self._get_as_binary()
8290  if len(self.__dict__) > 1:
8291  d = self.__dict__.copy()
8292  del d['this']
8293  p = (d, p)
8294  return p
8295 
8296  def __setstate__(self, p):
8297  if not hasattr(self, 'this'):
8298  self.__init__()
8299  if isinstance(p, tuple):
8300  d, p = p
8301  self.__dict__.update(d)
8302  return self._set_from_binary(p)
8303 
8304  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
8305 
8306 # Register ExtendedGridIndexKD in _IMP_algebra:
8307 _IMP_algebra.ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
8308 class BoundedGridRange1D(object):
8309  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 1 > class."""
8310 
8311  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8312 
8313  @staticmethod
8314  def get_is_bounded():
8315  r"""get_is_bounded() -> bool"""
8316  return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
8317 
8318  def __init__(self, *args):
8319  r"""
8320  __init__(BoundedGridRange1D self) -> BoundedGridRange1D
8321  __init__(BoundedGridRange1D self, IMP::Ints const & counts) -> BoundedGridRange1D
8322  """
8323  _IMP_algebra.BoundedGridRange1D_swiginit(self, _IMP_algebra.new_BoundedGridRange1D(*args))
8324 
8325  def get_number_of_voxels(self, *args):
8326  r"""
8327  get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
8328  get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
8329  """
8330  return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)
8331 
8332  def get_end_index(self):
8333  r"""get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8334  return _IMP_algebra.BoundedGridRange1D_get_end_index(self)
8335 
8336  def show(self, *args):
8337  r"""show(BoundedGridRange1D self, _ostream out=std::cout)"""
8338  return _IMP_algebra.BoundedGridRange1D_show(self, *args)
8339 
8340  def get_all_indexes(self):
8341  r"""get_all_indexes(BoundedGridRange1D self) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8342  return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)
8343 
8344  def get_indexes(self, lb, ub):
8345  r"""get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
8346  return _IMP_algebra.BoundedGridRange1D_get_indexes(self, lb, ub)
8347 
8348  def get_extended_indexes(self, lb, ub):
8349  r"""get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
8350  return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, lb, ub)
8351 
8352  def get_index(self, v):
8353  r"""get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
8354  return _IMP_algebra.BoundedGridRange1D_get_index(self, v)
8355 
8356  def get_has_index(self, v):
8357  r"""get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
8358  return _IMP_algebra.BoundedGridRange1D_get_has_index(self, v)
8359 
8360  def get_minimum_extended_index(self):
8361  r"""get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8362  return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)
8363 
8364  def get_maximum_extended_index(self):
8365  r"""get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
8366  return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)
8367 
8368  def __str__(self):
8369  r"""__str__(BoundedGridRange1D self) -> std::string"""
8370  return _IMP_algebra.BoundedGridRange1D___str__(self)
8371 
8372  def __repr__(self):
8373  r"""__repr__(BoundedGridRange1D self) -> std::string"""
8374  return _IMP_algebra.BoundedGridRange1D___repr__(self)
8375 
8376  def __cmp__(self, arg2):
8377  r"""__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
8378  return _IMP_algebra.BoundedGridRange1D___cmp__(self, arg2)
8379 
8380  def __eq__(self, arg2):
8381  r"""__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
8382  return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)
8383 
8384  def _get_as_binary(self):
8385  r"""_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
8386  return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)
8387 
8388  def _set_from_binary(self, p):
8389  r"""_set_from_binary(BoundedGridRange1D self, PyObject * p)"""
8390  return _IMP_algebra.BoundedGridRange1D__set_from_binary(self, p)
8391 
8392  def __getstate__(self):
8393  p = self._get_as_binary()
8394  if len(self.__dict__) > 1:
8395  d = self.__dict__.copy()
8396  del d['this']
8397  p = (d, p)
8398  return p
8399 
8400  def __setstate__(self, p):
8401  if not hasattr(self, 'this'):
8402  self.__init__()
8403  if isinstance(p, tuple):
8404  d, p = p
8405  self.__dict__.update(d)
8406  return self._set_from_binary(p)
8407 
8408  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
8409 
8410 # Register BoundedGridRange1D in _IMP_algebra:
8411 _IMP_algebra.BoundedGridRange1D_swigregister(BoundedGridRange1D)
8412 class BoundedGridRange2D(object):
8413  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 2 > class."""
8414 
8415  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8416 
8417  @staticmethod
8418  def get_is_bounded():
8419  r"""get_is_bounded() -> bool"""
8420  return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
8421 
8422  def __init__(self, *args):
8423  r"""
8424  __init__(BoundedGridRange2D self) -> BoundedGridRange2D
8425  __init__(BoundedGridRange2D self, IMP::Ints const & counts) -> BoundedGridRange2D
8426  """
8427  _IMP_algebra.BoundedGridRange2D_swiginit(self, _IMP_algebra.new_BoundedGridRange2D(*args))
8428 
8429  def get_number_of_voxels(self, *args):
8430  r"""
8431  get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
8432  get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
8433  """
8434  return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)
8435 
8436  def get_end_index(self):
8437  r"""get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8438  return _IMP_algebra.BoundedGridRange2D_get_end_index(self)
8439 
8440  def show(self, *args):
8441  r"""show(BoundedGridRange2D self, _ostream out=std::cout)"""
8442  return _IMP_algebra.BoundedGridRange2D_show(self, *args)
8443 
8444  def get_all_indexes(self):
8445  r"""get_all_indexes(BoundedGridRange2D self) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8446  return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)
8447 
8448  def get_indexes(self, lb, ub):
8449  r"""get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
8450  return _IMP_algebra.BoundedGridRange2D_get_indexes(self, lb, ub)
8451 
8452  def get_extended_indexes(self, lb, ub):
8453  r"""get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
8454  return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, lb, ub)
8455 
8456  def get_index(self, v):
8457  r"""get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
8458  return _IMP_algebra.BoundedGridRange2D_get_index(self, v)
8459 
8460  def get_has_index(self, v):
8461  r"""get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
8462  return _IMP_algebra.BoundedGridRange2D_get_has_index(self, v)
8463 
8464  def get_minimum_extended_index(self):
8465  r"""get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8466  return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)
8467 
8468  def get_maximum_extended_index(self):
8469  r"""get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
8470  return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)
8471 
8472  def __str__(self):
8473  r"""__str__(BoundedGridRange2D self) -> std::string"""
8474  return _IMP_algebra.BoundedGridRange2D___str__(self)
8475 
8476  def __repr__(self):
8477  r"""__repr__(BoundedGridRange2D self) -> std::string"""
8478  return _IMP_algebra.BoundedGridRange2D___repr__(self)
8479 
8480  def __cmp__(self, arg2):
8481  r"""__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
8482  return _IMP_algebra.BoundedGridRange2D___cmp__(self, arg2)
8483 
8484  def __eq__(self, arg2):
8485  r"""__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
8486  return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)
8487 
8488  def _get_as_binary(self):
8489  r"""_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
8490  return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)
8491 
8492  def _set_from_binary(self, p):
8493  r"""_set_from_binary(BoundedGridRange2D self, PyObject * p)"""
8494  return _IMP_algebra.BoundedGridRange2D__set_from_binary(self, p)
8495 
8496  def __getstate__(self):
8497  p = self._get_as_binary()
8498  if len(self.__dict__) > 1:
8499  d = self.__dict__.copy()
8500  del d['this']
8501  p = (d, p)
8502  return p
8503 
8504  def __setstate__(self, p):
8505  if not hasattr(self, 'this'):
8506  self.__init__()
8507  if isinstance(p, tuple):
8508  d, p = p
8509  self.__dict__.update(d)
8510  return self._set_from_binary(p)
8511 
8512  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
8513 
8514 # Register BoundedGridRange2D in _IMP_algebra:
8515 _IMP_algebra.BoundedGridRange2D_swigregister(BoundedGridRange2D)
8516 class BoundedGridRange3D(object):
8517  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 3 > class."""
8518 
8519  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8520 
8521  @staticmethod
8522  def get_is_bounded():
8523  r"""get_is_bounded() -> bool"""
8524  return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
8525 
8526  def __init__(self, *args):
8527  r"""
8528  __init__(BoundedGridRange3D self) -> BoundedGridRange3D
8529  __init__(BoundedGridRange3D self, IMP::Ints const & counts) -> BoundedGridRange3D
8530  """
8531  _IMP_algebra.BoundedGridRange3D_swiginit(self, _IMP_algebra.new_BoundedGridRange3D(*args))
8532 
8533  def get_number_of_voxels(self, *args):
8534  r"""
8535  get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
8536  get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
8537  """
8538  return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)
8539 
8540  def get_end_index(self):
8541  r"""get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8542  return _IMP_algebra.BoundedGridRange3D_get_end_index(self)
8543 
8544  def show(self, *args):
8545  r"""show(BoundedGridRange3D self, _ostream out=std::cout)"""
8546  return _IMP_algebra.BoundedGridRange3D_show(self, *args)
8547 
8548  def get_all_indexes(self):
8549  r"""get_all_indexes(BoundedGridRange3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8550  return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)
8551 
8552  def get_indexes(self, lb, ub):
8553  r"""get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
8554  return _IMP_algebra.BoundedGridRange3D_get_indexes(self, lb, ub)
8555 
8556  def get_extended_indexes(self, lb, ub):
8557  r"""get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
8558  return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, lb, ub)
8559 
8560  def get_index(self, v):
8561  r"""get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
8562  return _IMP_algebra.BoundedGridRange3D_get_index(self, v)
8563 
8564  def get_has_index(self, v):
8565  r"""get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
8566  return _IMP_algebra.BoundedGridRange3D_get_has_index(self, v)
8567 
8568  def get_minimum_extended_index(self):
8569  r"""get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8570  return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)
8571 
8572  def get_maximum_extended_index(self):
8573  r"""get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
8574  return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)
8575 
8576  def __str__(self):
8577  r"""__str__(BoundedGridRange3D self) -> std::string"""
8578  return _IMP_algebra.BoundedGridRange3D___str__(self)
8579 
8580  def __repr__(self):
8581  r"""__repr__(BoundedGridRange3D self) -> std::string"""
8582  return _IMP_algebra.BoundedGridRange3D___repr__(self)
8583 
8584  def __cmp__(self, arg2):
8585  r"""__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
8586  return _IMP_algebra.BoundedGridRange3D___cmp__(self, arg2)
8587 
8588  def __eq__(self, arg2):
8589  r"""__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
8590  return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)
8591 
8592  def _get_as_binary(self):
8593  r"""_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
8594  return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)
8595 
8596  def _set_from_binary(self, p):
8597  r"""_set_from_binary(BoundedGridRange3D self, PyObject * p)"""
8598  return _IMP_algebra.BoundedGridRange3D__set_from_binary(self, p)
8599 
8600  def __getstate__(self):
8601  p = self._get_as_binary()
8602  if len(self.__dict__) > 1:
8603  d = self.__dict__.copy()
8604  del d['this']
8605  p = (d, p)
8606  return p
8607 
8608  def __setstate__(self, p):
8609  if not hasattr(self, 'this'):
8610  self.__init__()
8611  if isinstance(p, tuple):
8612  d, p = p
8613  self.__dict__.update(d)
8614  return self._set_from_binary(p)
8615 
8616  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
8617 
8618 # Register BoundedGridRange3D in _IMP_algebra:
8619 _IMP_algebra.BoundedGridRange3D_swigregister(BoundedGridRange3D)
8620 class BoundedGridRange4D(object):
8621  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 4 > class."""
8622 
8623  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8624 
8625  @staticmethod
8626  def get_is_bounded():
8627  r"""get_is_bounded() -> bool"""
8628  return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
8629 
8630  def __init__(self, *args):
8631  r"""
8632  __init__(BoundedGridRange4D self) -> BoundedGridRange4D
8633  __init__(BoundedGridRange4D self, IMP::Ints const & counts) -> BoundedGridRange4D
8634  """
8635  _IMP_algebra.BoundedGridRange4D_swiginit(self, _IMP_algebra.new_BoundedGridRange4D(*args))
8636 
8637  def get_number_of_voxels(self, *args):
8638  r"""
8639  get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
8640  get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
8641  """
8642  return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)
8643 
8644  def get_end_index(self):
8645  r"""get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8646  return _IMP_algebra.BoundedGridRange4D_get_end_index(self)
8647 
8648  def show(self, *args):
8649  r"""show(BoundedGridRange4D self, _ostream out=std::cout)"""
8650  return _IMP_algebra.BoundedGridRange4D_show(self, *args)
8651 
8652  def get_all_indexes(self):
8653  r"""get_all_indexes(BoundedGridRange4D self) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8654  return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)
8655 
8656  def get_indexes(self, lb, ub):
8657  r"""get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
8658  return _IMP_algebra.BoundedGridRange4D_get_indexes(self, lb, ub)
8659 
8660  def get_extended_indexes(self, lb, ub):
8661  r"""get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
8662  return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, lb, ub)
8663 
8664  def get_index(self, v):
8665  r"""get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
8666  return _IMP_algebra.BoundedGridRange4D_get_index(self, v)
8667 
8668  def get_has_index(self, v):
8669  r"""get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
8670  return _IMP_algebra.BoundedGridRange4D_get_has_index(self, v)
8671 
8672  def get_minimum_extended_index(self):
8673  r"""get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8674  return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)
8675 
8676  def get_maximum_extended_index(self):
8677  r"""get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
8678  return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)
8679 
8680  def __str__(self):
8681  r"""__str__(BoundedGridRange4D self) -> std::string"""
8682  return _IMP_algebra.BoundedGridRange4D___str__(self)
8683 
8684  def __repr__(self):
8685  r"""__repr__(BoundedGridRange4D self) -> std::string"""
8686  return _IMP_algebra.BoundedGridRange4D___repr__(self)
8687 
8688  def __cmp__(self, arg2):
8689  r"""__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
8690  return _IMP_algebra.BoundedGridRange4D___cmp__(self, arg2)
8691 
8692  def __eq__(self, arg2):
8693  r"""__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
8694  return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)
8695 
8696  def _get_as_binary(self):
8697  r"""_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
8698  return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)
8699 
8700  def _set_from_binary(self, p):
8701  r"""_set_from_binary(BoundedGridRange4D self, PyObject * p)"""
8702  return _IMP_algebra.BoundedGridRange4D__set_from_binary(self, p)
8703 
8704  def __getstate__(self):
8705  p = self._get_as_binary()
8706  if len(self.__dict__) > 1:
8707  d = self.__dict__.copy()
8708  del d['this']
8709  p = (d, p)
8710  return p
8711 
8712  def __setstate__(self, p):
8713  if not hasattr(self, 'this'):
8714  self.__init__()
8715  if isinstance(p, tuple):
8716  d, p = p
8717  self.__dict__.update(d)
8718  return self._set_from_binary(p)
8719 
8720  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
8721 
8722 # Register BoundedGridRange4D in _IMP_algebra:
8723 _IMP_algebra.BoundedGridRange4D_swigregister(BoundedGridRange4D)
8724 class BoundedGridRange5D(object):
8725  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 5 > class."""
8726 
8727  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8728 
8729  @staticmethod
8730  def get_is_bounded():
8731  r"""get_is_bounded() -> bool"""
8732  return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
8733 
8734  def __init__(self, *args):
8735  r"""
8736  __init__(BoundedGridRange5D self) -> BoundedGridRange5D
8737  __init__(BoundedGridRange5D self, IMP::Ints const & counts) -> BoundedGridRange5D
8738  """
8739  _IMP_algebra.BoundedGridRange5D_swiginit(self, _IMP_algebra.new_BoundedGridRange5D(*args))
8740 
8741  def get_number_of_voxels(self, *args):
8742  r"""
8743  get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
8744  get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
8745  """
8746  return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)
8747 
8748  def get_end_index(self):
8749  r"""get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8750  return _IMP_algebra.BoundedGridRange5D_get_end_index(self)
8751 
8752  def show(self, *args):
8753  r"""show(BoundedGridRange5D self, _ostream out=std::cout)"""
8754  return _IMP_algebra.BoundedGridRange5D_show(self, *args)
8755 
8756  def get_all_indexes(self):
8757  r"""get_all_indexes(BoundedGridRange5D self) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8758  return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)
8759 
8760  def get_indexes(self, lb, ub):
8761  r"""get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
8762  return _IMP_algebra.BoundedGridRange5D_get_indexes(self, lb, ub)
8763 
8764  def get_extended_indexes(self, lb, ub):
8765  r"""get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
8766  return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, lb, ub)
8767 
8768  def get_index(self, v):
8769  r"""get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
8770  return _IMP_algebra.BoundedGridRange5D_get_index(self, v)
8771 
8772  def get_has_index(self, v):
8773  r"""get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
8774  return _IMP_algebra.BoundedGridRange5D_get_has_index(self, v)
8775 
8776  def get_minimum_extended_index(self):
8777  r"""get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8778  return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)
8779 
8780  def get_maximum_extended_index(self):
8781  r"""get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
8782  return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)
8783 
8784  def __str__(self):
8785  r"""__str__(BoundedGridRange5D self) -> std::string"""
8786  return _IMP_algebra.BoundedGridRange5D___str__(self)
8787 
8788  def __repr__(self):
8789  r"""__repr__(BoundedGridRange5D self) -> std::string"""
8790  return _IMP_algebra.BoundedGridRange5D___repr__(self)
8791 
8792  def __cmp__(self, arg2):
8793  r"""__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
8794  return _IMP_algebra.BoundedGridRange5D___cmp__(self, arg2)
8795 
8796  def __eq__(self, arg2):
8797  r"""__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
8798  return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)
8799 
8800  def _get_as_binary(self):
8801  r"""_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
8802  return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)
8803 
8804  def _set_from_binary(self, p):
8805  r"""_set_from_binary(BoundedGridRange5D self, PyObject * p)"""
8806  return _IMP_algebra.BoundedGridRange5D__set_from_binary(self, p)
8807 
8808  def __getstate__(self):
8809  p = self._get_as_binary()
8810  if len(self.__dict__) > 1:
8811  d = self.__dict__.copy()
8812  del d['this']
8813  p = (d, p)
8814  return p
8815 
8816  def __setstate__(self, p):
8817  if not hasattr(self, 'this'):
8818  self.__init__()
8819  if isinstance(p, tuple):
8820  d, p = p
8821  self.__dict__.update(d)
8822  return self._set_from_binary(p)
8823 
8824  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
8825 
8826 # Register BoundedGridRange5D in _IMP_algebra:
8827 _IMP_algebra.BoundedGridRange5D_swigregister(BoundedGridRange5D)
8828 class BoundedGridRange6D(object):
8829  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< 6 > class."""
8830 
8831  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8832 
8833  @staticmethod
8834  def get_is_bounded():
8835  r"""get_is_bounded() -> bool"""
8836  return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
8837 
8838  def __init__(self, *args):
8839  r"""
8840  __init__(BoundedGridRange6D self) -> BoundedGridRange6D
8841  __init__(BoundedGridRange6D self, IMP::Ints const & counts) -> BoundedGridRange6D
8842  """
8843  _IMP_algebra.BoundedGridRange6D_swiginit(self, _IMP_algebra.new_BoundedGridRange6D(*args))
8844 
8845  def get_number_of_voxels(self, *args):
8846  r"""
8847  get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
8848  get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
8849  """
8850  return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)
8851 
8852  def get_end_index(self):
8853  r"""get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8854  return _IMP_algebra.BoundedGridRange6D_get_end_index(self)
8855 
8856  def show(self, *args):
8857  r"""show(BoundedGridRange6D self, _ostream out=std::cout)"""
8858  return _IMP_algebra.BoundedGridRange6D_show(self, *args)
8859 
8860  def get_all_indexes(self):
8861  r"""get_all_indexes(BoundedGridRange6D self) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8862  return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)
8863 
8864  def get_indexes(self, lb, ub):
8865  r"""get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
8866  return _IMP_algebra.BoundedGridRange6D_get_indexes(self, lb, ub)
8867 
8868  def get_extended_indexes(self, lb, ub):
8869  r"""get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
8870  return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, lb, ub)
8871 
8872  def get_index(self, v):
8873  r"""get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
8874  return _IMP_algebra.BoundedGridRange6D_get_index(self, v)
8875 
8876  def get_has_index(self, v):
8877  r"""get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
8878  return _IMP_algebra.BoundedGridRange6D_get_has_index(self, v)
8879 
8880  def get_minimum_extended_index(self):
8881  r"""get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8882  return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)
8883 
8884  def get_maximum_extended_index(self):
8885  r"""get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
8886  return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)
8887 
8888  def __str__(self):
8889  r"""__str__(BoundedGridRange6D self) -> std::string"""
8890  return _IMP_algebra.BoundedGridRange6D___str__(self)
8891 
8892  def __repr__(self):
8893  r"""__repr__(BoundedGridRange6D self) -> std::string"""
8894  return _IMP_algebra.BoundedGridRange6D___repr__(self)
8895 
8896  def __cmp__(self, arg2):
8897  r"""__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
8898  return _IMP_algebra.BoundedGridRange6D___cmp__(self, arg2)
8899 
8900  def __eq__(self, arg2):
8901  r"""__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
8902  return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)
8903 
8904  def _get_as_binary(self):
8905  r"""_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
8906  return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)
8907 
8908  def _set_from_binary(self, p):
8909  r"""_set_from_binary(BoundedGridRange6D self, PyObject * p)"""
8910  return _IMP_algebra.BoundedGridRange6D__set_from_binary(self, p)
8911 
8912  def __getstate__(self):
8913  p = self._get_as_binary()
8914  if len(self.__dict__) > 1:
8915  d = self.__dict__.copy()
8916  del d['this']
8917  p = (d, p)
8918  return p
8919 
8920  def __setstate__(self, p):
8921  if not hasattr(self, 'this'):
8922  self.__init__()
8923  if isinstance(p, tuple):
8924  d, p = p
8925  self.__dict__.update(d)
8926  return self._set_from_binary(p)
8927 
8928  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
8929 
8930 # Register BoundedGridRange6D in _IMP_algebra:
8931 _IMP_algebra.BoundedGridRange6D_swigregister(BoundedGridRange6D)
8932 class BoundedGridRangeKD(object):
8933  r"""Proxy of C++ IMP::algebra::BoundedGridRangeD< -1 > class."""
8934 
8935  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
8936 
8937  @staticmethod
8938  def get_is_bounded():
8939  r"""get_is_bounded() -> bool"""
8940  return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
8941 
8942  def __init__(self, *args):
8943  r"""
8944  __init__(BoundedGridRangeKD self) -> BoundedGridRangeKD
8945  __init__(BoundedGridRangeKD self, IMP::Ints const & counts) -> BoundedGridRangeKD
8946  """
8947  _IMP_algebra.BoundedGridRangeKD_swiginit(self, _IMP_algebra.new_BoundedGridRangeKD(*args))
8948 
8949  def get_number_of_voxels(self, *args):
8950  r"""
8951  get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
8952  get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
8953  """
8954  return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)
8955 
8956  def get_end_index(self):
8957  r"""get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8958  return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)
8959 
8960  def show(self, *args):
8961  r"""show(BoundedGridRangeKD self, _ostream out=std::cout)"""
8962  return _IMP_algebra.BoundedGridRangeKD_show(self, *args)
8963 
8964  def get_all_indexes(self):
8965  r"""get_all_indexes(BoundedGridRangeKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8966  return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)
8967 
8968  def get_indexes(self, lb, ub):
8969  r"""get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
8970  return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, lb, ub)
8971 
8972  def get_extended_indexes(self, lb, ub):
8973  r"""get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
8974  return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, lb, ub)
8975 
8976  def get_index(self, v):
8977  r"""get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
8978  return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)
8979 
8980  def get_has_index(self, v):
8981  r"""get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
8982  return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, v)
8983 
8984  def get_minimum_extended_index(self):
8985  r"""get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8986  return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)
8987 
8988  def get_maximum_extended_index(self):
8989  r"""get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
8990  return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)
8991 
8992  def __str__(self):
8993  r"""__str__(BoundedGridRangeKD self) -> std::string"""
8994  return _IMP_algebra.BoundedGridRangeKD___str__(self)
8995 
8996  def __repr__(self):
8997  r"""__repr__(BoundedGridRangeKD self) -> std::string"""
8998  return _IMP_algebra.BoundedGridRangeKD___repr__(self)
8999 
9000  def __cmp__(self, arg2):
9001  r"""__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
9002  return _IMP_algebra.BoundedGridRangeKD___cmp__(self, arg2)
9003 
9004  def __eq__(self, arg2):
9005  r"""__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
9006  return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)
9007 
9008  def _get_as_binary(self):
9009  r"""_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
9010  return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)
9011 
9012  def _set_from_binary(self, p):
9013  r"""_set_from_binary(BoundedGridRangeKD self, PyObject * p)"""
9014  return _IMP_algebra.BoundedGridRangeKD__set_from_binary(self, p)
9015 
9016  def __getstate__(self):
9017  p = self._get_as_binary()
9018  if len(self.__dict__) > 1:
9019  d = self.__dict__.copy()
9020  del d['this']
9021  p = (d, p)
9022  return p
9023 
9024  def __setstate__(self, p):
9025  if not hasattr(self, 'this'):
9026  self.__init__()
9027  if isinstance(p, tuple):
9028  d, p = p
9029  self.__dict__.update(d)
9030  return self._set_from_binary(p)
9031 
9032  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
9033 
9034 # Register BoundedGridRangeKD in _IMP_algebra:
9035 _IMP_algebra.BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
9036 class UnboundedGridRange1D(object):
9037  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 1 > class."""
9038 
9039  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9040 
9041  def __init__(self, *args):
9042  r"""
9043  __init__(UnboundedGridRange1D self) -> UnboundedGridRange1D
9044  __init__(UnboundedGridRange1D self, IMP::Ints const & arg2) -> UnboundedGridRange1D
9045  """
9046  _IMP_algebra.UnboundedGridRange1D_swiginit(self, _IMP_algebra.new_UnboundedGridRange1D(*args))
9047 
9048  def set_number_of_voxels(self, arg2):
9049  r"""set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
9050  return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, arg2)
9051 
9052  def get_number_of_voxels(self, arg2):
9053  r"""get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
9054  return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, arg2)
9055 
9056  @staticmethod
9057  def get_is_bounded():
9058  r"""get_is_bounded() -> bool"""
9059  return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
9060 
9061  def get_has_index(self, arg2):
9062  r"""get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
9063  return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, arg2)
9064 
9065  def show(self, *args):
9066  r"""show(UnboundedGridRange1D self, _ostream out=std::cout)"""
9067  return _IMP_algebra.UnboundedGridRange1D_show(self, *args)
9068 
9069  def get_extended_indexes(self, lb, ub):
9070  r"""get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
9071  return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, lb, ub)
9072 
9073  def __str__(self):
9074  r"""__str__(UnboundedGridRange1D self) -> std::string"""
9075  return _IMP_algebra.UnboundedGridRange1D___str__(self)
9076 
9077  def __repr__(self):
9078  r"""__repr__(UnboundedGridRange1D self) -> std::string"""
9079  return _IMP_algebra.UnboundedGridRange1D___repr__(self)
9080 
9081  def __cmp__(self, arg2):
9082  r"""__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
9083  return _IMP_algebra.UnboundedGridRange1D___cmp__(self, arg2)
9084 
9085  def __eq__(self, arg2):
9086  r"""__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
9087  return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)
9088 
9089  def _get_as_binary(self):
9090  r"""_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
9091  return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)
9092 
9093  def _set_from_binary(self, p):
9094  r"""_set_from_binary(UnboundedGridRange1D self, PyObject * p)"""
9095  return _IMP_algebra.UnboundedGridRange1D__set_from_binary(self, p)
9096 
9097  def __getstate__(self):
9098  p = self._get_as_binary()
9099  if len(self.__dict__) > 1:
9100  d = self.__dict__.copy()
9101  del d['this']
9102  p = (d, p)
9103  return p
9104 
9105  def __setstate__(self, p):
9106  if not hasattr(self, 'this'):
9107  self.__init__()
9108  if isinstance(p, tuple):
9109  d, p = p
9110  self.__dict__.update(d)
9111  return self._set_from_binary(p)
9112 
9113  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
9114 
9115 # Register UnboundedGridRange1D in _IMP_algebra:
9116 _IMP_algebra.UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
9117 class UnboundedGridRange2D(object):
9118  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 2 > class."""
9119 
9120  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9121 
9122  def __init__(self, *args):
9123  r"""
9124  __init__(UnboundedGridRange2D self) -> UnboundedGridRange2D
9125  __init__(UnboundedGridRange2D self, IMP::Ints const & arg2) -> UnboundedGridRange2D
9126  """
9127  _IMP_algebra.UnboundedGridRange2D_swiginit(self, _IMP_algebra.new_UnboundedGridRange2D(*args))
9128 
9129  def set_number_of_voxels(self, arg2):
9130  r"""set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
9131  return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, arg2)
9132 
9133  def get_number_of_voxels(self, arg2):
9134  r"""get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
9135  return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, arg2)
9136 
9137  @staticmethod
9138  def get_is_bounded():
9139  r"""get_is_bounded() -> bool"""
9140  return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
9141 
9142  def get_has_index(self, arg2):
9143  r"""get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
9144  return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, arg2)
9145 
9146  def show(self, *args):
9147  r"""show(UnboundedGridRange2D self, _ostream out=std::cout)"""
9148  return _IMP_algebra.UnboundedGridRange2D_show(self, *args)
9149 
9150  def get_extended_indexes(self, lb, ub):
9151  r"""get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
9152  return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, lb, ub)
9153 
9154  def __str__(self):
9155  r"""__str__(UnboundedGridRange2D self) -> std::string"""
9156  return _IMP_algebra.UnboundedGridRange2D___str__(self)
9157 
9158  def __repr__(self):
9159  r"""__repr__(UnboundedGridRange2D self) -> std::string"""
9160  return _IMP_algebra.UnboundedGridRange2D___repr__(self)
9161 
9162  def __cmp__(self, arg2):
9163  r"""__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
9164  return _IMP_algebra.UnboundedGridRange2D___cmp__(self, arg2)
9165 
9166  def __eq__(self, arg2):
9167  r"""__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
9168  return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)
9169 
9170  def _get_as_binary(self):
9171  r"""_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
9172  return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)
9173 
9174  def _set_from_binary(self, p):
9175  r"""_set_from_binary(UnboundedGridRange2D self, PyObject * p)"""
9176  return _IMP_algebra.UnboundedGridRange2D__set_from_binary(self, p)
9177 
9178  def __getstate__(self):
9179  p = self._get_as_binary()
9180  if len(self.__dict__) > 1:
9181  d = self.__dict__.copy()
9182  del d['this']
9183  p = (d, p)
9184  return p
9185 
9186  def __setstate__(self, p):
9187  if not hasattr(self, 'this'):
9188  self.__init__()
9189  if isinstance(p, tuple):
9190  d, p = p
9191  self.__dict__.update(d)
9192  return self._set_from_binary(p)
9193 
9194  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
9195 
9196 # Register UnboundedGridRange2D in _IMP_algebra:
9197 _IMP_algebra.UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
9198 class UnboundedGridRange3D(object):
9199  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 3 > class."""
9200 
9201  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9202 
9203  def __init__(self, *args):
9204  r"""
9205  __init__(UnboundedGridRange3D self) -> UnboundedGridRange3D
9206  __init__(UnboundedGridRange3D self, IMP::Ints const & arg2) -> UnboundedGridRange3D
9207  """
9208  _IMP_algebra.UnboundedGridRange3D_swiginit(self, _IMP_algebra.new_UnboundedGridRange3D(*args))
9209 
9210  def set_number_of_voxels(self, arg2):
9211  r"""set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
9212  return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, arg2)
9213 
9214  def get_number_of_voxels(self, arg2):
9215  r"""get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
9216  return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, arg2)
9217 
9218  @staticmethod
9219  def get_is_bounded():
9220  r"""get_is_bounded() -> bool"""
9221  return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
9222 
9223  def get_has_index(self, arg2):
9224  r"""get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
9225  return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, arg2)
9226 
9227  def show(self, *args):
9228  r"""show(UnboundedGridRange3D self, _ostream out=std::cout)"""
9229  return _IMP_algebra.UnboundedGridRange3D_show(self, *args)
9230 
9231  def get_extended_indexes(self, lb, ub):
9232  r"""get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
9233  return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, lb, ub)
9234 
9235  def __str__(self):
9236  r"""__str__(UnboundedGridRange3D self) -> std::string"""
9237  return _IMP_algebra.UnboundedGridRange3D___str__(self)
9238 
9239  def __repr__(self):
9240  r"""__repr__(UnboundedGridRange3D self) -> std::string"""
9241  return _IMP_algebra.UnboundedGridRange3D___repr__(self)
9242 
9243  def __cmp__(self, arg2):
9244  r"""__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
9245  return _IMP_algebra.UnboundedGridRange3D___cmp__(self, arg2)
9246 
9247  def __eq__(self, arg2):
9248  r"""__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
9249  return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)
9250 
9251  def _get_as_binary(self):
9252  r"""_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
9253  return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)
9254 
9255  def _set_from_binary(self, p):
9256  r"""_set_from_binary(UnboundedGridRange3D self, PyObject * p)"""
9257  return _IMP_algebra.UnboundedGridRange3D__set_from_binary(self, p)
9258 
9259  def __getstate__(self):
9260  p = self._get_as_binary()
9261  if len(self.__dict__) > 1:
9262  d = self.__dict__.copy()
9263  del d['this']
9264  p = (d, p)
9265  return p
9266 
9267  def __setstate__(self, p):
9268  if not hasattr(self, 'this'):
9269  self.__init__()
9270  if isinstance(p, tuple):
9271  d, p = p
9272  self.__dict__.update(d)
9273  return self._set_from_binary(p)
9274 
9275  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
9276 
9277 # Register UnboundedGridRange3D in _IMP_algebra:
9278 _IMP_algebra.UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
9279 class UnboundedGridRange4D(object):
9280  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 4 > class."""
9281 
9282  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9283 
9284  def __init__(self, *args):
9285  r"""
9286  __init__(UnboundedGridRange4D self) -> UnboundedGridRange4D
9287  __init__(UnboundedGridRange4D self, IMP::Ints const & arg2) -> UnboundedGridRange4D
9288  """
9289  _IMP_algebra.UnboundedGridRange4D_swiginit(self, _IMP_algebra.new_UnboundedGridRange4D(*args))
9290 
9291  def set_number_of_voxels(self, arg2):
9292  r"""set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
9293  return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, arg2)
9294 
9295  def get_number_of_voxels(self, arg2):
9296  r"""get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
9297  return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, arg2)
9298 
9299  @staticmethod
9300  def get_is_bounded():
9301  r"""get_is_bounded() -> bool"""
9302  return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
9303 
9304  def get_has_index(self, arg2):
9305  r"""get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
9306  return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, arg2)
9307 
9308  def show(self, *args):
9309  r"""show(UnboundedGridRange4D self, _ostream out=std::cout)"""
9310  return _IMP_algebra.UnboundedGridRange4D_show(self, *args)
9311 
9312  def get_extended_indexes(self, lb, ub):
9313  r"""get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
9314  return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, lb, ub)
9315 
9316  def __str__(self):
9317  r"""__str__(UnboundedGridRange4D self) -> std::string"""
9318  return _IMP_algebra.UnboundedGridRange4D___str__(self)
9319 
9320  def __repr__(self):
9321  r"""__repr__(UnboundedGridRange4D self) -> std::string"""
9322  return _IMP_algebra.UnboundedGridRange4D___repr__(self)
9323 
9324  def __cmp__(self, arg2):
9325  r"""__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
9326  return _IMP_algebra.UnboundedGridRange4D___cmp__(self, arg2)
9327 
9328  def __eq__(self, arg2):
9329  r"""__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
9330  return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)
9331 
9332  def _get_as_binary(self):
9333  r"""_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
9334  return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)
9335 
9336  def _set_from_binary(self, p):
9337  r"""_set_from_binary(UnboundedGridRange4D self, PyObject * p)"""
9338  return _IMP_algebra.UnboundedGridRange4D__set_from_binary(self, p)
9339 
9340  def __getstate__(self):
9341  p = self._get_as_binary()
9342  if len(self.__dict__) > 1:
9343  d = self.__dict__.copy()
9344  del d['this']
9345  p = (d, p)
9346  return p
9347 
9348  def __setstate__(self, p):
9349  if not hasattr(self, 'this'):
9350  self.__init__()
9351  if isinstance(p, tuple):
9352  d, p = p
9353  self.__dict__.update(d)
9354  return self._set_from_binary(p)
9355 
9356  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
9357 
9358 # Register UnboundedGridRange4D in _IMP_algebra:
9359 _IMP_algebra.UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
9360 class UnboundedGridRange5D(object):
9361  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 5 > class."""
9362 
9363  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9364 
9365  def __init__(self, *args):
9366  r"""
9367  __init__(UnboundedGridRange5D self) -> UnboundedGridRange5D
9368  __init__(UnboundedGridRange5D self, IMP::Ints const & arg2) -> UnboundedGridRange5D
9369  """
9370  _IMP_algebra.UnboundedGridRange5D_swiginit(self, _IMP_algebra.new_UnboundedGridRange5D(*args))
9371 
9372  def set_number_of_voxels(self, arg2):
9373  r"""set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
9374  return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, arg2)
9375 
9376  def get_number_of_voxels(self, arg2):
9377  r"""get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
9378  return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, arg2)
9379 
9380  @staticmethod
9381  def get_is_bounded():
9382  r"""get_is_bounded() -> bool"""
9383  return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
9384 
9385  def get_has_index(self, arg2):
9386  r"""get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
9387  return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, arg2)
9388 
9389  def show(self, *args):
9390  r"""show(UnboundedGridRange5D self, _ostream out=std::cout)"""
9391  return _IMP_algebra.UnboundedGridRange5D_show(self, *args)
9392 
9393  def get_extended_indexes(self, lb, ub):
9394  r"""get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
9395  return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, lb, ub)
9396 
9397  def __str__(self):
9398  r"""__str__(UnboundedGridRange5D self) -> std::string"""
9399  return _IMP_algebra.UnboundedGridRange5D___str__(self)
9400 
9401  def __repr__(self):
9402  r"""__repr__(UnboundedGridRange5D self) -> std::string"""
9403  return _IMP_algebra.UnboundedGridRange5D___repr__(self)
9404 
9405  def __cmp__(self, arg2):
9406  r"""__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
9407  return _IMP_algebra.UnboundedGridRange5D___cmp__(self, arg2)
9408 
9409  def __eq__(self, arg2):
9410  r"""__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
9411  return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)
9412 
9413  def _get_as_binary(self):
9414  r"""_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
9415  return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)
9416 
9417  def _set_from_binary(self, p):
9418  r"""_set_from_binary(UnboundedGridRange5D self, PyObject * p)"""
9419  return _IMP_algebra.UnboundedGridRange5D__set_from_binary(self, p)
9420 
9421  def __getstate__(self):
9422  p = self._get_as_binary()
9423  if len(self.__dict__) > 1:
9424  d = self.__dict__.copy()
9425  del d['this']
9426  p = (d, p)
9427  return p
9428 
9429  def __setstate__(self, p):
9430  if not hasattr(self, 'this'):
9431  self.__init__()
9432  if isinstance(p, tuple):
9433  d, p = p
9434  self.__dict__.update(d)
9435  return self._set_from_binary(p)
9436 
9437  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
9438 
9439 # Register UnboundedGridRange5D in _IMP_algebra:
9440 _IMP_algebra.UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
9441 class UnboundedGridRange6D(object):
9442  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< 6 > class."""
9443 
9444  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9445 
9446  def __init__(self, *args):
9447  r"""
9448  __init__(UnboundedGridRange6D self) -> UnboundedGridRange6D
9449  __init__(UnboundedGridRange6D self, IMP::Ints const & arg2) -> UnboundedGridRange6D
9450  """
9451  _IMP_algebra.UnboundedGridRange6D_swiginit(self, _IMP_algebra.new_UnboundedGridRange6D(*args))
9452 
9453  def set_number_of_voxels(self, arg2):
9454  r"""set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
9455  return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, arg2)
9456 
9457  def get_number_of_voxels(self, arg2):
9458  r"""get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
9459  return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, arg2)
9460 
9461  @staticmethod
9462  def get_is_bounded():
9463  r"""get_is_bounded() -> bool"""
9464  return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
9465 
9466  def get_has_index(self, arg2):
9467  r"""get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
9468  return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, arg2)
9469 
9470  def show(self, *args):
9471  r"""show(UnboundedGridRange6D self, _ostream out=std::cout)"""
9472  return _IMP_algebra.UnboundedGridRange6D_show(self, *args)
9473 
9474  def get_extended_indexes(self, lb, ub):
9475  r"""get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
9476  return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, lb, ub)
9477 
9478  def __str__(self):
9479  r"""__str__(UnboundedGridRange6D self) -> std::string"""
9480  return _IMP_algebra.UnboundedGridRange6D___str__(self)
9481 
9482  def __repr__(self):
9483  r"""__repr__(UnboundedGridRange6D self) -> std::string"""
9484  return _IMP_algebra.UnboundedGridRange6D___repr__(self)
9485 
9486  def __cmp__(self, arg2):
9487  r"""__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
9488  return _IMP_algebra.UnboundedGridRange6D___cmp__(self, arg2)
9489 
9490  def __eq__(self, arg2):
9491  r"""__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
9492  return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)
9493 
9494  def _get_as_binary(self):
9495  r"""_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
9496  return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)
9497 
9498  def _set_from_binary(self, p):
9499  r"""_set_from_binary(UnboundedGridRange6D self, PyObject * p)"""
9500  return _IMP_algebra.UnboundedGridRange6D__set_from_binary(self, p)
9501 
9502  def __getstate__(self):
9503  p = self._get_as_binary()
9504  if len(self.__dict__) > 1:
9505  d = self.__dict__.copy()
9506  del d['this']
9507  p = (d, p)
9508  return p
9509 
9510  def __setstate__(self, p):
9511  if not hasattr(self, 'this'):
9512  self.__init__()
9513  if isinstance(p, tuple):
9514  d, p = p
9515  self.__dict__.update(d)
9516  return self._set_from_binary(p)
9517 
9518  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
9519 
9520 # Register UnboundedGridRange6D in _IMP_algebra:
9521 _IMP_algebra.UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
9522 class UnboundedGridRangeKD(object):
9523  r"""Proxy of C++ IMP::algebra::UnboundedGridRangeD< -1 > class."""
9524 
9525  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9526 
9527  def __init__(self, *args):
9528  r"""
9529  __init__(UnboundedGridRangeKD self) -> UnboundedGridRangeKD
9530  __init__(UnboundedGridRangeKD self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
9531  """
9532  _IMP_algebra.UnboundedGridRangeKD_swiginit(self, _IMP_algebra.new_UnboundedGridRangeKD(*args))
9533 
9534  def set_number_of_voxels(self, arg2):
9535  r"""set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
9536  return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, arg2)
9537 
9538  def get_number_of_voxels(self, arg2):
9539  r"""get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
9540  return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, arg2)
9541 
9542  @staticmethod
9543  def get_is_bounded():
9544  r"""get_is_bounded() -> bool"""
9545  return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
9546 
9547  def get_has_index(self, arg2):
9548  r"""get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
9549  return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, arg2)
9550 
9551  def show(self, *args):
9552  r"""show(UnboundedGridRangeKD self, _ostream out=std::cout)"""
9553  return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)
9554 
9555  def get_extended_indexes(self, lb, ub):
9556  r"""get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
9557  return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, lb, ub)
9558 
9559  def __str__(self):
9560  r"""__str__(UnboundedGridRangeKD self) -> std::string"""
9561  return _IMP_algebra.UnboundedGridRangeKD___str__(self)
9562 
9563  def __repr__(self):
9564  r"""__repr__(UnboundedGridRangeKD self) -> std::string"""
9565  return _IMP_algebra.UnboundedGridRangeKD___repr__(self)
9566 
9567  def __cmp__(self, arg2):
9568  r"""__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
9569  return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, arg2)
9570 
9571  def __eq__(self, arg2):
9572  r"""__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
9573  return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)
9574 
9575  def _get_as_binary(self):
9576  r"""_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
9577  return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)
9578 
9579  def _set_from_binary(self, p):
9580  r"""_set_from_binary(UnboundedGridRangeKD self, PyObject * p)"""
9581  return _IMP_algebra.UnboundedGridRangeKD__set_from_binary(self, p)
9582 
9583  def __getstate__(self):
9584  p = self._get_as_binary()
9585  if len(self.__dict__) > 1:
9586  d = self.__dict__.copy()
9587  del d['this']
9588  p = (d, p)
9589  return p
9590 
9591  def __setstate__(self, p):
9592  if not hasattr(self, 'this'):
9593  self.__init__()
9594  if isinstance(p, tuple):
9595  d, p = p
9596  self.__dict__.update(d)
9597  return self._set_from_binary(p)
9598 
9599  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
9600 
9601 # Register UnboundedGridRangeKD in _IMP_algebra:
9602 _IMP_algebra.UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
9603 class DefaultEmbedding1D(object):
9604  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 1 > class."""
9605 
9606  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9607 
9608  def __init__(self, *args):
9609  r"""
9610  __init__(DefaultEmbedding1D self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
9611  __init__(DefaultEmbedding1D self) -> DefaultEmbedding1D
9612  """
9613  _IMP_algebra.DefaultEmbedding1D_swiginit(self, _IMP_algebra.new_DefaultEmbedding1D(*args))
9614 
9615  def set_origin(self, o):
9616  r"""set_origin(DefaultEmbedding1D self, Vector1D o)"""
9617  return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)
9618 
9619  def get_origin(self):
9620  r"""get_origin(DefaultEmbedding1D self) -> Vector1D"""
9621  return _IMP_algebra.DefaultEmbedding1D_get_origin(self)
9622 
9623  def get_dimension(self):
9624  r"""get_dimension(DefaultEmbedding1D self) -> unsigned int"""
9625  return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)
9626 
9627  def set_unit_cell(self, o):
9628  r"""set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
9629  return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, o)
9630 
9631  def get_inverse_unit_cell(self):
9632  r"""get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9633  return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)
9634 
9635  def get_unit_cell(self):
9636  r"""get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
9637  return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)
9638 
9639  def get_extended_index(self, o):
9640  r"""get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
9641  return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, o)
9642 
9643  def get_index(self, o):
9644  r"""get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
9645  return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)
9646 
9647  def get_center(self, *args):
9648  r"""
9649  get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
9650  get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
9651  """
9652  return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)
9653 
9654  def get_bounding_box(self, *args):
9655  r"""
9656  get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
9657  get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
9658  """
9659  return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)
9660 
9661  def show(self, *args):
9662  r"""show(DefaultEmbedding1D self, _ostream out=std::cout)"""
9663  return _IMP_algebra.DefaultEmbedding1D_show(self, *args)
9664 
9665  def __str__(self):
9666  r"""__str__(DefaultEmbedding1D self) -> std::string"""
9667  return _IMP_algebra.DefaultEmbedding1D___str__(self)
9668 
9669  def __repr__(self):
9670  r"""__repr__(DefaultEmbedding1D self) -> std::string"""
9671  return _IMP_algebra.DefaultEmbedding1D___repr__(self)
9672 
9673  def __cmp__(self, arg2):
9674  r"""__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
9675  return _IMP_algebra.DefaultEmbedding1D___cmp__(self, arg2)
9676 
9677  def __eq__(self, arg2):
9678  r"""__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
9679  return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)
9680 
9681  def _get_as_binary(self):
9682  r"""_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
9683  return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)
9684 
9685  def _set_from_binary(self, p):
9686  r"""_set_from_binary(DefaultEmbedding1D self, PyObject * p)"""
9687  return _IMP_algebra.DefaultEmbedding1D__set_from_binary(self, p)
9688 
9689  def __getstate__(self):
9690  p = self._get_as_binary()
9691  if len(self.__dict__) > 1:
9692  d = self.__dict__.copy()
9693  del d['this']
9694  p = (d, p)
9695  return p
9696 
9697  def __setstate__(self, p):
9698  if not hasattr(self, 'this'):
9699  self.__init__()
9700  if isinstance(p, tuple):
9701  d, p = p
9702  self.__dict__.update(d)
9703  return self._set_from_binary(p)
9704 
9705  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
9706 
9707 # Register DefaultEmbedding1D in _IMP_algebra:
9708 _IMP_algebra.DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
9709 class DefaultEmbedding2D(object):
9710  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 2 > class."""
9711 
9712  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9713 
9714  def __init__(self, *args):
9715  r"""
9716  __init__(DefaultEmbedding2D self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
9717  __init__(DefaultEmbedding2D self) -> DefaultEmbedding2D
9718  """
9719  _IMP_algebra.DefaultEmbedding2D_swiginit(self, _IMP_algebra.new_DefaultEmbedding2D(*args))
9720 
9721  def set_origin(self, o):
9722  r"""set_origin(DefaultEmbedding2D self, Vector2D o)"""
9723  return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)
9724 
9725  def get_origin(self):
9726  r"""get_origin(DefaultEmbedding2D self) -> Vector2D"""
9727  return _IMP_algebra.DefaultEmbedding2D_get_origin(self)
9728 
9729  def get_dimension(self):
9730  r"""get_dimension(DefaultEmbedding2D self) -> unsigned int"""
9731  return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)
9732 
9733  def set_unit_cell(self, o):
9734  r"""set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
9735  return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, o)
9736 
9737  def get_inverse_unit_cell(self):
9738  r"""get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9739  return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)
9740 
9741  def get_unit_cell(self):
9742  r"""get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
9743  return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)
9744 
9745  def get_extended_index(self, o):
9746  r"""get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
9747  return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, o)
9748 
9749  def get_index(self, o):
9750  r"""get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
9751  return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)
9752 
9753  def get_center(self, *args):
9754  r"""
9755  get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
9756  get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
9757  """
9758  return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)
9759 
9760  def get_bounding_box(self, *args):
9761  r"""
9762  get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
9763  get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
9764  """
9765  return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)
9766 
9767  def show(self, *args):
9768  r"""show(DefaultEmbedding2D self, _ostream out=std::cout)"""
9769  return _IMP_algebra.DefaultEmbedding2D_show(self, *args)
9770 
9771  def __str__(self):
9772  r"""__str__(DefaultEmbedding2D self) -> std::string"""
9773  return _IMP_algebra.DefaultEmbedding2D___str__(self)
9774 
9775  def __repr__(self):
9776  r"""__repr__(DefaultEmbedding2D self) -> std::string"""
9777  return _IMP_algebra.DefaultEmbedding2D___repr__(self)
9778 
9779  def __cmp__(self, arg2):
9780  r"""__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
9781  return _IMP_algebra.DefaultEmbedding2D___cmp__(self, arg2)
9782 
9783  def __eq__(self, arg2):
9784  r"""__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
9785  return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)
9786 
9787  def _get_as_binary(self):
9788  r"""_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
9789  return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)
9790 
9791  def _set_from_binary(self, p):
9792  r"""_set_from_binary(DefaultEmbedding2D self, PyObject * p)"""
9793  return _IMP_algebra.DefaultEmbedding2D__set_from_binary(self, p)
9794 
9795  def __getstate__(self):
9796  p = self._get_as_binary()
9797  if len(self.__dict__) > 1:
9798  d = self.__dict__.copy()
9799  del d['this']
9800  p = (d, p)
9801  return p
9802 
9803  def __setstate__(self, p):
9804  if not hasattr(self, 'this'):
9805  self.__init__()
9806  if isinstance(p, tuple):
9807  d, p = p
9808  self.__dict__.update(d)
9809  return self._set_from_binary(p)
9810 
9811  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
9812 
9813 # Register DefaultEmbedding2D in _IMP_algebra:
9814 _IMP_algebra.DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
9815 class DefaultEmbedding3D(object):
9816  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 3 > class."""
9817 
9818  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9819 
9820  def __init__(self, *args):
9821  r"""
9822  __init__(DefaultEmbedding3D self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
9823  __init__(DefaultEmbedding3D self) -> DefaultEmbedding3D
9824  """
9825  _IMP_algebra.DefaultEmbedding3D_swiginit(self, _IMP_algebra.new_DefaultEmbedding3D(*args))
9826 
9827  def set_origin(self, o):
9828  r"""set_origin(DefaultEmbedding3D self, Vector3D o)"""
9829  return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)
9830 
9831  def get_origin(self):
9832  r"""get_origin(DefaultEmbedding3D self) -> Vector3D"""
9833  return _IMP_algebra.DefaultEmbedding3D_get_origin(self)
9834 
9835  def get_dimension(self):
9836  r"""get_dimension(DefaultEmbedding3D self) -> unsigned int"""
9837  return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)
9838 
9839  def set_unit_cell(self, o):
9840  r"""set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
9841  return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, o)
9842 
9843  def get_inverse_unit_cell(self):
9844  r"""get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9845  return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)
9846 
9847  def get_unit_cell(self):
9848  r"""get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
9849  return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)
9850 
9851  def get_extended_index(self, o):
9852  r"""get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
9853  return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, o)
9854 
9855  def get_index(self, o):
9856  r"""get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
9857  return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)
9858 
9859  def get_center(self, *args):
9860  r"""
9861  get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
9862  get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
9863  """
9864  return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)
9865 
9866  def get_bounding_box(self, *args):
9867  r"""
9868  get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
9869  get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
9870  """
9871  return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)
9872 
9873  def show(self, *args):
9874  r"""show(DefaultEmbedding3D self, _ostream out=std::cout)"""
9875  return _IMP_algebra.DefaultEmbedding3D_show(self, *args)
9876 
9877  def __str__(self):
9878  r"""__str__(DefaultEmbedding3D self) -> std::string"""
9879  return _IMP_algebra.DefaultEmbedding3D___str__(self)
9880 
9881  def __repr__(self):
9882  r"""__repr__(DefaultEmbedding3D self) -> std::string"""
9883  return _IMP_algebra.DefaultEmbedding3D___repr__(self)
9884 
9885  def __cmp__(self, arg2):
9886  r"""__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
9887  return _IMP_algebra.DefaultEmbedding3D___cmp__(self, arg2)
9888 
9889  def __eq__(self, arg2):
9890  r"""__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
9891  return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)
9892 
9893  def _get_as_binary(self):
9894  r"""_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
9895  return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)
9896 
9897  def _set_from_binary(self, p):
9898  r"""_set_from_binary(DefaultEmbedding3D self, PyObject * p)"""
9899  return _IMP_algebra.DefaultEmbedding3D__set_from_binary(self, p)
9900 
9901  def __getstate__(self):
9902  p = self._get_as_binary()
9903  if len(self.__dict__) > 1:
9904  d = self.__dict__.copy()
9905  del d['this']
9906  p = (d, p)
9907  return p
9908 
9909  def __setstate__(self, p):
9910  if not hasattr(self, 'this'):
9911  self.__init__()
9912  if isinstance(p, tuple):
9913  d, p = p
9914  self.__dict__.update(d)
9915  return self._set_from_binary(p)
9916 
9917  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
9918 
9919 # Register DefaultEmbedding3D in _IMP_algebra:
9920 _IMP_algebra.DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
9921 class DefaultEmbedding4D(object):
9922  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 4 > class."""
9923 
9924  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
9925 
9926  def __init__(self, *args):
9927  r"""
9928  __init__(DefaultEmbedding4D self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
9929  __init__(DefaultEmbedding4D self) -> DefaultEmbedding4D
9930  """
9931  _IMP_algebra.DefaultEmbedding4D_swiginit(self, _IMP_algebra.new_DefaultEmbedding4D(*args))
9932 
9933  def set_origin(self, o):
9934  r"""set_origin(DefaultEmbedding4D self, Vector4D o)"""
9935  return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)
9936 
9937  def get_origin(self):
9938  r"""get_origin(DefaultEmbedding4D self) -> Vector4D"""
9939  return _IMP_algebra.DefaultEmbedding4D_get_origin(self)
9940 
9941  def get_dimension(self):
9942  r"""get_dimension(DefaultEmbedding4D self) -> unsigned int"""
9943  return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)
9944 
9945  def set_unit_cell(self, o):
9946  r"""set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
9947  return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, o)
9948 
9949  def get_inverse_unit_cell(self):
9950  r"""get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9951  return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)
9952 
9953  def get_unit_cell(self):
9954  r"""get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
9955  return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)
9956 
9957  def get_extended_index(self, o):
9958  r"""get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
9959  return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, o)
9960 
9961  def get_index(self, o):
9962  r"""get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
9963  return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)
9964 
9965  def get_center(self, *args):
9966  r"""
9967  get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
9968  get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
9969  """
9970  return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)
9971 
9972  def get_bounding_box(self, *args):
9973  r"""
9974  get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
9975  get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
9976  """
9977  return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)
9978 
9979  def show(self, *args):
9980  r"""show(DefaultEmbedding4D self, _ostream out=std::cout)"""
9981  return _IMP_algebra.DefaultEmbedding4D_show(self, *args)
9982 
9983  def __str__(self):
9984  r"""__str__(DefaultEmbedding4D self) -> std::string"""
9985  return _IMP_algebra.DefaultEmbedding4D___str__(self)
9986 
9987  def __repr__(self):
9988  r"""__repr__(DefaultEmbedding4D self) -> std::string"""
9989  return _IMP_algebra.DefaultEmbedding4D___repr__(self)
9990 
9991  def __cmp__(self, arg2):
9992  r"""__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
9993  return _IMP_algebra.DefaultEmbedding4D___cmp__(self, arg2)
9994 
9995  def __eq__(self, arg2):
9996  r"""__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
9997  return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)
9998 
9999  def _get_as_binary(self):
10000  r"""_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
10001  return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)
10002 
10003  def _set_from_binary(self, p):
10004  r"""_set_from_binary(DefaultEmbedding4D self, PyObject * p)"""
10005  return _IMP_algebra.DefaultEmbedding4D__set_from_binary(self, p)
10006 
10007  def __getstate__(self):
10008  p = self._get_as_binary()
10009  if len(self.__dict__) > 1:
10010  d = self.__dict__.copy()
10011  del d['this']
10012  p = (d, p)
10013  return p
10014 
10015  def __setstate__(self, p):
10016  if not hasattr(self, 'this'):
10017  self.__init__()
10018  if isinstance(p, tuple):
10019  d, p = p
10020  self.__dict__.update(d)
10021  return self._set_from_binary(p)
10022 
10023  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
10024 
10025 # Register DefaultEmbedding4D in _IMP_algebra:
10026 _IMP_algebra.DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
10027 class DefaultEmbedding5D(object):
10028  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 5 > class."""
10029 
10030  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10031 
10032  def __init__(self, *args):
10033  r"""
10034  __init__(DefaultEmbedding5D self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
10035  __init__(DefaultEmbedding5D self) -> DefaultEmbedding5D
10036  """
10037  _IMP_algebra.DefaultEmbedding5D_swiginit(self, _IMP_algebra.new_DefaultEmbedding5D(*args))
10038 
10039  def set_origin(self, o):
10040  r"""set_origin(DefaultEmbedding5D self, Vector5D o)"""
10041  return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)
10042 
10043  def get_origin(self):
10044  r"""get_origin(DefaultEmbedding5D self) -> Vector5D"""
10045  return _IMP_algebra.DefaultEmbedding5D_get_origin(self)
10046 
10047  def get_dimension(self):
10048  r"""get_dimension(DefaultEmbedding5D self) -> unsigned int"""
10049  return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)
10050 
10051  def set_unit_cell(self, o):
10052  r"""set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
10053  return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, o)
10054 
10055  def get_inverse_unit_cell(self):
10056  r"""get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10057  return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)
10058 
10059  def get_unit_cell(self):
10060  r"""get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
10061  return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)
10062 
10063  def get_extended_index(self, o):
10064  r"""get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10065  return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, o)
10066 
10067  def get_index(self, o):
10068  r"""get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
10069  return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)
10070 
10071  def get_center(self, *args):
10072  r"""
10073  get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10074  get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
10075  """
10076  return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)
10077 
10078  def get_bounding_box(self, *args):
10079  r"""
10080  get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10081  get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10082  """
10083  return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)
10084 
10085  def show(self, *args):
10086  r"""show(DefaultEmbedding5D self, _ostream out=std::cout)"""
10087  return _IMP_algebra.DefaultEmbedding5D_show(self, *args)
10088 
10089  def __str__(self):
10090  r"""__str__(DefaultEmbedding5D self) -> std::string"""
10091  return _IMP_algebra.DefaultEmbedding5D___str__(self)
10092 
10093  def __repr__(self):
10094  r"""__repr__(DefaultEmbedding5D self) -> std::string"""
10095  return _IMP_algebra.DefaultEmbedding5D___repr__(self)
10096 
10097  def __cmp__(self, arg2):
10098  r"""__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
10099  return _IMP_algebra.DefaultEmbedding5D___cmp__(self, arg2)
10100 
10101  def __eq__(self, arg2):
10102  r"""__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
10103  return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)
10104 
10105  def _get_as_binary(self):
10106  r"""_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
10107  return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)
10108 
10109  def _set_from_binary(self, p):
10110  r"""_set_from_binary(DefaultEmbedding5D self, PyObject * p)"""
10111  return _IMP_algebra.DefaultEmbedding5D__set_from_binary(self, p)
10112 
10113  def __getstate__(self):
10114  p = self._get_as_binary()
10115  if len(self.__dict__) > 1:
10116  d = self.__dict__.copy()
10117  del d['this']
10118  p = (d, p)
10119  return p
10120 
10121  def __setstate__(self, p):
10122  if not hasattr(self, 'this'):
10123  self.__init__()
10124  if isinstance(p, tuple):
10125  d, p = p
10126  self.__dict__.update(d)
10127  return self._set_from_binary(p)
10128 
10129  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
10130 
10131 # Register DefaultEmbedding5D in _IMP_algebra:
10132 _IMP_algebra.DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
10133 class DefaultEmbedding6D(object):
10134  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< 6 > class."""
10135 
10136  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10137 
10138  def __init__(self, *args):
10139  r"""
10140  __init__(DefaultEmbedding6D self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
10141  __init__(DefaultEmbedding6D self) -> DefaultEmbedding6D
10142  """
10143  _IMP_algebra.DefaultEmbedding6D_swiginit(self, _IMP_algebra.new_DefaultEmbedding6D(*args))
10144 
10145  def set_origin(self, o):
10146  r"""set_origin(DefaultEmbedding6D self, Vector6D o)"""
10147  return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)
10148 
10149  def get_origin(self):
10150  r"""get_origin(DefaultEmbedding6D self) -> Vector6D"""
10151  return _IMP_algebra.DefaultEmbedding6D_get_origin(self)
10152 
10153  def get_dimension(self):
10154  r"""get_dimension(DefaultEmbedding6D self) -> unsigned int"""
10155  return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)
10156 
10157  def set_unit_cell(self, o):
10158  r"""set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
10159  return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, o)
10160 
10161  def get_inverse_unit_cell(self):
10162  r"""get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10163  return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)
10164 
10165  def get_unit_cell(self):
10166  r"""get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
10167  return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)
10168 
10169  def get_extended_index(self, o):
10170  r"""get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10171  return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, o)
10172 
10173  def get_index(self, o):
10174  r"""get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
10175  return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)
10176 
10177  def get_center(self, *args):
10178  r"""
10179  get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10180  get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
10181  """
10182  return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)
10183 
10184  def get_bounding_box(self, *args):
10185  r"""
10186  get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10187  get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10188  """
10189  return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)
10190 
10191  def show(self, *args):
10192  r"""show(DefaultEmbedding6D self, _ostream out=std::cout)"""
10193  return _IMP_algebra.DefaultEmbedding6D_show(self, *args)
10194 
10195  def __str__(self):
10196  r"""__str__(DefaultEmbedding6D self) -> std::string"""
10197  return _IMP_algebra.DefaultEmbedding6D___str__(self)
10198 
10199  def __repr__(self):
10200  r"""__repr__(DefaultEmbedding6D self) -> std::string"""
10201  return _IMP_algebra.DefaultEmbedding6D___repr__(self)
10202 
10203  def __cmp__(self, arg2):
10204  r"""__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
10205  return _IMP_algebra.DefaultEmbedding6D___cmp__(self, arg2)
10206 
10207  def __eq__(self, arg2):
10208  r"""__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
10209  return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)
10210 
10211  def _get_as_binary(self):
10212  r"""_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
10213  return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)
10214 
10215  def _set_from_binary(self, p):
10216  r"""_set_from_binary(DefaultEmbedding6D self, PyObject * p)"""
10217  return _IMP_algebra.DefaultEmbedding6D__set_from_binary(self, p)
10218 
10219  def __getstate__(self):
10220  p = self._get_as_binary()
10221  if len(self.__dict__) > 1:
10222  d = self.__dict__.copy()
10223  del d['this']
10224  p = (d, p)
10225  return p
10226 
10227  def __setstate__(self, p):
10228  if not hasattr(self, 'this'):
10229  self.__init__()
10230  if isinstance(p, tuple):
10231  d, p = p
10232  self.__dict__.update(d)
10233  return self._set_from_binary(p)
10234 
10235  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
10236 
10237 # Register DefaultEmbedding6D in _IMP_algebra:
10238 _IMP_algebra.DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
10239 class DefaultEmbeddingKD(object):
10240  r"""Proxy of C++ IMP::algebra::DefaultEmbeddingD< -1 > class."""
10241 
10242  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10243 
10244  def __init__(self, *args):
10245  r"""
10246  __init__(DefaultEmbeddingKD self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
10247  __init__(DefaultEmbeddingKD self) -> DefaultEmbeddingKD
10248  """
10249  _IMP_algebra.DefaultEmbeddingKD_swiginit(self, _IMP_algebra.new_DefaultEmbeddingKD(*args))
10250 
10251  def set_origin(self, o):
10252  r"""set_origin(DefaultEmbeddingKD self, VectorKD o)"""
10253  return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)
10254 
10255  def get_origin(self):
10256  r"""get_origin(DefaultEmbeddingKD self) -> VectorKD"""
10257  return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)
10258 
10259  def get_dimension(self):
10260  r"""get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
10261  return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)
10262 
10263  def set_unit_cell(self, o):
10264  r"""set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
10265  return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, o)
10266 
10267  def get_inverse_unit_cell(self):
10268  r"""get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10269  return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)
10270 
10271  def get_unit_cell(self):
10272  r"""get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
10273  return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)
10274 
10275  def get_extended_index(self, o):
10276  r"""get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
10277  return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, o)
10278 
10279  def get_index(self, o):
10280  r"""get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
10281  return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)
10282 
10283  def get_center(self, *args):
10284  r"""
10285  get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
10286  get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
10287  """
10288  return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)
10289 
10290  def get_bounding_box(self, *args):
10291  r"""
10292  get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
10293  get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
10294  """
10295  return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)
10296 
10297  def show(self, *args):
10298  r"""show(DefaultEmbeddingKD self, _ostream out=std::cout)"""
10299  return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)
10300 
10301  def __str__(self):
10302  r"""__str__(DefaultEmbeddingKD self) -> std::string"""
10303  return _IMP_algebra.DefaultEmbeddingKD___str__(self)
10304 
10305  def __repr__(self):
10306  r"""__repr__(DefaultEmbeddingKD self) -> std::string"""
10307  return _IMP_algebra.DefaultEmbeddingKD___repr__(self)
10308 
10309  def __cmp__(self, arg2):
10310  r"""__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
10311  return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, arg2)
10312 
10313  def __eq__(self, arg2):
10314  r"""__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
10315  return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)
10316 
10317  def _get_as_binary(self):
10318  r"""_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
10319  return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)
10320 
10321  def _set_from_binary(self, p):
10322  r"""_set_from_binary(DefaultEmbeddingKD self, PyObject * p)"""
10323  return _IMP_algebra.DefaultEmbeddingKD__set_from_binary(self, p)
10324 
10325  def __getstate__(self):
10326  p = self._get_as_binary()
10327  if len(self.__dict__) > 1:
10328  d = self.__dict__.copy()
10329  del d['this']
10330  p = (d, p)
10331  return p
10332 
10333  def __setstate__(self, p):
10334  if not hasattr(self, 'this'):
10335  self.__init__()
10336  if isinstance(p, tuple):
10337  d, p = p
10338  self.__dict__.update(d)
10339  return self._set_from_binary(p)
10340 
10341  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
10342 
10343 # Register DefaultEmbeddingKD in _IMP_algebra:
10344 _IMP_algebra.DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
10345 class LogEmbedding1D(object):
10346  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 1 > class."""
10347 
10348  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10349 
10350  def __init__(self, *args):
10351  r"""
10352  __init__(LogEmbedding1D self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
10353  __init__(LogEmbedding1D self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
10354  __init__(LogEmbedding1D self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
10355  __init__(LogEmbedding1D self) -> LogEmbedding1D
10356  """
10357  _IMP_algebra.LogEmbedding1D_swiginit(self, _IMP_algebra.new_LogEmbedding1D(*args))
10358 
10359  def set_origin(self, o):
10360  r"""set_origin(LogEmbedding1D self, Vector1D o)"""
10361  return _IMP_algebra.LogEmbedding1D_set_origin(self, o)
10362 
10363  def get_origin(self):
10364  r"""get_origin(LogEmbedding1D self) -> Vector1D"""
10365  return _IMP_algebra.LogEmbedding1D_get_origin(self)
10366 
10367  def get_dimension(self):
10368  r"""get_dimension(LogEmbedding1D self) -> unsigned int"""
10369  return _IMP_algebra.LogEmbedding1D_get_dimension(self)
10370 
10371  def set_unit_cell(self, *args):
10372  r"""
10373  set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
10374  set_unit_cell(LogEmbedding1D self, Vector1D o)
10375  """
10376  return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)
10377 
10378  def get_unit_cell(self):
10379  r"""get_unit_cell(LogEmbedding1D self) -> Vector1D"""
10380  return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)
10381 
10382  def get_extended_index(self, o):
10383  r"""get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
10384  return _IMP_algebra.LogEmbedding1D_get_extended_index(self, o)
10385 
10386  def get_index(self, o):
10387  r"""get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
10388  return _IMP_algebra.LogEmbedding1D_get_index(self, o)
10389 
10390  def get_center(self, *args):
10391  r"""
10392  get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
10393  get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
10394  """
10395  return _IMP_algebra.LogEmbedding1D_get_center(self, *args)
10396 
10397  def get_bounding_box(self, *args):
10398  r"""
10399  get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
10400  get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
10401  """
10402  return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)
10403 
10404  def show(self, *args):
10405  r"""show(LogEmbedding1D self, _ostream out=std::cout)"""
10406  return _IMP_algebra.LogEmbedding1D_show(self, *args)
10407 
10408  def __str__(self):
10409  r"""__str__(LogEmbedding1D self) -> std::string"""
10410  return _IMP_algebra.LogEmbedding1D___str__(self)
10411 
10412  def __repr__(self):
10413  r"""__repr__(LogEmbedding1D self) -> std::string"""
10414  return _IMP_algebra.LogEmbedding1D___repr__(self)
10415 
10416  def __cmp__(self, arg2):
10417  r"""__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
10418  return _IMP_algebra.LogEmbedding1D___cmp__(self, arg2)
10419 
10420  def __eq__(self, arg2):
10421  r"""__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
10422  return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)
10423 
10424  def _get_as_binary(self):
10425  r"""_get_as_binary(LogEmbedding1D self) -> PyObject *"""
10426  return _IMP_algebra.LogEmbedding1D__get_as_binary(self)
10427 
10428  def _set_from_binary(self, p):
10429  r"""_set_from_binary(LogEmbedding1D self, PyObject * p)"""
10430  return _IMP_algebra.LogEmbedding1D__set_from_binary(self, p)
10431 
10432  def __getstate__(self):
10433  p = self._get_as_binary()
10434  if len(self.__dict__) > 1:
10435  d = self.__dict__.copy()
10436  del d['this']
10437  p = (d, p)
10438  return p
10439 
10440  def __setstate__(self, p):
10441  if not hasattr(self, 'this'):
10442  self.__init__()
10443  if isinstance(p, tuple):
10444  d, p = p
10445  self.__dict__.update(d)
10446  return self._set_from_binary(p)
10447 
10448  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
10449 
10450 # Register LogEmbedding1D in _IMP_algebra:
10451 _IMP_algebra.LogEmbedding1D_swigregister(LogEmbedding1D)
10452 class LogEmbedding2D(object):
10453  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 2 > class."""
10454 
10455  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10456 
10457  def __init__(self, *args):
10458  r"""
10459  __init__(LogEmbedding2D self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
10460  __init__(LogEmbedding2D self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
10461  __init__(LogEmbedding2D self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
10462  __init__(LogEmbedding2D self) -> LogEmbedding2D
10463  """
10464  _IMP_algebra.LogEmbedding2D_swiginit(self, _IMP_algebra.new_LogEmbedding2D(*args))
10465 
10466  def set_origin(self, o):
10467  r"""set_origin(LogEmbedding2D self, Vector2D o)"""
10468  return _IMP_algebra.LogEmbedding2D_set_origin(self, o)
10469 
10470  def get_origin(self):
10471  r"""get_origin(LogEmbedding2D self) -> Vector2D"""
10472  return _IMP_algebra.LogEmbedding2D_get_origin(self)
10473 
10474  def get_dimension(self):
10475  r"""get_dimension(LogEmbedding2D self) -> unsigned int"""
10476  return _IMP_algebra.LogEmbedding2D_get_dimension(self)
10477 
10478  def set_unit_cell(self, *args):
10479  r"""
10480  set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
10481  set_unit_cell(LogEmbedding2D self, Vector2D o)
10482  """
10483  return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)
10484 
10485  def get_unit_cell(self):
10486  r"""get_unit_cell(LogEmbedding2D self) -> Vector2D"""
10487  return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)
10488 
10489  def get_extended_index(self, o):
10490  r"""get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
10491  return _IMP_algebra.LogEmbedding2D_get_extended_index(self, o)
10492 
10493  def get_index(self, o):
10494  r"""get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
10495  return _IMP_algebra.LogEmbedding2D_get_index(self, o)
10496 
10497  def get_center(self, *args):
10498  r"""
10499  get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
10500  get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
10501  """
10502  return _IMP_algebra.LogEmbedding2D_get_center(self, *args)
10503 
10504  def get_bounding_box(self, *args):
10505  r"""
10506  get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
10507  get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
10508  """
10509  return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)
10510 
10511  def show(self, *args):
10512  r"""show(LogEmbedding2D self, _ostream out=std::cout)"""
10513  return _IMP_algebra.LogEmbedding2D_show(self, *args)
10514 
10515  def __str__(self):
10516  r"""__str__(LogEmbedding2D self) -> std::string"""
10517  return _IMP_algebra.LogEmbedding2D___str__(self)
10518 
10519  def __repr__(self):
10520  r"""__repr__(LogEmbedding2D self) -> std::string"""
10521  return _IMP_algebra.LogEmbedding2D___repr__(self)
10522 
10523  def __cmp__(self, arg2):
10524  r"""__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
10525  return _IMP_algebra.LogEmbedding2D___cmp__(self, arg2)
10526 
10527  def __eq__(self, arg2):
10528  r"""__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
10529  return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)
10530 
10531  def _get_as_binary(self):
10532  r"""_get_as_binary(LogEmbedding2D self) -> PyObject *"""
10533  return _IMP_algebra.LogEmbedding2D__get_as_binary(self)
10534 
10535  def _set_from_binary(self, p):
10536  r"""_set_from_binary(LogEmbedding2D self, PyObject * p)"""
10537  return _IMP_algebra.LogEmbedding2D__set_from_binary(self, p)
10538 
10539  def __getstate__(self):
10540  p = self._get_as_binary()
10541  if len(self.__dict__) > 1:
10542  d = self.__dict__.copy()
10543  del d['this']
10544  p = (d, p)
10545  return p
10546 
10547  def __setstate__(self, p):
10548  if not hasattr(self, 'this'):
10549  self.__init__()
10550  if isinstance(p, tuple):
10551  d, p = p
10552  self.__dict__.update(d)
10553  return self._set_from_binary(p)
10554 
10555  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
10556 
10557 # Register LogEmbedding2D in _IMP_algebra:
10558 _IMP_algebra.LogEmbedding2D_swigregister(LogEmbedding2D)
10559 class LogEmbedding4D(object):
10560  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 4 > class."""
10561 
10562  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10563 
10564  def __init__(self, *args):
10565  r"""
10566  __init__(LogEmbedding4D self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
10567  __init__(LogEmbedding4D self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
10568  __init__(LogEmbedding4D self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
10569  __init__(LogEmbedding4D self) -> LogEmbedding4D
10570  """
10571  _IMP_algebra.LogEmbedding4D_swiginit(self, _IMP_algebra.new_LogEmbedding4D(*args))
10572 
10573  def set_origin(self, o):
10574  r"""set_origin(LogEmbedding4D self, Vector4D o)"""
10575  return _IMP_algebra.LogEmbedding4D_set_origin(self, o)
10576 
10577  def get_origin(self):
10578  r"""get_origin(LogEmbedding4D self) -> Vector4D"""
10579  return _IMP_algebra.LogEmbedding4D_get_origin(self)
10580 
10581  def get_dimension(self):
10582  r"""get_dimension(LogEmbedding4D self) -> unsigned int"""
10583  return _IMP_algebra.LogEmbedding4D_get_dimension(self)
10584 
10585  def set_unit_cell(self, *args):
10586  r"""
10587  set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
10588  set_unit_cell(LogEmbedding4D self, Vector4D o)
10589  """
10590  return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)
10591 
10592  def get_unit_cell(self):
10593  r"""get_unit_cell(LogEmbedding4D self) -> Vector4D"""
10594  return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)
10595 
10596  def get_extended_index(self, o):
10597  r"""get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
10598  return _IMP_algebra.LogEmbedding4D_get_extended_index(self, o)
10599 
10600  def get_index(self, o):
10601  r"""get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
10602  return _IMP_algebra.LogEmbedding4D_get_index(self, o)
10603 
10604  def get_center(self, *args):
10605  r"""
10606  get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
10607  get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
10608  """
10609  return _IMP_algebra.LogEmbedding4D_get_center(self, *args)
10610 
10611  def get_bounding_box(self, *args):
10612  r"""
10613  get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
10614  get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
10615  """
10616  return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)
10617 
10618  def show(self, *args):
10619  r"""show(LogEmbedding4D self, _ostream out=std::cout)"""
10620  return _IMP_algebra.LogEmbedding4D_show(self, *args)
10621 
10622  def __str__(self):
10623  r"""__str__(LogEmbedding4D self) -> std::string"""
10624  return _IMP_algebra.LogEmbedding4D___str__(self)
10625 
10626  def __repr__(self):
10627  r"""__repr__(LogEmbedding4D self) -> std::string"""
10628  return _IMP_algebra.LogEmbedding4D___repr__(self)
10629 
10630  def __cmp__(self, arg2):
10631  r"""__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
10632  return _IMP_algebra.LogEmbedding4D___cmp__(self, arg2)
10633 
10634  def __eq__(self, arg2):
10635  r"""__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
10636  return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)
10637 
10638  def _get_as_binary(self):
10639  r"""_get_as_binary(LogEmbedding4D self) -> PyObject *"""
10640  return _IMP_algebra.LogEmbedding4D__get_as_binary(self)
10641 
10642  def _set_from_binary(self, p):
10643  r"""_set_from_binary(LogEmbedding4D self, PyObject * p)"""
10644  return _IMP_algebra.LogEmbedding4D__set_from_binary(self, p)
10645 
10646  def __getstate__(self):
10647  p = self._get_as_binary()
10648  if len(self.__dict__) > 1:
10649  d = self.__dict__.copy()
10650  del d['this']
10651  p = (d, p)
10652  return p
10653 
10654  def __setstate__(self, p):
10655  if not hasattr(self, 'this'):
10656  self.__init__()
10657  if isinstance(p, tuple):
10658  d, p = p
10659  self.__dict__.update(d)
10660  return self._set_from_binary(p)
10661 
10662  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
10663 
10664 # Register LogEmbedding4D in _IMP_algebra:
10665 _IMP_algebra.LogEmbedding4D_swigregister(LogEmbedding4D)
10666 class LogEmbedding5D(object):
10667  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 5 > class."""
10668 
10669  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10670 
10671  def __init__(self, *args):
10672  r"""
10673  __init__(LogEmbedding5D self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
10674  __init__(LogEmbedding5D self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
10675  __init__(LogEmbedding5D self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
10676  __init__(LogEmbedding5D self) -> LogEmbedding5D
10677  """
10678  _IMP_algebra.LogEmbedding5D_swiginit(self, _IMP_algebra.new_LogEmbedding5D(*args))
10679 
10680  def set_origin(self, o):
10681  r"""set_origin(LogEmbedding5D self, Vector5D o)"""
10682  return _IMP_algebra.LogEmbedding5D_set_origin(self, o)
10683 
10684  def get_origin(self):
10685  r"""get_origin(LogEmbedding5D self) -> Vector5D"""
10686  return _IMP_algebra.LogEmbedding5D_get_origin(self)
10687 
10688  def get_dimension(self):
10689  r"""get_dimension(LogEmbedding5D self) -> unsigned int"""
10690  return _IMP_algebra.LogEmbedding5D_get_dimension(self)
10691 
10692  def set_unit_cell(self, *args):
10693  r"""
10694  set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
10695  set_unit_cell(LogEmbedding5D self, Vector5D o)
10696  """
10697  return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)
10698 
10699  def get_unit_cell(self):
10700  r"""get_unit_cell(LogEmbedding5D self) -> Vector5D"""
10701  return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)
10702 
10703  def get_extended_index(self, o):
10704  r"""get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
10705  return _IMP_algebra.LogEmbedding5D_get_extended_index(self, o)
10706 
10707  def get_index(self, o):
10708  r"""get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
10709  return _IMP_algebra.LogEmbedding5D_get_index(self, o)
10710 
10711  def get_center(self, *args):
10712  r"""
10713  get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
10714  get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
10715  """
10716  return _IMP_algebra.LogEmbedding5D_get_center(self, *args)
10717 
10718  def get_bounding_box(self, *args):
10719  r"""
10720  get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
10721  get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
10722  """
10723  return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)
10724 
10725  def show(self, *args):
10726  r"""show(LogEmbedding5D self, _ostream out=std::cout)"""
10727  return _IMP_algebra.LogEmbedding5D_show(self, *args)
10728 
10729  def __str__(self):
10730  r"""__str__(LogEmbedding5D self) -> std::string"""
10731  return _IMP_algebra.LogEmbedding5D___str__(self)
10732 
10733  def __repr__(self):
10734  r"""__repr__(LogEmbedding5D self) -> std::string"""
10735  return _IMP_algebra.LogEmbedding5D___repr__(self)
10736 
10737  def __cmp__(self, arg2):
10738  r"""__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
10739  return _IMP_algebra.LogEmbedding5D___cmp__(self, arg2)
10740 
10741  def __eq__(self, arg2):
10742  r"""__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
10743  return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)
10744 
10745  def _get_as_binary(self):
10746  r"""_get_as_binary(LogEmbedding5D self) -> PyObject *"""
10747  return _IMP_algebra.LogEmbedding5D__get_as_binary(self)
10748 
10749  def _set_from_binary(self, p):
10750  r"""_set_from_binary(LogEmbedding5D self, PyObject * p)"""
10751  return _IMP_algebra.LogEmbedding5D__set_from_binary(self, p)
10752 
10753  def __getstate__(self):
10754  p = self._get_as_binary()
10755  if len(self.__dict__) > 1:
10756  d = self.__dict__.copy()
10757  del d['this']
10758  p = (d, p)
10759  return p
10760 
10761  def __setstate__(self, p):
10762  if not hasattr(self, 'this'):
10763  self.__init__()
10764  if isinstance(p, tuple):
10765  d, p = p
10766  self.__dict__.update(d)
10767  return self._set_from_binary(p)
10768 
10769  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
10770 
10771 # Register LogEmbedding5D in _IMP_algebra:
10772 _IMP_algebra.LogEmbedding5D_swigregister(LogEmbedding5D)
10773 class LogEmbedding6D(object):
10774  r"""Proxy of C++ IMP::algebra::LogEmbeddingD< 6 > class."""
10775 
10776  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10777 
10778  def __init__(self, *args):
10779  r"""
10780  __init__(LogEmbedding6D self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
10781  __init__(LogEmbedding6D self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
10782  __init__(LogEmbedding6D self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
10783  __init__(LogEmbedding6D self) -> LogEmbedding6D
10784  """
10785  _IMP_algebra.LogEmbedding6D_swiginit(self, _IMP_algebra.new_LogEmbedding6D(*args))
10786 
10787  def set_origin(self, o):
10788  r"""set_origin(LogEmbedding6D self, Vector6D o)"""
10789  return _IMP_algebra.LogEmbedding6D_set_origin(self, o)
10790 
10791  def get_origin(self):
10792  r"""get_origin(LogEmbedding6D self) -> Vector6D"""
10793  return _IMP_algebra.LogEmbedding6D_get_origin(self)
10794 
10795  def get_dimension(self):
10796  r"""get_dimension(LogEmbedding6D self) -> unsigned int"""
10797  return _IMP_algebra.LogEmbedding6D_get_dimension(self)
10798 
10799  def set_unit_cell(self, *args):
10800  r"""
10801  set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
10802  set_unit_cell(LogEmbedding6D self, Vector6D o)
10803  """
10804  return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)
10805 
10806  def get_unit_cell(self):
10807  r"""get_unit_cell(LogEmbedding6D self) -> Vector6D"""
10808  return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)
10809 
10810  def get_extended_index(self, o):
10811  r"""get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
10812  return _IMP_algebra.LogEmbedding6D_get_extended_index(self, o)
10813 
10814  def get_index(self, o):
10815  r"""get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
10816  return _IMP_algebra.LogEmbedding6D_get_index(self, o)
10817 
10818  def get_center(self, *args):
10819  r"""
10820  get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
10821  get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
10822  """
10823  return _IMP_algebra.LogEmbedding6D_get_center(self, *args)
10824 
10825  def get_bounding_box(self, *args):
10826  r"""
10827  get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
10828  get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
10829  """
10830  return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)
10831 
10832  def show(self, *args):
10833  r"""show(LogEmbedding6D self, _ostream out=std::cout)"""
10834  return _IMP_algebra.LogEmbedding6D_show(self, *args)
10835 
10836  def __str__(self):
10837  r"""__str__(LogEmbedding6D self) -> std::string"""
10838  return _IMP_algebra.LogEmbedding6D___str__(self)
10839 
10840  def __repr__(self):
10841  r"""__repr__(LogEmbedding6D self) -> std::string"""
10842  return _IMP_algebra.LogEmbedding6D___repr__(self)
10843 
10844  def __cmp__(self, arg2):
10845  r"""__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
10846  return _IMP_algebra.LogEmbedding6D___cmp__(self, arg2)
10847 
10848  def __eq__(self, arg2):
10849  r"""__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
10850  return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)
10851 
10852  def _get_as_binary(self):
10853  r"""_get_as_binary(LogEmbedding6D self) -> PyObject *"""
10854  return _IMP_algebra.LogEmbedding6D__get_as_binary(self)
10855 
10856  def _set_from_binary(self, p):
10857  r"""_set_from_binary(LogEmbedding6D self, PyObject * p)"""
10858  return _IMP_algebra.LogEmbedding6D__set_from_binary(self, p)
10859 
10860  def __getstate__(self):
10861  p = self._get_as_binary()
10862  if len(self.__dict__) > 1:
10863  d = self.__dict__.copy()
10864  del d['this']
10865  p = (d, p)
10866  return p
10867 
10868  def __setstate__(self, p):
10869  if not hasattr(self, 'this'):
10870  self.__init__()
10871  if isinstance(p, tuple):
10872  d, p = p
10873  self.__dict__.update(d)
10874  return self._set_from_binary(p)
10875 
10876  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
10877 
10878 # Register LogEmbedding6D in _IMP_algebra:
10879 _IMP_algebra.LogEmbedding6D_swigregister(LogEmbedding6D)
10880 class SpherePatch3D(_GeometricPrimitive3D):
10881  r"""Proxy of C++ IMP::algebra::SpherePatch3D class."""
10882 
10883  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10884 
10885  def __init__(self, *args):
10886  r"""
10887  __init__(SpherePatch3D self) -> SpherePatch3D
10888  __init__(SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
10889  """
10890  _IMP_algebra.SpherePatch3D_swiginit(self, _IMP_algebra.new_SpherePatch3D(*args))
10891 
10892  def get_contains(self, p):
10893  r"""get_contains(SpherePatch3D self, Vector3D p) -> bool"""
10894  return _IMP_algebra.SpherePatch3D_get_contains(self, p)
10895 
10896  def get_plane(self):
10897  r"""get_plane(SpherePatch3D self) -> Plane3D"""
10898  return _IMP_algebra.SpherePatch3D_get_plane(self)
10899 
10900  def get_sphere(self):
10901  r"""get_sphere(SpherePatch3D self) -> Sphere3D"""
10902  return _IMP_algebra.SpherePatch3D_get_sphere(self)
10903 
10904  def show(self, *args):
10905  r"""show(SpherePatch3D self, _ostream out=std::cout)"""
10906  return _IMP_algebra.SpherePatch3D_show(self, *args)
10907 
10908  def get_boundary_point(self):
10909  r"""get_boundary_point(SpherePatch3D self) -> Vector3D"""
10910  return _IMP_algebra.SpherePatch3D_get_boundary_point(self)
10911 
10912  def __str__(self):
10913  r"""__str__(SpherePatch3D self) -> std::string"""
10914  return _IMP_algebra.SpherePatch3D___str__(self)
10915 
10916  def __repr__(self):
10917  r"""__repr__(SpherePatch3D self) -> std::string"""
10918  return _IMP_algebra.SpherePatch3D___repr__(self)
10919 
10920  def _get_as_binary(self):
10921  r"""_get_as_binary(SpherePatch3D self) -> PyObject *"""
10922  return _IMP_algebra.SpherePatch3D__get_as_binary(self)
10923 
10924  def _set_from_binary(self, p):
10925  r"""_set_from_binary(SpherePatch3D self, PyObject * p)"""
10926  return _IMP_algebra.SpherePatch3D__set_from_binary(self, p)
10927 
10928  def __getstate__(self):
10929  p = self._get_as_binary()
10930  if len(self.__dict__) > 1:
10931  d = self.__dict__.copy()
10932  del d['this']
10933  p = (d, p)
10934  return p
10935 
10936  def __setstate__(self, p):
10937  if not hasattr(self, 'this'):
10938  self.__init__()
10939  if isinstance(p, tuple):
10940  d, p = p
10941  self.__dict__.update(d)
10942  return self._set_from_binary(p)
10943 
10944  __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
10945 
10946 # Register SpherePatch3D in _IMP_algebra:
10947 _IMP_algebra.SpherePatch3D_swigregister(SpherePatch3D)
10948 
10949 def get_area(*args):
10950  r"""
10951  get_area(Plane3D g) -> double
10952  get_area(SpherePatch3D g) -> double
10953  """
10954  return _IMP_algebra.get_area(*args)
10955 
10956 def get_sphere_patch_3d_geometry(g):
10957  r"""get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
10958  return _IMP_algebra.get_sphere_patch_3d_geometry(g)
10959 class Cone3D(_GeometricPrimitive3D):
10960  r"""Proxy of C++ IMP::algebra::Cone3D class."""
10961 
10962  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
10963 
10964  def __init__(self, *args):
10965  r"""
10966  __init__(Cone3D self) -> Cone3D
10967  __init__(Cone3D self, Segment3D s, double radius) -> Cone3D
10968  """
10969  _IMP_algebra.Cone3D_swiginit(self, _IMP_algebra.new_Cone3D(*args))
10970 
10971  def get_tip(self):
10972  r"""get_tip(Cone3D self) -> Vector3D"""
10973  return _IMP_algebra.Cone3D_get_tip(self)
10974 
10975  def get_direction(self):
10976  r"""get_direction(Cone3D self) -> Vector3D"""
10977  return _IMP_algebra.Cone3D_get_direction(self)
10978 
10979  def get_height(self):
10980  r"""get_height(Cone3D self) -> double"""
10981  return _IMP_algebra.Cone3D_get_height(self)
10982 
10983  def get_angle(self):
10984  r"""get_angle(Cone3D self) -> double"""
10985  return _IMP_algebra.Cone3D_get_angle(self)
10986 
10987  def get_radius(self):
10988  r"""get_radius(Cone3D self) -> double"""
10989  return _IMP_algebra.Cone3D_get_radius(self)
10990 
10991  def get_contains(self, v):
10992  r"""get_contains(Cone3D self, Vector3D v) -> bool"""
10993  return _IMP_algebra.Cone3D_get_contains(self, v)
10994 
10995  def get_base_plane(self):
10996  r"""get_base_plane(Cone3D self) -> Plane3D"""
10997  return _IMP_algebra.Cone3D_get_base_plane(self)
10998 
10999  def show(self, *args):
11000  r"""show(Cone3D self, _ostream out=std::cout)"""
11001  return _IMP_algebra.Cone3D_show(self, *args)
11002 
11003  def __str__(self):
11004  r"""__str__(Cone3D self) -> std::string"""
11005  return _IMP_algebra.Cone3D___str__(self)
11006 
11007  def __repr__(self):
11008  r"""__repr__(Cone3D self) -> std::string"""
11009  return _IMP_algebra.Cone3D___repr__(self)
11010 
11011  def _get_as_binary(self):
11012  r"""_get_as_binary(Cone3D self) -> PyObject *"""
11013  return _IMP_algebra.Cone3D__get_as_binary(self)
11014 
11015  def _set_from_binary(self, p):
11016  r"""_set_from_binary(Cone3D self, PyObject * p)"""
11017  return _IMP_algebra.Cone3D__set_from_binary(self, p)
11018 
11019  def __getstate__(self):
11020  p = self._get_as_binary()
11021  if len(self.__dict__) > 1:
11022  d = self.__dict__.copy()
11023  del d['this']
11024  p = (d, p)
11025  return p
11026 
11027  def __setstate__(self, p):
11028  if not hasattr(self, 'this'):
11029  self.__init__()
11030  if isinstance(p, tuple):
11031  d, p = p
11032  self.__dict__.update(d)
11033  return self._set_from_binary(p)
11034 
11035  __swig_destroy__ = _IMP_algebra.delete_Cone3D
11036 
11037 # Register Cone3D in _IMP_algebra:
11038 _IMP_algebra.Cone3D_swigregister(Cone3D)
11039 
11040 def get_surface_area(*args):
11041  r"""
11042  get_surface_area(BoundingBox3D g) -> double
11043  get_surface_area(Sphere3D g) -> double
11044  get_surface_area(Cylinder3D g) -> double
11045  get_surface_area(Ellipsoid3D g) -> double
11046  get_surface_area(Cone3D g) -> double
11047  """
11048  return _IMP_algebra.get_surface_area(*args)
11049 
11050 def get_volume(*args):
11051  r"""
11052  get_volume(BoundingBox3D g) -> double
11053  get_volume(Sphere3D g) -> double
11054  get_volume(Cylinder3D g) -> double
11055  get_volume(Ellipsoid3D g) -> double
11056  get_volume(Cone3D g) -> double
11057  """
11058  return _IMP_algebra.get_volume(*args)
11059 
11060 def get_cone_3d_geometry(g):
11061  r"""get_cone_3d_geometry(Cone3D g) -> Cone3D"""
11062  return _IMP_algebra.get_cone_3d_geometry(g)
11063 
11064 def write_pts(vs, out):
11065  r"""write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
11066  return _IMP_algebra.write_pts(vs, out)
11067 
11068 def read_pts(input):
11069  r"""read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
11070  return _IMP_algebra.read_pts(input)
11071 
11072 def write_spheres(vs, out):
11073  r"""write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
11074  return _IMP_algebra.write_spheres(vs, out)
11075 
11076 def read_spheres(input):
11077  r"""read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
11078  return _IMP_algebra.read_spheres(input)
11079 
11081  r"""get_random_vector_on_unit_sphere() -> Vector3D"""
11082  return _IMP_algebra.get_random_vector_on_unit_sphere()
11083 
11084 def get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle):
11085  r"""get_grid_surface_cover(Cylinder3D cyl, int number_of_cycles, int number_of_points_on_cycle) -> IMP::algebra::Vector3Ds"""
11086  return _IMP_algebra.get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle)
11087 
11088 def get_random_chain(*args):
11089  r"""get_random_chain(unsigned int n, double r, Vector3D start=IMP::algebra::Vector3D(0, 0, 0), IMP::algebra::Sphere3Ds const & obstacles=IMP::algebra::Sphere3Ds()) -> IMP::algebra::Vector3Ds"""
11090  return _IMP_algebra.get_random_chain(*args)
11091 
11092 def reversed_read(dest, size, nitems, f, reverse):
11093  r"""reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
11094  return _IMP_algebra.reversed_read(dest, size, nitems, f, reverse)
11095 
11096 def reversed_write(src, size, nitems, f, reverse=False):
11097  r"""reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)"""
11098  return _IMP_algebra.reversed_write(src, size, nitems, f, reverse)
11099 
11100 def get_is_big_endian():
11101  r"""get_is_big_endian() -> bool"""
11102  return _IMP_algebra.get_is_big_endian()
11103 
11104 def get_is_little_endian():
11105  r"""get_is_little_endian() -> bool"""
11106  return _IMP_algebra.get_is_little_endian()
11107 
11108 def get_shortest_segment(*args):
11109  r"""
11110  get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
11111  get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
11112  """
11113  return _IMP_algebra.get_shortest_segment(*args)
11114 class DynamicNearestNeighbor3D(IMP.Object):
11115  r"""Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class."""
11116 
11117  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11118 
11119  def __init__(self, vs, query_estimate=1):
11120  r"""__init__(DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D"""
11121  _IMP_algebra.DynamicNearestNeighbor3D_swiginit(self, _IMP_algebra.new_DynamicNearestNeighbor3D(vs, query_estimate))
11122 
11123  def get_in_ball(self, id, distance):
11124  r"""get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
11125  return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, id, distance)
11126 
11127  def set_coordinates(self, id, nc):
11128  r"""set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
11129  return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, id, nc)
11130 
11131  def get_version_info(self):
11132  r"""get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
11133  return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)
11134  __swig_destroy__ = _IMP_algebra.delete_DynamicNearestNeighbor3D
11135 
11136  def __str__(self):
11137  r"""__str__(DynamicNearestNeighbor3D self) -> std::string"""
11138  return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)
11139 
11140  def __repr__(self):
11141  r"""__repr__(DynamicNearestNeighbor3D self) -> std::string"""
11142  return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)
11143 
11144  @staticmethod
11145  def get_from(o):
11146  return _object_cast_to_DynamicNearestNeighbor3D(o)
11147 
11148 
11149 # Register DynamicNearestNeighbor3D in _IMP_algebra:
11150 _IMP_algebra.DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
11151 class VectorKDMetric(IMP.Object):
11152  r"""Proxy of C++ IMP::algebra::VectorKDMetric class."""
11153 
11154  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11155 
11156  def __init__(self, name):
11157  r"""__init__(VectorKDMetric self, std::string name) -> VectorKDMetric"""
11158  if self.__class__ == VectorKDMetric:
11159  _self = None
11160  else:
11161  _self = self
11162  _IMP_algebra.VectorKDMetric_swiginit(self, _IMP_algebra.new_VectorKDMetric(_self, name))
11163 
11164  if self.__class__ != VectorKDMetric:
11165  _director_objects.register(self)
11166 
11167 
11168 
11169 
11170  def get_distance(self, a, b):
11171  r"""get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
11172  return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)
11173 
11174  def get_centroid(self, vs):
11175  r"""get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
11176  return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)
11177 
11178  def __str__(self):
11179  r"""__str__(VectorKDMetric self) -> std::string"""
11180  return _IMP_algebra.VectorKDMetric___str__(self)
11181 
11182  def __repr__(self):
11183  r"""__repr__(VectorKDMetric self) -> std::string"""
11184  return _IMP_algebra.VectorKDMetric___repr__(self)
11185 
11186  @staticmethod
11187  def get_from(o):
11188  return _object_cast_to_VectorKDMetric(o)
11189 
11190 
11191  def get_type_name(self):
11192  return self.__class__.__name__
11193  def do_show(self, out):
11194  pass
11195  def get_version_info(self):
11196  if"IMP::algebra" == "IMP":
11197  return VersionInfo(self.__module__,
11198  __import__(self.__module__).get_module_version())
11199  else:
11200  return IMP.VersionInfo(self.__module__,
11201  __import__(self.__module__).get_module_version())
11202  @staticmethod
11203  def get_from(o):
11204  return _object_cast_to_VectorKDMetric(o)
11205 
11206  __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
11207  def __disown__(self):
11208  self.this.disown()
11209  _IMP_algebra.disown_VectorKDMetric(self)
11210  return weakref.proxy(self)
11211 
11212  def do_destroy(self):
11213  r"""do_destroy(VectorKDMetric self)"""
11214  return _IMP_algebra.VectorKDMetric_do_destroy(self)
11215 
11216 # Register VectorKDMetric in _IMP_algebra:
11217 _IMP_algebra.VectorKDMetric_swigregister(VectorKDMetric)
11218 class EuclideanVectorKDMetric(VectorKDMetric):
11219  r"""Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class."""
11220 
11221  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11222 
11223  def __init__(self, *args):
11224  r"""__init__(EuclideanVectorKDMetric self, std::string name="EuclideanVectorKDMetric%1%") -> EuclideanVectorKDMetric"""
11225  _IMP_algebra.EuclideanVectorKDMetric_swiginit(self, _IMP_algebra.new_EuclideanVectorKDMetric(*args))
11226 
11227  def get_version_info(self):
11228  r"""get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
11229  return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)
11230  __swig_destroy__ = _IMP_algebra.delete_EuclideanVectorKDMetric
11231 
11232  def __str__(self):
11233  r"""__str__(EuclideanVectorKDMetric self) -> std::string"""
11234  return _IMP_algebra.EuclideanVectorKDMetric___str__(self)
11235 
11236  def __repr__(self):
11237  r"""__repr__(EuclideanVectorKDMetric self) -> std::string"""
11238  return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)
11239 
11240  @staticmethod
11241  def get_from(o):
11242  return _object_cast_to_EuclideanVectorKDMetric(o)
11243 
11244 
11245  def _get_as_binary(self):
11246  r"""_get_as_binary(EuclideanVectorKDMetric self) -> PyObject *"""
11247  return _IMP_algebra.EuclideanVectorKDMetric__get_as_binary(self)
11248 
11249  def _set_from_binary(self, p):
11250  r"""_set_from_binary(EuclideanVectorKDMetric self, PyObject * p)"""
11251  return _IMP_algebra.EuclideanVectorKDMetric__set_from_binary(self, p)
11252 
11253  def __getstate__(self):
11254  p = self._get_as_binary()
11255  if len(self.__dict__) > 1:
11256  d = self.__dict__.copy()
11257  del d['this']
11258  p = (d, p)
11259  return p
11260 
11261  def __setstate__(self, p):
11262  if not hasattr(self, 'this'):
11263  self.__init__()
11264  if isinstance(p, tuple):
11265  d, p = p
11266  self.__dict__.update(d)
11267  return self._set_from_binary(p)
11268 
11269 
11270 # Register EuclideanVectorKDMetric in _IMP_algebra:
11271 _IMP_algebra.EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
11272 class MaxVectorKDMetric(VectorKDMetric):
11273  r"""Proxy of C++ IMP::algebra::MaxVectorKDMetric class."""
11274 
11275  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11276 
11277  def __init__(self, *args):
11278  r"""__init__(MaxVectorKDMetric self, std::string name="MaxVectorKDMetric%1%") -> MaxVectorKDMetric"""
11279  _IMP_algebra.MaxVectorKDMetric_swiginit(self, _IMP_algebra.new_MaxVectorKDMetric(*args))
11280 
11281  def get_version_info(self):
11282  r"""get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
11283  return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)
11284  __swig_destroy__ = _IMP_algebra.delete_MaxVectorKDMetric
11285 
11286  def __str__(self):
11287  r"""__str__(MaxVectorKDMetric self) -> std::string"""
11288  return _IMP_algebra.MaxVectorKDMetric___str__(self)
11289 
11290  def __repr__(self):
11291  r"""__repr__(MaxVectorKDMetric self) -> std::string"""
11292  return _IMP_algebra.MaxVectorKDMetric___repr__(self)
11293 
11294  @staticmethod
11295  def get_from(o):
11296  return _object_cast_to_MaxVectorKDMetric(o)
11297 
11298 
11299  def _get_as_binary(self):
11300  r"""_get_as_binary(MaxVectorKDMetric self) -> PyObject *"""
11301  return _IMP_algebra.MaxVectorKDMetric__get_as_binary(self)
11302 
11303  def _set_from_binary(self, p):
11304  r"""_set_from_binary(MaxVectorKDMetric self, PyObject * p)"""
11305  return _IMP_algebra.MaxVectorKDMetric__set_from_binary(self, p)
11306 
11307  def __getstate__(self):
11308  p = self._get_as_binary()
11309  if len(self.__dict__) > 1:
11310  d = self.__dict__.copy()
11311  del d['this']
11312  p = (d, p)
11313  return p
11314 
11315  def __setstate__(self, p):
11316  if not hasattr(self, 'this'):
11317  self.__init__()
11318  if isinstance(p, tuple):
11319  d, p = p
11320  self.__dict__.update(d)
11321  return self._set_from_binary(p)
11322 
11323 
11324 # Register MaxVectorKDMetric in _IMP_algebra:
11325 _IMP_algebra.MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
11326 class Gaussian3D(_GeometricPrimitive3D):
11327  r"""Proxy of C++ IMP::algebra::Gaussian3D class."""
11328 
11329  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11330 
11331  def __init__(self, *args):
11332  r"""
11333  __init__(Gaussian3D self) -> Gaussian3D
11334  __init__(Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
11335  """
11336  _IMP_algebra.Gaussian3D_swiginit(self, _IMP_algebra.new_Gaussian3D(*args))
11337 
11338  def get_reference_frame(self):
11339  r"""get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
11340  return _IMP_algebra.Gaussian3D_get_reference_frame(self)
11341 
11342  def get_variances(self):
11343  r"""get_variances(Gaussian3D self) -> Vector3D"""
11344  return _IMP_algebra.Gaussian3D_get_variances(self)
11345 
11346  def get_center(self):
11347  r"""get_center(Gaussian3D self) -> Vector3D"""
11348  return _IMP_algebra.Gaussian3D_get_center(self)
11349 
11350  def show(self, *args):
11351  r"""show(Gaussian3D self, _ostream out=std::cout)"""
11352  return _IMP_algebra.Gaussian3D_show(self, *args)
11353 
11354  def __str__(self):
11355  r"""__str__(Gaussian3D self) -> std::string"""
11356  return _IMP_algebra.Gaussian3D___str__(self)
11357 
11358  def __repr__(self):
11359  r"""__repr__(Gaussian3D self) -> std::string"""
11360  return _IMP_algebra.Gaussian3D___repr__(self)
11361 
11362  def _get_as_binary(self):
11363  r"""_get_as_binary(Gaussian3D self) -> PyObject *"""
11364  return _IMP_algebra.Gaussian3D__get_as_binary(self)
11365 
11366  def _set_from_binary(self, p):
11367  r"""_set_from_binary(Gaussian3D self, PyObject * p)"""
11368  return _IMP_algebra.Gaussian3D__set_from_binary(self, p)
11369 
11370  def __getstate__(self):
11371  p = self._get_as_binary()
11372  if len(self.__dict__) > 1:
11373  d = self.__dict__.copy()
11374  del d['this']
11375  p = (d, p)
11376  return p
11377 
11378  def __setstate__(self, p):
11379  if not hasattr(self, 'this'):
11380  self.__init__()
11381  if isinstance(p, tuple):
11382  d, p = p
11383  self.__dict__.update(d)
11384  return self._set_from_binary(p)
11385 
11386  __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
11387 
11388 # Register Gaussian3D in _IMP_algebra:
11389 _IMP_algebra.Gaussian3D_swigregister(Gaussian3D)
11390 
11391 def get_covariance(g):
11392  r"""get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
11393  return _IMP_algebra.get_covariance(g)
11394 
11395 def get_gaussian_from_covariance(covariance, center):
11396  r"""get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
11397  return _IMP_algebra.get_gaussian_from_covariance(covariance, center)
11398 
11399 def get_rasterized(gmm, weights, cell_width, bb):
11400  r"""get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D"""
11401  return _IMP_algebra.get_rasterized(gmm, weights, cell_width, bb)
11402 
11403 def get_rasterized_fast(gmm, weights, cell_width, bb, factor=2.5):
11404  r"""get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb, double factor=2.5) -> DenseDoubleGrid3D"""
11405  return _IMP_algebra.get_rasterized_fast(gmm, weights, cell_width, bb, factor)
11406 
11407 def _pass_matrix_xf(m):
11408  r"""_pass_matrix_xf(Eigen::MatrixXf const & m) -> Eigen::MatrixXf"""
11409  return _IMP_algebra._pass_matrix_xf(m)
11410 
11411 def _pass_matrix_xd(m):
11412  r"""_pass_matrix_xd(Eigen::MatrixXd const & m) -> Eigen::MatrixXd"""
11413  return _IMP_algebra._pass_matrix_xd(m)
11414 
11415 def _pass_matrix_3d(m):
11416  r"""_pass_matrix_3d(Eigen::Matrix3d const & m) -> Eigen::Matrix3d"""
11417  return _IMP_algebra._pass_matrix_3d(m)
11418 
11419 def _pass_array_xd(m):
11420  r"""_pass_array_xd(Eigen::ArrayXXd const & m) -> Eigen::ArrayXXd"""
11421  return _IMP_algebra._pass_array_xd(m)
11422 
11423 def _pass_vector_xd(m):
11424  r"""_pass_vector_xd(Eigen::VectorXd const & m) -> Eigen::VectorXd"""
11425  return _IMP_algebra._pass_vector_xd(m)
11426 class NearestNeighbor1D(IMP.Object):
11427  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 1 > class."""
11428 
11429  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11430 
11431  def __init__(self, vs, epsilon=0):
11432  r"""__init__(NearestNeighbor1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D"""
11433  _IMP_algebra.NearestNeighbor1D_swiginit(self, _IMP_algebra.new_NearestNeighbor1D(vs, epsilon))
11434 
11435  def set_query_log(self, fname):
11436  r"""set_query_log(NearestNeighbor1D self, std::string fname)"""
11437  return _IMP_algebra.NearestNeighbor1D_set_query_log(self, fname)
11438 
11439  def get_nearest_neighbor(self, *args):
11440  r"""
11441  get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
11442  get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
11443  """
11444  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)
11445 
11446  def get_nearest_neighbors(self, *args):
11447  r"""
11448  get_nearest_neighbors(NearestNeighbor1D self, unsigned int i, unsigned int k) -> IMP::Ints
11449  get_nearest_neighbors(NearestNeighbor1D self, Vector1D v, unsigned int k) -> IMP::Ints
11450  """
11451  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)
11452 
11453  def get_in_ball(self, *args):
11454  r"""
11455  get_in_ball(NearestNeighbor1D self, unsigned int i, double distance) -> IMP::Ints
11456  get_in_ball(NearestNeighbor1D self, Vector1D pt, double distance) -> IMP::Ints
11457  """
11458  return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)
11459 
11460  def get_version_info(self):
11461  r"""get_version_info(NearestNeighbor1D self) -> VersionInfo"""
11462  return _IMP_algebra.NearestNeighbor1D_get_version_info(self)
11463  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor1D
11464 
11465  def __str__(self):
11466  r"""__str__(NearestNeighbor1D self) -> std::string"""
11467  return _IMP_algebra.NearestNeighbor1D___str__(self)
11468 
11469  def __repr__(self):
11470  r"""__repr__(NearestNeighbor1D self) -> std::string"""
11471  return _IMP_algebra.NearestNeighbor1D___repr__(self)
11472 
11473  @staticmethod
11474  def get_from(o):
11475  return _object_cast_to_NearestNeighborD(o)
11476 
11477 
11478 # Register NearestNeighbor1D in _IMP_algebra:
11479 _IMP_algebra.NearestNeighbor1D_swigregister(NearestNeighbor1D)
11480 class NearestNeighbor2D(IMP.Object):
11481  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 2 > class."""
11482 
11483  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11484 
11485  def __init__(self, vs, epsilon=0):
11486  r"""__init__(NearestNeighbor2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D"""
11487  _IMP_algebra.NearestNeighbor2D_swiginit(self, _IMP_algebra.new_NearestNeighbor2D(vs, epsilon))
11488 
11489  def set_query_log(self, fname):
11490  r"""set_query_log(NearestNeighbor2D self, std::string fname)"""
11491  return _IMP_algebra.NearestNeighbor2D_set_query_log(self, fname)
11492 
11493  def get_nearest_neighbor(self, *args):
11494  r"""
11495  get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
11496  get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
11497  """
11498  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)
11499 
11500  def get_nearest_neighbors(self, *args):
11501  r"""
11502  get_nearest_neighbors(NearestNeighbor2D self, unsigned int i, unsigned int k) -> IMP::Ints
11503  get_nearest_neighbors(NearestNeighbor2D self, Vector2D v, unsigned int k) -> IMP::Ints
11504  """
11505  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)
11506 
11507  def get_in_ball(self, *args):
11508  r"""
11509  get_in_ball(NearestNeighbor2D self, unsigned int i, double distance) -> IMP::Ints
11510  get_in_ball(NearestNeighbor2D self, Vector2D pt, double distance) -> IMP::Ints
11511  """
11512  return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)
11513 
11514  def get_version_info(self):
11515  r"""get_version_info(NearestNeighbor2D self) -> VersionInfo"""
11516  return _IMP_algebra.NearestNeighbor2D_get_version_info(self)
11517  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor2D
11518 
11519  def __str__(self):
11520  r"""__str__(NearestNeighbor2D self) -> std::string"""
11521  return _IMP_algebra.NearestNeighbor2D___str__(self)
11522 
11523  def __repr__(self):
11524  r"""__repr__(NearestNeighbor2D self) -> std::string"""
11525  return _IMP_algebra.NearestNeighbor2D___repr__(self)
11526 
11527  @staticmethod
11528  def get_from(o):
11529  return _object_cast_to_NearestNeighborD(o)
11530 
11531 
11532 # Register NearestNeighbor2D in _IMP_algebra:
11533 _IMP_algebra.NearestNeighbor2D_swigregister(NearestNeighbor2D)
11534 class NearestNeighbor3D(IMP.Object):
11535  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 3 > class."""
11536 
11537  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11538 
11539  def __init__(self, vs, epsilon=0):
11540  r"""__init__(NearestNeighbor3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D"""
11541  _IMP_algebra.NearestNeighbor3D_swiginit(self, _IMP_algebra.new_NearestNeighbor3D(vs, epsilon))
11542 
11543  def set_query_log(self, fname):
11544  r"""set_query_log(NearestNeighbor3D self, std::string fname)"""
11545  return _IMP_algebra.NearestNeighbor3D_set_query_log(self, fname)
11546 
11547  def get_nearest_neighbor(self, *args):
11548  r"""
11549  get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
11550  get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
11551  """
11552  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)
11553 
11554  def get_nearest_neighbors(self, *args):
11555  r"""
11556  get_nearest_neighbors(NearestNeighbor3D self, unsigned int i, unsigned int k) -> IMP::Ints
11557  get_nearest_neighbors(NearestNeighbor3D self, Vector3D v, unsigned int k) -> IMP::Ints
11558  """
11559  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)
11560 
11561  def get_in_ball(self, *args):
11562  r"""
11563  get_in_ball(NearestNeighbor3D self, unsigned int i, double distance) -> IMP::Ints
11564  get_in_ball(NearestNeighbor3D self, Vector3D pt, double distance) -> IMP::Ints
11565  """
11566  return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)
11567 
11568  def get_version_info(self):
11569  r"""get_version_info(NearestNeighbor3D self) -> VersionInfo"""
11570  return _IMP_algebra.NearestNeighbor3D_get_version_info(self)
11571  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor3D
11572 
11573  def __str__(self):
11574  r"""__str__(NearestNeighbor3D self) -> std::string"""
11575  return _IMP_algebra.NearestNeighbor3D___str__(self)
11576 
11577  def __repr__(self):
11578  r"""__repr__(NearestNeighbor3D self) -> std::string"""
11579  return _IMP_algebra.NearestNeighbor3D___repr__(self)
11580 
11581  @staticmethod
11582  def get_from(o):
11583  return _object_cast_to_NearestNeighborD(o)
11584 
11585 
11586 # Register NearestNeighbor3D in _IMP_algebra:
11587 _IMP_algebra.NearestNeighbor3D_swigregister(NearestNeighbor3D)
11588 class NearestNeighbor4D(IMP.Object):
11589  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 4 > class."""
11590 
11591  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11592 
11593  def __init__(self, vs, epsilon=0):
11594  r"""__init__(NearestNeighbor4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D"""
11595  _IMP_algebra.NearestNeighbor4D_swiginit(self, _IMP_algebra.new_NearestNeighbor4D(vs, epsilon))
11596 
11597  def set_query_log(self, fname):
11598  r"""set_query_log(NearestNeighbor4D self, std::string fname)"""
11599  return _IMP_algebra.NearestNeighbor4D_set_query_log(self, fname)
11600 
11601  def get_nearest_neighbor(self, *args):
11602  r"""
11603  get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
11604  get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
11605  """
11606  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)
11607 
11608  def get_nearest_neighbors(self, *args):
11609  r"""
11610  get_nearest_neighbors(NearestNeighbor4D self, unsigned int i, unsigned int k) -> IMP::Ints
11611  get_nearest_neighbors(NearestNeighbor4D self, Vector4D v, unsigned int k) -> IMP::Ints
11612  """
11613  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)
11614 
11615  def get_in_ball(self, *args):
11616  r"""
11617  get_in_ball(NearestNeighbor4D self, unsigned int i, double distance) -> IMP::Ints
11618  get_in_ball(NearestNeighbor4D self, Vector4D pt, double distance) -> IMP::Ints
11619  """
11620  return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)
11621 
11622  def get_version_info(self):
11623  r"""get_version_info(NearestNeighbor4D self) -> VersionInfo"""
11624  return _IMP_algebra.NearestNeighbor4D_get_version_info(self)
11625  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor4D
11626 
11627  def __str__(self):
11628  r"""__str__(NearestNeighbor4D self) -> std::string"""
11629  return _IMP_algebra.NearestNeighbor4D___str__(self)
11630 
11631  def __repr__(self):
11632  r"""__repr__(NearestNeighbor4D self) -> std::string"""
11633  return _IMP_algebra.NearestNeighbor4D___repr__(self)
11634 
11635  @staticmethod
11636  def get_from(o):
11637  return _object_cast_to_NearestNeighborD(o)
11638 
11639 
11640 # Register NearestNeighbor4D in _IMP_algebra:
11641 _IMP_algebra.NearestNeighbor4D_swigregister(NearestNeighbor4D)
11642 class NearestNeighbor5D(IMP.Object):
11643  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 5 > class."""
11644 
11645  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11646 
11647  def __init__(self, vs, epsilon=0):
11648  r"""__init__(NearestNeighbor5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D"""
11649  _IMP_algebra.NearestNeighbor5D_swiginit(self, _IMP_algebra.new_NearestNeighbor5D(vs, epsilon))
11650 
11651  def set_query_log(self, fname):
11652  r"""set_query_log(NearestNeighbor5D self, std::string fname)"""
11653  return _IMP_algebra.NearestNeighbor5D_set_query_log(self, fname)
11654 
11655  def get_nearest_neighbor(self, *args):
11656  r"""
11657  get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
11658  get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
11659  """
11660  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)
11661 
11662  def get_nearest_neighbors(self, *args):
11663  r"""
11664  get_nearest_neighbors(NearestNeighbor5D self, unsigned int i, unsigned int k) -> IMP::Ints
11665  get_nearest_neighbors(NearestNeighbor5D self, Vector5D v, unsigned int k) -> IMP::Ints
11666  """
11667  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)
11668 
11669  def get_in_ball(self, *args):
11670  r"""
11671  get_in_ball(NearestNeighbor5D self, unsigned int i, double distance) -> IMP::Ints
11672  get_in_ball(NearestNeighbor5D self, Vector5D pt, double distance) -> IMP::Ints
11673  """
11674  return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)
11675 
11676  def get_version_info(self):
11677  r"""get_version_info(NearestNeighbor5D self) -> VersionInfo"""
11678  return _IMP_algebra.NearestNeighbor5D_get_version_info(self)
11679  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor5D
11680 
11681  def __str__(self):
11682  r"""__str__(NearestNeighbor5D self) -> std::string"""
11683  return _IMP_algebra.NearestNeighbor5D___str__(self)
11684 
11685  def __repr__(self):
11686  r"""__repr__(NearestNeighbor5D self) -> std::string"""
11687  return _IMP_algebra.NearestNeighbor5D___repr__(self)
11688 
11689  @staticmethod
11690  def get_from(o):
11691  return _object_cast_to_NearestNeighborD(o)
11692 
11693 
11694 # Register NearestNeighbor5D in _IMP_algebra:
11695 _IMP_algebra.NearestNeighbor5D_swigregister(NearestNeighbor5D)
11696 class NearestNeighbor6D(IMP.Object):
11697  r"""Proxy of C++ IMP::algebra::NearestNeighborD< 6 > class."""
11698 
11699  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11700 
11701  def __init__(self, vs, epsilon=0):
11702  r"""__init__(NearestNeighbor6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D"""
11703  _IMP_algebra.NearestNeighbor6D_swiginit(self, _IMP_algebra.new_NearestNeighbor6D(vs, epsilon))
11704 
11705  def set_query_log(self, fname):
11706  r"""set_query_log(NearestNeighbor6D self, std::string fname)"""
11707  return _IMP_algebra.NearestNeighbor6D_set_query_log(self, fname)
11708 
11709  def get_nearest_neighbor(self, *args):
11710  r"""
11711  get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
11712  get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
11713  """
11714  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)
11715 
11716  def get_nearest_neighbors(self, *args):
11717  r"""
11718  get_nearest_neighbors(NearestNeighbor6D self, unsigned int i, unsigned int k) -> IMP::Ints
11719  get_nearest_neighbors(NearestNeighbor6D self, Vector6D v, unsigned int k) -> IMP::Ints
11720  """
11721  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)
11722 
11723  def get_in_ball(self, *args):
11724  r"""
11725  get_in_ball(NearestNeighbor6D self, unsigned int i, double distance) -> IMP::Ints
11726  get_in_ball(NearestNeighbor6D self, Vector6D pt, double distance) -> IMP::Ints
11727  """
11728  return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)
11729 
11730  def get_version_info(self):
11731  r"""get_version_info(NearestNeighbor6D self) -> VersionInfo"""
11732  return _IMP_algebra.NearestNeighbor6D_get_version_info(self)
11733  __swig_destroy__ = _IMP_algebra.delete_NearestNeighbor6D
11734 
11735  def __str__(self):
11736  r"""__str__(NearestNeighbor6D self) -> std::string"""
11737  return _IMP_algebra.NearestNeighbor6D___str__(self)
11738 
11739  def __repr__(self):
11740  r"""__repr__(NearestNeighbor6D self) -> std::string"""
11741  return _IMP_algebra.NearestNeighbor6D___repr__(self)
11742 
11743  @staticmethod
11744  def get_from(o):
11745  return _object_cast_to_NearestNeighborD(o)
11746 
11747 
11748 # Register NearestNeighbor6D in _IMP_algebra:
11749 _IMP_algebra.NearestNeighbor6D_swigregister(NearestNeighbor6D)
11750 class NearestNeighborKD(IMP.Object):
11751  r"""Proxy of C++ IMP::algebra::NearestNeighborD< -1 > class."""
11752 
11753  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11754 
11755  def __init__(self, vs, epsilon=0):
11756  r"""__init__(NearestNeighborKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD"""
11757  _IMP_algebra.NearestNeighborKD_swiginit(self, _IMP_algebra.new_NearestNeighborKD(vs, epsilon))
11758 
11759  def set_query_log(self, fname):
11760  r"""set_query_log(NearestNeighborKD self, std::string fname)"""
11761  return _IMP_algebra.NearestNeighborKD_set_query_log(self, fname)
11762 
11763  def get_nearest_neighbor(self, *args):
11764  r"""
11765  get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
11766  get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
11767  """
11768  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)
11769 
11770  def get_nearest_neighbors(self, *args):
11771  r"""
11772  get_nearest_neighbors(NearestNeighborKD self, unsigned int i, unsigned int k) -> IMP::Ints
11773  get_nearest_neighbors(NearestNeighborKD self, VectorKD v, unsigned int k) -> IMP::Ints
11774  """
11775  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)
11776 
11777  def get_in_ball(self, *args):
11778  r"""
11779  get_in_ball(NearestNeighborKD self, unsigned int i, double distance) -> IMP::Ints
11780  get_in_ball(NearestNeighborKD self, VectorKD pt, double distance) -> IMP::Ints
11781  """
11782  return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)
11783 
11784  def get_version_info(self):
11785  r"""get_version_info(NearestNeighborKD self) -> VersionInfo"""
11786  return _IMP_algebra.NearestNeighborKD_get_version_info(self)
11787  __swig_destroy__ = _IMP_algebra.delete_NearestNeighborKD
11788 
11789  def __str__(self):
11790  r"""__str__(NearestNeighborKD self) -> std::string"""
11791  return _IMP_algebra.NearestNeighborKD___str__(self)
11792 
11793  def __repr__(self):
11794  r"""__repr__(NearestNeighborKD self) -> std::string"""
11795  return _IMP_algebra.NearestNeighborKD___repr__(self)
11796 
11797  @staticmethod
11798  def get_from(o):
11799  return _object_cast_to_NearestNeighborD(o)
11800 
11801 
11802 # Register NearestNeighborKD in _IMP_algebra:
11803 _IMP_algebra.NearestNeighborKD_swigregister(NearestNeighborKD)
11804 
11805 def get_transformation_aligning_pair(set_from, set_to):
11806  r"""get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
11807  return _IMP_algebra.get_transformation_aligning_pair(set_from, set_to)
11808 class PrincipalComponentAnalysis1D(_GeometricPrimitive1D):
11809  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 1 > class."""
11810 
11811  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11812 
11813  def __init__(self, *args):
11814  r"""
11815  __init__(PrincipalComponentAnalysis1D self) -> PrincipalComponentAnalysis1D
11816  __init__(PrincipalComponentAnalysis1D self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
11817  """
11818  _IMP_algebra.PrincipalComponentAnalysis1D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis1D(*args))
11819 
11820  def get_principal_components(self):
11821  r"""get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
11822  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)
11823 
11824  def get_principal_component(self, i):
11825  r"""get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
11826  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, i)
11827 
11828  def get_principal_values(self):
11829  r"""get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
11830  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)
11831 
11832  def get_principal_value(self, i):
11833  r"""get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
11834  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, i)
11835 
11836  def get_centroid(self):
11837  r"""get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
11838  return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)
11839 
11840  def set_centroid(self, cntr):
11841  r"""set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
11842  return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)
11843 
11844  def show(self, *args):
11845  r"""show(PrincipalComponentAnalysis1D self, _ostream out=std::cout)"""
11846  return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)
11847 
11848  def __cmp__(self, o):
11849  r"""__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
11850  return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, o)
11851 
11852  def __eq__(self, o):
11853  r"""__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11854  return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)
11855 
11856  def __ne__(self, o):
11857  r"""__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11858  return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)
11859 
11860  def __lt__(self, o):
11861  r"""__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11862  return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)
11863 
11864  def __gt__(self, o):
11865  r"""__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11866  return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)
11867 
11868  def __ge__(self, o):
11869  r"""__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11870  return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)
11871 
11872  def __le__(self, o):
11873  r"""__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
11874  return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)
11875 
11876  def __str__(self):
11877  r"""__str__(PrincipalComponentAnalysis1D self) -> std::string"""
11878  return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)
11879 
11880  def __repr__(self):
11881  r"""__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
11882  return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)
11883 
11884  def _get_as_binary(self):
11885  r"""_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
11886  return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)
11887 
11888  def _set_from_binary(self, p):
11889  r"""_set_from_binary(PrincipalComponentAnalysis1D self, PyObject * p)"""
11890  return _IMP_algebra.PrincipalComponentAnalysis1D__set_from_binary(self, p)
11891 
11892  def __getstate__(self):
11893  p = self._get_as_binary()
11894  if len(self.__dict__) > 1:
11895  d = self.__dict__.copy()
11896  del d['this']
11897  p = (d, p)
11898  return p
11899 
11900  def __setstate__(self, p):
11901  if not hasattr(self, 'this'):
11902  self.__init__()
11903  if isinstance(p, tuple):
11904  d, p = p
11905  self.__dict__.update(d)
11906  return self._set_from_binary(p)
11907 
11908  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
11909 
11910 # Register PrincipalComponentAnalysis1D in _IMP_algebra:
11911 _IMP_algebra.PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
11912 class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
11913  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 2 > class."""
11914 
11915  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
11916 
11917  def __init__(self, *args):
11918  r"""
11919  __init__(PrincipalComponentAnalysis2D self) -> PrincipalComponentAnalysis2D
11920  __init__(PrincipalComponentAnalysis2D self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
11921  """
11922  _IMP_algebra.PrincipalComponentAnalysis2D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis2D(*args))
11923 
11924  def get_principal_components(self):
11925  r"""get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
11926  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)
11927 
11928  def get_principal_component(self, i):
11929  r"""get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
11930  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, i)
11931 
11932  def get_principal_values(self):
11933  r"""get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
11934  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)
11935 
11936  def get_principal_value(self, i):
11937  r"""get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
11938  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, i)
11939 
11940  def get_centroid(self):
11941  r"""get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
11942  return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)
11943 
11944  def set_centroid(self, cntr):
11945  r"""set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
11946  return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)
11947 
11948  def show(self, *args):
11949  r"""show(PrincipalComponentAnalysis2D self, _ostream out=std::cout)"""
11950  return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)
11951 
11952  def __cmp__(self, o):
11953  r"""__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
11954  return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, o)
11955 
11956  def __eq__(self, o):
11957  r"""__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11958  return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)
11959 
11960  def __ne__(self, o):
11961  r"""__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11962  return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)
11963 
11964  def __lt__(self, o):
11965  r"""__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11966  return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)
11967 
11968  def __gt__(self, o):
11969  r"""__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11970  return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)
11971 
11972  def __ge__(self, o):
11973  r"""__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11974  return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)
11975 
11976  def __le__(self, o):
11977  r"""__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
11978  return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)
11979 
11980  def __str__(self):
11981  r"""__str__(PrincipalComponentAnalysis2D self) -> std::string"""
11982  return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)
11983 
11984  def __repr__(self):
11985  r"""__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
11986  return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)
11987 
11988  def _get_as_binary(self):
11989  r"""_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
11990  return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)
11991 
11992  def _set_from_binary(self, p):
11993  r"""_set_from_binary(PrincipalComponentAnalysis2D self, PyObject * p)"""
11994  return _IMP_algebra.PrincipalComponentAnalysis2D__set_from_binary(self, p)
11995 
11996  def __getstate__(self):
11997  p = self._get_as_binary()
11998  if len(self.__dict__) > 1:
11999  d = self.__dict__.copy()
12000  del d['this']
12001  p = (d, p)
12002  return p
12003 
12004  def __setstate__(self, p):
12005  if not hasattr(self, 'this'):
12006  self.__init__()
12007  if isinstance(p, tuple):
12008  d, p = p
12009  self.__dict__.update(d)
12010  return self._set_from_binary(p)
12011 
12012  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
12013 
12014 # Register PrincipalComponentAnalysis2D in _IMP_algebra:
12015 _IMP_algebra.PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
12016 class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
12017  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 3 > class."""
12018 
12019  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12020 
12021  def __init__(self, *args):
12022  r"""
12023  __init__(PrincipalComponentAnalysis3D self) -> PrincipalComponentAnalysis3D
12024  __init__(PrincipalComponentAnalysis3D self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
12025  """
12026  _IMP_algebra.PrincipalComponentAnalysis3D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis3D(*args))
12027 
12028  def get_principal_components(self):
12029  r"""get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
12030  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)
12031 
12032  def get_principal_component(self, i):
12033  r"""get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
12034  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, i)
12035 
12036  def get_principal_values(self):
12037  r"""get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
12038  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)
12039 
12040  def get_principal_value(self, i):
12041  r"""get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
12042  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, i)
12043 
12044  def get_centroid(self):
12045  r"""get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
12046  return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)
12047 
12048  def set_centroid(self, cntr):
12049  r"""set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
12050  return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)
12051 
12052  def show(self, *args):
12053  r"""show(PrincipalComponentAnalysis3D self, _ostream out=std::cout)"""
12054  return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)
12055 
12056  def __cmp__(self, o):
12057  r"""__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
12058  return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, o)
12059 
12060  def __eq__(self, o):
12061  r"""__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12062  return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)
12063 
12064  def __ne__(self, o):
12065  r"""__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12066  return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)
12067 
12068  def __lt__(self, o):
12069  r"""__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12070  return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)
12071 
12072  def __gt__(self, o):
12073  r"""__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12074  return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)
12075 
12076  def __ge__(self, o):
12077  r"""__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12078  return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)
12079 
12080  def __le__(self, o):
12081  r"""__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
12082  return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)
12083 
12084  def __str__(self):
12085  r"""__str__(PrincipalComponentAnalysis3D self) -> std::string"""
12086  return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)
12087 
12088  def __repr__(self):
12089  r"""__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
12090  return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)
12091 
12092  def _get_as_binary(self):
12093  r"""_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
12094  return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)
12095 
12096  def _set_from_binary(self, p):
12097  r"""_set_from_binary(PrincipalComponentAnalysis3D self, PyObject * p)"""
12098  return _IMP_algebra.PrincipalComponentAnalysis3D__set_from_binary(self, p)
12099 
12100  def __getstate__(self):
12101  p = self._get_as_binary()
12102  if len(self.__dict__) > 1:
12103  d = self.__dict__.copy()
12104  del d['this']
12105  p = (d, p)
12106  return p
12107 
12108  def __setstate__(self, p):
12109  if not hasattr(self, 'this'):
12110  self.__init__()
12111  if isinstance(p, tuple):
12112  d, p = p
12113  self.__dict__.update(d)
12114  return self._set_from_binary(p)
12115 
12116  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
12117 
12118 # Register PrincipalComponentAnalysis3D in _IMP_algebra:
12119 _IMP_algebra.PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
12120 class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
12121  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 4 > class."""
12122 
12123  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12124 
12125  def __init__(self, *args):
12126  r"""
12127  __init__(PrincipalComponentAnalysis4D self) -> PrincipalComponentAnalysis4D
12128  __init__(PrincipalComponentAnalysis4D self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
12129  """
12130  _IMP_algebra.PrincipalComponentAnalysis4D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis4D(*args))
12131 
12132  def get_principal_components(self):
12133  r"""get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
12134  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)
12135 
12136  def get_principal_component(self, i):
12137  r"""get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
12138  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, i)
12139 
12140  def get_principal_values(self):
12141  r"""get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
12142  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)
12143 
12144  def get_principal_value(self, i):
12145  r"""get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
12146  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, i)
12147 
12148  def get_centroid(self):
12149  r"""get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
12150  return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)
12151 
12152  def set_centroid(self, cntr):
12153  r"""set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
12154  return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)
12155 
12156  def show(self, *args):
12157  r"""show(PrincipalComponentAnalysis4D self, _ostream out=std::cout)"""
12158  return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)
12159 
12160  def __cmp__(self, o):
12161  r"""__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
12162  return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, o)
12163 
12164  def __eq__(self, o):
12165  r"""__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12166  return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)
12167 
12168  def __ne__(self, o):
12169  r"""__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12170  return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)
12171 
12172  def __lt__(self, o):
12173  r"""__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12174  return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)
12175 
12176  def __gt__(self, o):
12177  r"""__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12178  return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)
12179 
12180  def __ge__(self, o):
12181  r"""__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12182  return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)
12183 
12184  def __le__(self, o):
12185  r"""__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
12186  return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)
12187 
12188  def __str__(self):
12189  r"""__str__(PrincipalComponentAnalysis4D self) -> std::string"""
12190  return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)
12191 
12192  def __repr__(self):
12193  r"""__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
12194  return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)
12195 
12196  def _get_as_binary(self):
12197  r"""_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
12198  return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)
12199 
12200  def _set_from_binary(self, p):
12201  r"""_set_from_binary(PrincipalComponentAnalysis4D self, PyObject * p)"""
12202  return _IMP_algebra.PrincipalComponentAnalysis4D__set_from_binary(self, p)
12203 
12204  def __getstate__(self):
12205  p = self._get_as_binary()
12206  if len(self.__dict__) > 1:
12207  d = self.__dict__.copy()
12208  del d['this']
12209  p = (d, p)
12210  return p
12211 
12212  def __setstate__(self, p):
12213  if not hasattr(self, 'this'):
12214  self.__init__()
12215  if isinstance(p, tuple):
12216  d, p = p
12217  self.__dict__.update(d)
12218  return self._set_from_binary(p)
12219 
12220  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
12221 
12222 # Register PrincipalComponentAnalysis4D in _IMP_algebra:
12223 _IMP_algebra.PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
12224 class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
12225  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 5 > class."""
12226 
12227  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12228 
12229  def __init__(self, *args):
12230  r"""
12231  __init__(PrincipalComponentAnalysis5D self) -> PrincipalComponentAnalysis5D
12232  __init__(PrincipalComponentAnalysis5D self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
12233  """
12234  _IMP_algebra.PrincipalComponentAnalysis5D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis5D(*args))
12235 
12236  def get_principal_components(self):
12237  r"""get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
12238  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)
12239 
12240  def get_principal_component(self, i):
12241  r"""get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
12242  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, i)
12243 
12244  def get_principal_values(self):
12245  r"""get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
12246  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)
12247 
12248  def get_principal_value(self, i):
12249  r"""get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
12250  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, i)
12251 
12252  def get_centroid(self):
12253  r"""get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
12254  return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)
12255 
12256  def set_centroid(self, cntr):
12257  r"""set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
12258  return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)
12259 
12260  def show(self, *args):
12261  r"""show(PrincipalComponentAnalysis5D self, _ostream out=std::cout)"""
12262  return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)
12263 
12264  def __cmp__(self, o):
12265  r"""__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
12266  return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, o)
12267 
12268  def __eq__(self, o):
12269  r"""__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12270  return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)
12271 
12272  def __ne__(self, o):
12273  r"""__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12274  return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)
12275 
12276  def __lt__(self, o):
12277  r"""__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12278  return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)
12279 
12280  def __gt__(self, o):
12281  r"""__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12282  return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)
12283 
12284  def __ge__(self, o):
12285  r"""__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12286  return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)
12287 
12288  def __le__(self, o):
12289  r"""__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
12290  return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)
12291 
12292  def __str__(self):
12293  r"""__str__(PrincipalComponentAnalysis5D self) -> std::string"""
12294  return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)
12295 
12296  def __repr__(self):
12297  r"""__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
12298  return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)
12299 
12300  def _get_as_binary(self):
12301  r"""_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
12302  return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)
12303 
12304  def _set_from_binary(self, p):
12305  r"""_set_from_binary(PrincipalComponentAnalysis5D self, PyObject * p)"""
12306  return _IMP_algebra.PrincipalComponentAnalysis5D__set_from_binary(self, p)
12307 
12308  def __getstate__(self):
12309  p = self._get_as_binary()
12310  if len(self.__dict__) > 1:
12311  d = self.__dict__.copy()
12312  del d['this']
12313  p = (d, p)
12314  return p
12315 
12316  def __setstate__(self, p):
12317  if not hasattr(self, 'this'):
12318  self.__init__()
12319  if isinstance(p, tuple):
12320  d, p = p
12321  self.__dict__.update(d)
12322  return self._set_from_binary(p)
12323 
12324  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
12325 
12326 # Register PrincipalComponentAnalysis5D in _IMP_algebra:
12327 _IMP_algebra.PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
12328 class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
12329  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< 6 > class."""
12330 
12331  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12332 
12333  def __init__(self, *args):
12334  r"""
12335  __init__(PrincipalComponentAnalysis6D self) -> PrincipalComponentAnalysis6D
12336  __init__(PrincipalComponentAnalysis6D self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
12337  """
12338  _IMP_algebra.PrincipalComponentAnalysis6D_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysis6D(*args))
12339 
12340  def get_principal_components(self):
12341  r"""get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
12342  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)
12343 
12344  def get_principal_component(self, i):
12345  r"""get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
12346  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, i)
12347 
12348  def get_principal_values(self):
12349  r"""get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
12350  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)
12351 
12352  def get_principal_value(self, i):
12353  r"""get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
12354  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, i)
12355 
12356  def get_centroid(self):
12357  r"""get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
12358  return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)
12359 
12360  def set_centroid(self, cntr):
12361  r"""set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
12362  return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)
12363 
12364  def show(self, *args):
12365  r"""show(PrincipalComponentAnalysis6D self, _ostream out=std::cout)"""
12366  return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)
12367 
12368  def __cmp__(self, o):
12369  r"""__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
12370  return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, o)
12371 
12372  def __eq__(self, o):
12373  r"""__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12374  return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)
12375 
12376  def __ne__(self, o):
12377  r"""__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12378  return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)
12379 
12380  def __lt__(self, o):
12381  r"""__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12382  return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)
12383 
12384  def __gt__(self, o):
12385  r"""__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12386  return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)
12387 
12388  def __ge__(self, o):
12389  r"""__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12390  return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)
12391 
12392  def __le__(self, o):
12393  r"""__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
12394  return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)
12395 
12396  def __str__(self):
12397  r"""__str__(PrincipalComponentAnalysis6D self) -> std::string"""
12398  return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)
12399 
12400  def __repr__(self):
12401  r"""__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
12402  return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)
12403 
12404  def _get_as_binary(self):
12405  r"""_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
12406  return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)
12407 
12408  def _set_from_binary(self, p):
12409  r"""_set_from_binary(PrincipalComponentAnalysis6D self, PyObject * p)"""
12410  return _IMP_algebra.PrincipalComponentAnalysis6D__set_from_binary(self, p)
12411 
12412  def __getstate__(self):
12413  p = self._get_as_binary()
12414  if len(self.__dict__) > 1:
12415  d = self.__dict__.copy()
12416  del d['this']
12417  p = (d, p)
12418  return p
12419 
12420  def __setstate__(self, p):
12421  if not hasattr(self, 'this'):
12422  self.__init__()
12423  if isinstance(p, tuple):
12424  d, p = p
12425  self.__dict__.update(d)
12426  return self._set_from_binary(p)
12427 
12428  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
12429 
12430 # Register PrincipalComponentAnalysis6D in _IMP_algebra:
12431 _IMP_algebra.PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
12432 class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
12433  r"""Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD< -1 > class."""
12434 
12435  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12436 
12437  def __init__(self, *args):
12438  r"""
12439  __init__(PrincipalComponentAnalysisKD self) -> PrincipalComponentAnalysisKD
12440  __init__(PrincipalComponentAnalysisKD self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
12441  """
12442  _IMP_algebra.PrincipalComponentAnalysisKD_swiginit(self, _IMP_algebra.new_PrincipalComponentAnalysisKD(*args))
12443 
12444  def get_principal_components(self):
12445  r"""get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
12446  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)
12447 
12448  def get_principal_component(self, i):
12449  r"""get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
12450  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, i)
12451 
12452  def get_principal_values(self):
12453  r"""get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
12454  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)
12455 
12456  def get_principal_value(self, i):
12457  r"""get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
12458  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, i)
12459 
12460  def get_centroid(self):
12461  r"""get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
12462  return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)
12463 
12464  def set_centroid(self, cntr):
12465  r"""set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
12466  return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)
12467 
12468  def show(self, *args):
12469  r"""show(PrincipalComponentAnalysisKD self, _ostream out=std::cout)"""
12470  return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)
12471 
12472  def __cmp__(self, o):
12473  r"""__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
12474  return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, o)
12475 
12476  def __eq__(self, o):
12477  r"""__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12478  return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)
12479 
12480  def __ne__(self, o):
12481  r"""__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12482  return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)
12483 
12484  def __lt__(self, o):
12485  r"""__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12486  return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)
12487 
12488  def __gt__(self, o):
12489  r"""__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12490  return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)
12491 
12492  def __ge__(self, o):
12493  r"""__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12494  return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)
12495 
12496  def __le__(self, o):
12497  r"""__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
12498  return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)
12499 
12500  def __str__(self):
12501  r"""__str__(PrincipalComponentAnalysisKD self) -> std::string"""
12502  return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)
12503 
12504  def __repr__(self):
12505  r"""__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
12506  return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)
12507 
12508  def _get_as_binary(self):
12509  r"""_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
12510  return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)
12511 
12512  def _set_from_binary(self, p):
12513  r"""_set_from_binary(PrincipalComponentAnalysisKD self, PyObject * p)"""
12514  return _IMP_algebra.PrincipalComponentAnalysisKD__set_from_binary(self, p)
12515 
12516  def __getstate__(self):
12517  p = self._get_as_binary()
12518  if len(self.__dict__) > 1:
12519  d = self.__dict__.copy()
12520  del d['this']
12521  p = (d, p)
12522  return p
12523 
12524  def __setstate__(self, p):
12525  if not hasattr(self, 'this'):
12526  self.__init__()
12527  if isinstance(p, tuple):
12528  d, p = p
12529  self.__dict__.update(d)
12530  return self._set_from_binary(p)
12531 
12532  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
12533 
12534 # Register PrincipalComponentAnalysisKD in _IMP_algebra:
12535 _IMP_algebra.PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)
12536 
12537 def get_principal_components(*args):
12538  r"""
12539  get_principal_components(IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > > const & a) -> PrincipalComponentAnalysis1D
12540  get_principal_components(IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > > const & a) -> PrincipalComponentAnalysis2D
12541  get_principal_components(IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > > const & a) -> PrincipalComponentAnalysis3D
12542  get_principal_components(IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > > const & a) -> PrincipalComponentAnalysis4D
12543  get_principal_components(IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > > const & a) -> PrincipalComponentAnalysis5D
12544  get_principal_components(IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > > const & a) -> PrincipalComponentAnalysis6D
12545  get_principal_components(IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > > const & a) -> PrincipalComponentAnalysisKD
12546  """
12547  return _IMP_algebra.get_principal_components(*args)
12548 
12549 def get_distance(*args):
12550  r"""
12551  get_distance(Rotation3D r0, Rotation3D r1) -> double
12552  get_distance(Line3D s, Vector3D p) -> double
12553  get_distance(Line3D a, Line3D b) -> double
12554  get_distance(Segment3D s, Vector3D p) -> double
12555  get_distance(Segment3D a, Segment3D b) -> double
12556  get_distance(Plane3D pln, Vector3D p) -> double
12557  get_distance(Vector1D a, Vector1D b) -> double
12558  get_distance(Vector2D a, Vector2D b) -> double
12559  get_distance(Vector3D a, Vector3D b) -> double
12560  get_distance(Vector4D a, Vector4D b) -> double
12561  get_distance(Vector5D a, Vector5D b) -> double
12562  get_distance(Vector6D a, Vector6D b) -> double
12563  get_distance(VectorKD a, VectorKD b) -> double
12564  get_distance(Sphere1D a, Sphere1D b) -> double
12565  get_distance(Sphere2D a, Sphere2D b) -> double
12566  get_distance(Sphere3D a, Sphere3D b) -> double
12567  get_distance(Sphere4D a, Sphere4D b) -> double
12568  get_distance(Sphere5D a, Sphere5D b) -> double
12569  get_distance(Sphere6D a, Sphere6D b) -> double
12570  get_distance(SphereKD a, SphereKD b) -> double
12571  """
12572  return _IMP_algebra.get_distance(*args)
12573 
12574 def get_squared_distance(*args):
12575  r"""
12576  get_squared_distance(Vector1D a, Vector1D b) -> double
12577  get_squared_distance(Vector2D a, Vector2D b) -> double
12578  get_squared_distance(Vector3D a, Vector3D b) -> double
12579  get_squared_distance(Vector4D a, Vector4D b) -> double
12580  get_squared_distance(Vector5D a, Vector5D b) -> double
12581  get_squared_distance(Vector6D a, Vector6D b) -> double
12582  get_squared_distance(VectorKD a, VectorKD b) -> double
12583  """
12584  return _IMP_algebra.get_squared_distance(*args)
12585 
12586 def get_basis_vector_1d(coordinate):
12587  r"""get_basis_vector_1d(unsigned int coordinate) -> Vector1D"""
12588  return _IMP_algebra.get_basis_vector_1d(coordinate)
12589 
12590 def get_basis_vector_2d(coordinate):
12591  r"""get_basis_vector_2d(unsigned int coordinate) -> Vector2D"""
12592  return _IMP_algebra.get_basis_vector_2d(coordinate)
12593 
12594 def get_basis_vector_3d(coordinate):
12595  r"""get_basis_vector_3d(unsigned int coordinate) -> Vector3D"""
12596  return _IMP_algebra.get_basis_vector_3d(coordinate)
12597 
12598 def get_basis_vector_4d(coordinate):
12599  r"""get_basis_vector_4d(unsigned int coordinate) -> Vector4D"""
12600  return _IMP_algebra.get_basis_vector_4d(coordinate)
12601 
12602 def get_basis_vector_5d(coordinate):
12603  r"""get_basis_vector_5d(unsigned int coordinate) -> Vector5D"""
12604  return _IMP_algebra.get_basis_vector_5d(coordinate)
12605 
12606 def get_basis_vector_6d(coordinate):
12607  r"""get_basis_vector_6d(unsigned int coordinate) -> Vector6D"""
12608  return _IMP_algebra.get_basis_vector_6d(coordinate)
12609 
12610 def get_zero_vector_1d():
12611  r"""get_zero_vector_1d() -> Vector1D"""
12612  return _IMP_algebra.get_zero_vector_1d()
12613 
12614 def get_zero_vector_2d():
12615  r"""get_zero_vector_2d() -> Vector2D"""
12616  return _IMP_algebra.get_zero_vector_2d()
12617 
12618 def get_zero_vector_3d():
12619  r"""get_zero_vector_3d() -> Vector3D"""
12620  return _IMP_algebra.get_zero_vector_3d()
12621 
12622 def get_zero_vector_4d():
12623  r"""get_zero_vector_4d() -> Vector4D"""
12624  return _IMP_algebra.get_zero_vector_4d()
12625 
12626 def get_zero_vector_5d():
12627  r"""get_zero_vector_5d() -> Vector5D"""
12628  return _IMP_algebra.get_zero_vector_5d()
12629 
12630 def get_zero_vector_6d():
12631  r"""get_zero_vector_6d() -> Vector6D"""
12632  return _IMP_algebra.get_zero_vector_6d()
12633 
12634 def get_ones_vector_1d(v=1):
12635  r"""get_ones_vector_1d(double v=1) -> Vector1D"""
12636  return _IMP_algebra.get_ones_vector_1d(v)
12637 
12638 def get_ones_vector_2d(v=1):
12639  r"""get_ones_vector_2d(double v=1) -> Vector2D"""
12640  return _IMP_algebra.get_ones_vector_2d(v)
12641 
12642 def get_ones_vector_3d(v=1):
12643  r"""get_ones_vector_3d(double v=1) -> Vector3D"""
12644  return _IMP_algebra.get_ones_vector_3d(v)
12645 
12646 def get_ones_vector_4d(v=1):
12647  r"""get_ones_vector_4d(double v=1) -> Vector4D"""
12648  return _IMP_algebra.get_ones_vector_4d(v)
12649 
12650 def get_ones_vector_5d(v=1):
12651  r"""get_ones_vector_5d(double v=1) -> Vector5D"""
12652  return _IMP_algebra.get_ones_vector_5d(v)
12653 
12654 def get_ones_vector_6d(v=1):
12655  r"""get_ones_vector_6d(double v=1) -> Vector6D"""
12656  return _IMP_algebra.get_ones_vector_6d(v)
12657 
12658 def get_unit_bounding_box_1d():
12659  r"""get_unit_bounding_box_1d() -> BoundingBox1D"""
12660  return _IMP_algebra.get_unit_bounding_box_1d()
12661 
12662 def get_unit_bounding_box_2d():
12663  r"""get_unit_bounding_box_2d() -> BoundingBox2D"""
12664  return _IMP_algebra.get_unit_bounding_box_2d()
12665 
12666 def get_unit_bounding_box_3d():
12667  r"""get_unit_bounding_box_3d() -> BoundingBox3D"""
12668  return _IMP_algebra.get_unit_bounding_box_3d()
12669 
12670 def get_unit_bounding_box_4d():
12671  r"""get_unit_bounding_box_4d() -> BoundingBox4D"""
12672  return _IMP_algebra.get_unit_bounding_box_4d()
12673 
12674 def get_unit_bounding_box_5d():
12675  r"""get_unit_bounding_box_5d() -> BoundingBox5D"""
12676  return _IMP_algebra.get_unit_bounding_box_5d()
12677 
12678 def get_unit_bounding_box_6d():
12679  r"""get_unit_bounding_box_6d() -> BoundingBox6D"""
12680  return _IMP_algebra.get_unit_bounding_box_6d()
12681 
12682 def get_cube_1d(radius):
12683  r"""get_cube_1d(double radius) -> BoundingBox1D"""
12684  return _IMP_algebra.get_cube_1d(radius)
12685 
12686 def get_cube_2d(radius):
12687  r"""get_cube_2d(double radius) -> BoundingBox2D"""
12688  return _IMP_algebra.get_cube_2d(radius)
12689 
12690 def get_cube_3d(radius):
12691  r"""get_cube_3d(double radius) -> BoundingBox3D"""
12692  return _IMP_algebra.get_cube_3d(radius)
12693 
12694 def get_cube_4d(radius):
12695  r"""get_cube_4d(double radius) -> BoundingBox4D"""
12696  return _IMP_algebra.get_cube_4d(radius)
12697 
12698 def get_cube_5d(radius):
12699  r"""get_cube_5d(double radius) -> BoundingBox5D"""
12700  return _IMP_algebra.get_cube_5d(radius)
12701 
12702 def get_cube_6d(radius):
12703  r"""get_cube_6d(double radius) -> BoundingBox6D"""
12704  return _IMP_algebra.get_cube_6d(radius)
12705 
12706 def get_unit_sphere_1d():
12707  r"""get_unit_sphere_1d() -> Sphere1D"""
12708  return _IMP_algebra.get_unit_sphere_1d()
12709 
12710 def get_unit_sphere_2d():
12711  r"""get_unit_sphere_2d() -> Sphere2D"""
12712  return _IMP_algebra.get_unit_sphere_2d()
12713 
12714 def get_unit_sphere_3d():
12715  r"""get_unit_sphere_3d() -> Sphere3D"""
12716  return _IMP_algebra.get_unit_sphere_3d()
12717 
12718 def get_unit_sphere_4d():
12719  r"""get_unit_sphere_4d() -> Sphere4D"""
12720  return _IMP_algebra.get_unit_sphere_4d()
12721 
12722 def get_unit_sphere_5d():
12723  r"""get_unit_sphere_5d() -> Sphere5D"""
12724  return _IMP_algebra.get_unit_sphere_5d()
12725 
12726 def get_unit_sphere_6d():
12727  r"""get_unit_sphere_6d() -> Sphere6D"""
12728  return _IMP_algebra.get_unit_sphere_6d()
12729 
12730 def get_interiors_intersect(*args):
12731  r"""
12732  get_interiors_intersect(Sphere1D a, Sphere1D b) -> bool
12733  get_interiors_intersect(Sphere2D a, Sphere2D b) -> bool
12734  get_interiors_intersect(Sphere3D a, Sphere3D b) -> bool
12735  get_interiors_intersect(Sphere4D a, Sphere4D b) -> bool
12736  get_interiors_intersect(Sphere5D a, Sphere5D b) -> bool
12737  get_interiors_intersect(Sphere6D a, Sphere6D b) -> bool
12738  get_interiors_intersect(SphereKD a, SphereKD b) -> bool
12739  get_interiors_intersect(BoundingBox1D a, BoundingBox1D b) -> bool
12740  get_interiors_intersect(BoundingBox2D a, BoundingBox2D b) -> bool
12741  get_interiors_intersect(BoundingBox3D a, BoundingBox3D b) -> bool
12742  get_interiors_intersect(BoundingBox4D a, BoundingBox4D b) -> bool
12743  get_interiors_intersect(BoundingBox5D a, BoundingBox5D b) -> bool
12744  get_interiors_intersect(BoundingBox6D a, BoundingBox6D b) -> bool
12745  get_interiors_intersect(BoundingBoxKD a, BoundingBoxKD b) -> bool
12746  """
12747  return _IMP_algebra.get_interiors_intersect(*args)
12748 
12749 def get_random_vector_on(*args):
12750  r"""
12751  get_random_vector_on(Sphere1D a) -> Vector1D
12752  get_random_vector_on(Sphere2D a) -> Vector2D
12753  get_random_vector_on(Sphere3D a) -> Vector3D
12754  get_random_vector_on(Sphere4D a) -> Vector4D
12755  get_random_vector_on(Sphere5D a) -> Vector5D
12756  get_random_vector_on(Sphere6D a) -> Vector6D
12757  get_random_vector_on(SphereKD a) -> VectorKD
12758  get_random_vector_on(UnitSimplex1D a) -> Vector1D
12759  get_random_vector_on(UnitSimplex2D a) -> Vector2D
12760  get_random_vector_on(UnitSimplex3D a) -> Vector3D
12761  get_random_vector_on(UnitSimplex4D a) -> Vector4D
12762  get_random_vector_on(UnitSimplex5D a) -> Vector5D
12763  get_random_vector_on(UnitSimplex6D a) -> Vector6D
12764  get_random_vector_on(UnitSimplexKD a) -> VectorKD
12765  get_random_vector_on(BoundingBox1D a) -> Vector1D
12766  get_random_vector_on(BoundingBox2D a) -> Vector2D
12767  get_random_vector_on(BoundingBox3D a) -> Vector3D
12768  get_random_vector_on(BoundingBox4D a) -> Vector4D
12769  get_random_vector_on(BoundingBox5D a) -> Vector5D
12770  get_random_vector_on(BoundingBox6D a) -> Vector6D
12771  get_random_vector_on(BoundingBoxKD a) -> VectorKD
12772  """
12773  return _IMP_algebra.get_random_vector_on(*args)
12774 
12775 def get_random_vector_in(*args):
12776  r"""
12777  get_random_vector_in(Cylinder3D c) -> Vector3D
12778  get_random_vector_in(Sphere1D a) -> Vector1D
12779  get_random_vector_in(Sphere2D a) -> Vector2D
12780  get_random_vector_in(Sphere3D a) -> Vector3D
12781  get_random_vector_in(Sphere4D a) -> Vector4D
12782  get_random_vector_in(Sphere5D a) -> Vector5D
12783  get_random_vector_in(Sphere6D a) -> Vector6D
12784  get_random_vector_in(SphereKD a) -> VectorKD
12785  get_random_vector_in(BoundingBox1D a) -> Vector1D
12786  get_random_vector_in(BoundingBox2D a) -> Vector2D
12787  get_random_vector_in(BoundingBox3D a) -> Vector3D
12788  get_random_vector_in(BoundingBox4D a) -> Vector4D
12789  get_random_vector_in(BoundingBox5D a) -> Vector5D
12790  get_random_vector_in(BoundingBox6D a) -> Vector6D
12791  get_random_vector_in(BoundingBoxKD a) -> VectorKD
12792  """
12793  return _IMP_algebra.get_random_vector_in(*args)
12794 
12795 def get_intersection(*args):
12796  r"""
12797  get_intersection(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12798  get_intersection(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12799  get_intersection(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12800  get_intersection(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12801  get_intersection(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12802  get_intersection(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12803  get_intersection(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12804  """
12805  return _IMP_algebra.get_intersection(*args)
12806 
12807 def get_union(*args):
12808  r"""
12809  get_union(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
12810  get_union(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
12811  get_union(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
12812  get_union(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
12813  get_union(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
12814  get_union(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
12815  get_union(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
12816  """
12817  return _IMP_algebra.get_union(*args)
12818 
12819 def get_bounding_box(*args):
12820  r"""
12821  get_bounding_box(Line3D g) -> BoundingBox3D
12822  get_bounding_box(Segment3D g) -> BoundingBox3D
12823  get_bounding_box(Plane3D g) -> BoundingBox3D
12824  get_bounding_box(Cylinder3D g) -> BoundingBox3D
12825  get_bounding_box(Ellipsoid3D g) -> BoundingBox3D
12826  get_bounding_box(SpherePatch3D g) -> BoundingBox3D
12827  get_bounding_box(Cone3D g) -> BoundingBox3D
12828  get_bounding_box(Sphere1D a) -> BoundingBox1D
12829  get_bounding_box(Sphere2D a) -> BoundingBox2D
12830  get_bounding_box(Sphere3D a) -> BoundingBox3D
12831  get_bounding_box(Sphere4D a) -> BoundingBox4D
12832  get_bounding_box(Sphere5D a) -> BoundingBox5D
12833  get_bounding_box(Sphere6D a) -> BoundingBox6D
12834  get_bounding_box(SphereKD a) -> BoundingBoxKD
12835  """
12836  return _IMP_algebra.get_bounding_box(*args)
12837 
12838 def get_uniform_surface_cover(*args):
12839  r"""
12840  get_uniform_surface_cover(Cylinder3D cyl, int number_of_points) -> IMP::algebra::Vector3Ds
12841  get_uniform_surface_cover(SpherePatch3D sph, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12842  get_uniform_surface_cover(Cone3D cone, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
12843  get_uniform_surface_cover(IMP::algebra::Sphere3Ds const & _in, double points_per_square_angstrom) -> IMP::algebra::Vector3Ds
12844  get_uniform_surface_cover(Sphere1D a, unsigned int const & b) -> IMP::algebra::Vector1Ds
12845  get_uniform_surface_cover(Sphere2D a, unsigned int const & b) -> IMP::algebra::Vector2Ds
12846  get_uniform_surface_cover(Sphere3D a, unsigned int const & b) -> IMP::algebra::Vector3Ds
12847  get_uniform_surface_cover(Sphere4D a, unsigned int const & b) -> IMP::algebra::Vector4Ds
12848  get_uniform_surface_cover(Sphere5D a, unsigned int const & b) -> IMP::algebra::Vector5Ds
12849  get_uniform_surface_cover(Sphere6D a, unsigned int const & b) -> IMP::algebra::Vector6Ds
12850  get_uniform_surface_cover(SphereKD a, unsigned int const & b) -> IMP::algebra::VectorKDs
12851  """
12852  return _IMP_algebra.get_uniform_surface_cover(*args)
12853 
12855  r"""
12856  get_grid_interior_cover_by_spacing(BoundingBox1D a, double const & b) -> IMP::algebra::Vector1Ds
12857  get_grid_interior_cover_by_spacing(BoundingBox2D a, double const & b) -> IMP::algebra::Vector2Ds
12858  get_grid_interior_cover_by_spacing(BoundingBox3D a, double const & b) -> IMP::algebra::Vector3Ds
12859  get_grid_interior_cover_by_spacing(BoundingBox4D a, double const & b) -> IMP::algebra::Vector4Ds
12860  get_grid_interior_cover_by_spacing(BoundingBox5D a, double const & b) -> IMP::algebra::Vector5Ds
12861  get_grid_interior_cover_by_spacing(BoundingBox6D a, double const & b) -> IMP::algebra::Vector6Ds
12862  get_grid_interior_cover_by_spacing(BoundingBoxKD a, double const & b) -> IMP::algebra::VectorKDs
12863  """
12864  return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
12865 
12866 def get_projected(*args):
12867  r"""
12868  get_projected(Line3D l, Vector3D p) -> Vector3D
12869  get_projected(Line3D l, Segment3D s) -> Segment3D
12870  get_projected(UnitSimplex1D a, Vector1D b) -> Vector1D
12871  get_projected(UnitSimplex2D a, Vector2D b) -> Vector2D
12872  get_projected(UnitSimplex3D a, Vector3D b) -> Vector3D
12873  get_projected(UnitSimplex4D a, Vector4D b) -> Vector4D
12874  get_projected(UnitSimplex5D a, Vector5D b) -> Vector5D
12875  get_projected(UnitSimplex6D a, Vector6D b) -> Vector6D
12876  get_projected(UnitSimplexKD a, VectorKD b) -> VectorKD
12877  """
12878  return _IMP_algebra.get_projected(*args)
12879 
12880 def get_vertices(*args):
12881  r"""
12882  get_vertices(BoundingBox1D a) -> IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > >
12883  get_vertices(BoundingBox2D a) -> IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > >
12884  get_vertices(BoundingBox3D a) -> IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > >
12885  get_vertices(BoundingBox4D a) -> IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > >
12886  get_vertices(BoundingBox5D a) -> IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > >
12887  get_vertices(BoundingBox6D a) -> IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > >
12888  get_vertices(BoundingBoxKD a) -> IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > >
12889  get_vertices(UnitSimplex1D a) -> IMP::Vector< IMP::algebra::Vector1D,std::allocator< IMP::algebra::Vector1D > >
12890  get_vertices(UnitSimplex2D a) -> IMP::Vector< IMP::algebra::Vector2D,std::allocator< IMP::algebra::Vector2D > >
12891  get_vertices(UnitSimplex3D a) -> IMP::Vector< IMP::algebra::Vector3D,std::allocator< IMP::algebra::Vector3D > >
12892  get_vertices(UnitSimplex4D a) -> IMP::Vector< IMP::algebra::Vector4D,std::allocator< IMP::algebra::Vector4D > >
12893  get_vertices(UnitSimplex5D a) -> IMP::Vector< IMP::algebra::Vector5D,std::allocator< IMP::algebra::Vector5D > >
12894  get_vertices(UnitSimplex6D a) -> IMP::Vector< IMP::algebra::Vector6D,std::allocator< IMP::algebra::Vector6D > >
12895  get_vertices(UnitSimplexKD a) -> IMP::Vector< IMP::algebra::VectorKD,std::allocator< IMP::algebra::VectorKD > >
12896  """
12897  return _IMP_algebra.get_vertices(*args)
12898 
12899 def get_increasing_from_embedded(*args):
12900  r"""
12901  get_increasing_from_embedded(UnitSimplex1D a, Vector1D b) -> Vector1D
12902  get_increasing_from_embedded(UnitSimplex2D a, Vector2D b) -> Vector2D
12903  get_increasing_from_embedded(UnitSimplex3D a, Vector3D b) -> Vector3D
12904  get_increasing_from_embedded(UnitSimplex4D a, Vector4D b) -> Vector4D
12905  get_increasing_from_embedded(UnitSimplex5D a, Vector5D b) -> Vector5D
12906  get_increasing_from_embedded(UnitSimplex6D a, Vector6D b) -> Vector6D
12907  get_increasing_from_embedded(UnitSimplexKD a, VectorKD b) -> VectorKD
12908  """
12909  return _IMP_algebra.get_increasing_from_embedded(*args)
12910 
12911 def get_embedded_from_increasing(*args):
12912  r"""
12913  get_embedded_from_increasing(UnitSimplex1D a, Vector1D b) -> Vector1D
12914  get_embedded_from_increasing(UnitSimplex2D a, Vector2D b) -> Vector2D
12915  get_embedded_from_increasing(UnitSimplex3D a, Vector3D b) -> Vector3D
12916  get_embedded_from_increasing(UnitSimplex4D a, Vector4D b) -> Vector4D
12917  get_embedded_from_increasing(UnitSimplex5D a, Vector5D b) -> Vector5D
12918  get_embedded_from_increasing(UnitSimplex6D a, Vector6D b) -> Vector6D
12919  get_embedded_from_increasing(UnitSimplexKD a, VectorKD b) -> VectorKD
12920  """
12921  return _IMP_algebra.get_embedded_from_increasing(*args)
12922 class _AxisAnglePair(object):
12923  r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,double > class."""
12924 
12925  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12926  __repr__ = _swig_repr
12927 
12928  def __init__(self, *args):
12929  r"""
12930  __init__(_AxisAnglePair self) -> _AxisAnglePair
12931  __init__(_AxisAnglePair self, Vector3D first, double second) -> _AxisAnglePair
12932  __init__(_AxisAnglePair self, _AxisAnglePair other) -> _AxisAnglePair
12933  """
12934  _IMP_algebra._AxisAnglePair_swiginit(self, _IMP_algebra.new__AxisAnglePair(*args))
12935  first = property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set, doc=r"""first : IMP::algebra::VectorD<(3)>""")
12936  second = property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set, doc=r"""second : double""")
12937  def __len__(self):
12938  return 2
12939  def __repr__(self):
12940  return str((self.first, self.second))
12941  def __getitem__(self, index):
12942  if not (index % 2):
12943  return self.first
12944  else:
12945  return self.second
12946  def __setitem__(self, index, val):
12947  if not (index % 2):
12948  self.first = val
12949  else:
12950  self.second = val
12951  __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
12952 
12953 # Register _AxisAnglePair in _IMP_algebra:
12954 _IMP_algebra._AxisAnglePair_swigregister(_AxisAnglePair)
12955 
12957  r"""get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 >,std::allocator< IMP::algebra::VectorD< 3 > > > const & source, IMP::Vector< IMP::algebra::VectorD< 3 >,std::allocator< IMP::algebra::VectorD< 3 > > > const & target) -> Transformation3D"""
12958  return _IMP_algebra.get_transformation_aligning_first_to_second(source, target)
12959 class _RotatedVector3DAdjoint(object):
12960  r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,IMP::algebra::VectorD< 4 > > class."""
12961 
12962  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12963  __repr__ = _swig_repr
12964 
12965  def __init__(self, *args):
12966  r"""
12967  __init__(_RotatedVector3DAdjoint self) -> _RotatedVector3DAdjoint
12968  __init__(_RotatedVector3DAdjoint self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
12969  __init__(_RotatedVector3DAdjoint self, _RotatedVector3DAdjoint other) -> _RotatedVector3DAdjoint
12970  """
12971  _IMP_algebra._RotatedVector3DAdjoint_swiginit(self, _IMP_algebra.new__RotatedVector3DAdjoint(*args))
12972  first = property(_IMP_algebra._RotatedVector3DAdjoint_first_get, _IMP_algebra._RotatedVector3DAdjoint_first_set, doc=r"""first : IMP::algebra::VectorD<(3)>""")
12973  second = property(_IMP_algebra._RotatedVector3DAdjoint_second_get, _IMP_algebra._RotatedVector3DAdjoint_second_set, doc=r"""second : IMP::algebra::VectorD<(4)>""")
12974  def __len__(self):
12975  return 2
12976  def __repr__(self):
12977  return str((self.first, self.second))
12978  def __getitem__(self, index):
12979  if not (index % 2):
12980  return self.first
12981  else:
12982  return self.second
12983  def __setitem__(self, index, val):
12984  if not (index % 2):
12985  self.first = val
12986  else:
12987  self.second = val
12988  __swig_destroy__ = _IMP_algebra.delete__RotatedVector3DAdjoint
12989 
12990 # Register _RotatedVector3DAdjoint in _IMP_algebra:
12991 _IMP_algebra._RotatedVector3DAdjoint_swigregister(_RotatedVector3DAdjoint)
12992 class _ComposeRotation3DAdjoint(object):
12993  r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 4 > > class."""
12994 
12995  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
12996  __repr__ = _swig_repr
12997 
12998  def __init__(self, *args):
12999  r"""
13000  __init__(_ComposeRotation3DAdjoint self) -> _ComposeRotation3DAdjoint
13001  __init__(_ComposeRotation3DAdjoint self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
13002  __init__(_ComposeRotation3DAdjoint self, _ComposeRotation3DAdjoint other) -> _ComposeRotation3DAdjoint
13003  """
13004  _IMP_algebra._ComposeRotation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeRotation3DAdjoint(*args))
13005  first = property(_IMP_algebra._ComposeRotation3DAdjoint_first_get, _IMP_algebra._ComposeRotation3DAdjoint_first_set, doc=r"""first : IMP::algebra::VectorD<(4)>""")
13006  second = property(_IMP_algebra._ComposeRotation3DAdjoint_second_get, _IMP_algebra._ComposeRotation3DAdjoint_second_set, doc=r"""second : IMP::algebra::VectorD<(4)>""")
13007  def __len__(self):
13008  return 2
13009  def __repr__(self):
13010  return str((self.first, self.second))
13011  def __getitem__(self, index):
13012  if not (index % 2):
13013  return self.first
13014  else:
13015  return self.second
13016  def __setitem__(self, index, val):
13017  if not (index % 2):
13018  self.first = val
13019  else:
13020  self.second = val
13021  __swig_destroy__ = _IMP_algebra.delete__ComposeRotation3DAdjoint
13022 
13023 # Register _ComposeRotation3DAdjoint in _IMP_algebra:
13024 _IMP_algebra._ComposeRotation3DAdjoint_swigregister(_ComposeRotation3DAdjoint)
13025 class _Transformation3DAdjoint(object):
13026  r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > class."""
13027 
13028  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13029  __repr__ = _swig_repr
13030 
13031  def __init__(self, *args):
13032  r"""
13033  __init__(_Transformation3DAdjoint self) -> _Transformation3DAdjoint
13034  __init__(_Transformation3DAdjoint self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
13035  __init__(_Transformation3DAdjoint self, _Transformation3DAdjoint other) -> _Transformation3DAdjoint
13036  """
13037  _IMP_algebra._Transformation3DAdjoint_swiginit(self, _IMP_algebra.new__Transformation3DAdjoint(*args))
13038  first = property(_IMP_algebra._Transformation3DAdjoint_first_get, _IMP_algebra._Transformation3DAdjoint_first_set, doc=r"""first : IMP::algebra::VectorD<(4)>""")
13039  second = property(_IMP_algebra._Transformation3DAdjoint_second_get, _IMP_algebra._Transformation3DAdjoint_second_set, doc=r"""second : IMP::algebra::VectorD<(3)>""")
13040  def __len__(self):
13041  return 2
13042  def __repr__(self):
13043  return str((self.first, self.second))
13044  def __getitem__(self, index):
13045  if not (index % 2):
13046  return self.first
13047  else:
13048  return self.second
13049  def __setitem__(self, index, val):
13050  if not (index % 2):
13051  self.first = val
13052  else:
13053  self.second = val
13054  __swig_destroy__ = _IMP_algebra.delete__Transformation3DAdjoint
13055 
13056 # Register _Transformation3DAdjoint in _IMP_algebra:
13057 _IMP_algebra._Transformation3DAdjoint_swigregister(_Transformation3DAdjoint)
13058 class _TransformedVector3DAdjoint(object):
13059  r"""Proxy of C++ std::pair< IMP::algebra::VectorD< 3 >,std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > > class."""
13060 
13061  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13062  __repr__ = _swig_repr
13063 
13064  def __init__(self, *args):
13065  r"""
13066  __init__(_TransformedVector3DAdjoint self) -> _TransformedVector3DAdjoint
13067  __init__(_TransformedVector3DAdjoint self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
13068  __init__(_TransformedVector3DAdjoint self, _TransformedVector3DAdjoint other) -> _TransformedVector3DAdjoint
13069  """
13070  _IMP_algebra._TransformedVector3DAdjoint_swiginit(self, _IMP_algebra.new__TransformedVector3DAdjoint(*args))
13071  first = property(_IMP_algebra._TransformedVector3DAdjoint_first_get, _IMP_algebra._TransformedVector3DAdjoint_first_set, doc=r"""first : IMP::algebra::VectorD<(3)>""")
13072  second = property(_IMP_algebra._TransformedVector3DAdjoint_second_get, _IMP_algebra._TransformedVector3DAdjoint_second_set, doc=r"""second : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13073  def __len__(self):
13074  return 2
13075  def __repr__(self):
13076  return str((self.first, self.second))
13077  def __getitem__(self, index):
13078  if not (index % 2):
13079  return self.first
13080  else:
13081  return self.second
13082  def __setitem__(self, index, val):
13083  if not (index % 2):
13084  self.first = val
13085  else:
13086  self.second = val
13087  __swig_destroy__ = _IMP_algebra.delete__TransformedVector3DAdjoint
13088 
13089 # Register _TransformedVector3DAdjoint in _IMP_algebra:
13090 _IMP_algebra._TransformedVector3DAdjoint_swigregister(_TransformedVector3DAdjoint)
13091 class _ComposeTransformation3DAdjoint(object):
13092  r"""Proxy of C++ std::pair< std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > >,std::pair< IMP::algebra::VectorD< 4 >,IMP::algebra::VectorD< 3 > > > class."""
13093 
13094  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
13095  __repr__ = _swig_repr
13096 
13097  def __init__(self, *args):
13098  r"""
13099  __init__(_ComposeTransformation3DAdjoint self) -> _ComposeTransformation3DAdjoint
13100  __init__(_ComposeTransformation3DAdjoint self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
13101  __init__(_ComposeTransformation3DAdjoint self, _ComposeTransformation3DAdjoint other) -> _ComposeTransformation3DAdjoint
13102  """
13103  _IMP_algebra._ComposeTransformation3DAdjoint_swiginit(self, _IMP_algebra.new__ComposeTransformation3DAdjoint(*args))
13104  first = property(_IMP_algebra._ComposeTransformation3DAdjoint_first_get, _IMP_algebra._ComposeTransformation3DAdjoint_first_set, doc=r"""first : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13105  second = property(_IMP_algebra._ComposeTransformation3DAdjoint_second_get, _IMP_algebra._ComposeTransformation3DAdjoint_second_set, doc=r"""second : std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>""")
13106  def __len__(self):
13107  return 2
13108  def __repr__(self):
13109  return str((self.first, self.second))
13110  def __getitem__(self, index):
13111  if not (index % 2):
13112  return self.first
13113  else:
13114  return self.second
13115  def __setitem__(self, index, val):
13116  if not (index % 2):
13117  self.first = val
13118  else:
13119  self.second = val
13120  __swig_destroy__ = _IMP_algebra.delete__ComposeTransformation3DAdjoint
13121 
13122 # Register _ComposeTransformation3DAdjoint in _IMP_algebra:
13123 _IMP_algebra._ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)
13124 
13125 def get_rmsd_transforming_first(tr, v0, v1):
13126  r"""get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13127  return _IMP_algebra.get_rmsd_transforming_first(tr, v0, v1)
13128 
13129 def get_rmsd(v0, v1):
13130  r"""get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
13131  return _IMP_algebra.get_rmsd(v0, v1)
13132 
13133 def get_weighted_rmsd_transforming_first(tr, v0, v1, weights):
13134  r"""get_weighted_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13135  return _IMP_algebra.get_weighted_rmsd_transforming_first(tr, v0, v1, weights)
13136 
13137 def get_weighted_rmsd(v0, v1, weights):
13138  r"""get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
13139  return _IMP_algebra.get_weighted_rmsd(v0, v1, weights)
13140 
13141 LinearFit=LinearFit2D
13142 ParabolicFit=ParabolicFit2D
13143 
13144 
13145 def get_module_version():
13146  r"""get_module_version() -> std::string const"""
13147  return _IMP_algebra.get_module_version()
13148 
13149 def get_example_path(fname):
13150  r"""get_example_path(std::string fname) -> std::string"""
13151  return _IMP_algebra.get_example_path(fname)
13152 
13153 def get_data_path(fname):
13154  r"""get_data_path(std::string fname) -> std::string"""
13155  return _IMP_algebra.get_data_path(fname)
13156 
13157 from . import _version_check
13158 _version_check.check_version(get_module_version())
13159 __version__ = get_module_version()
13160 
13161 
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:420
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:404
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:263
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:416
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:188
VT get_unit_vector(VT vt)
Returns a unit vector pointing at the same direction as this vector.
Definition: VectorBaseD.h:272
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:223
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:412
VectorD< D > get_ones_vector_kd(unsigned int Di, double v=1)
Return a vector of ones (or another constant)
Definition: VectorD.h:296
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:400
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:408
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:424
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