IMP logo
IMP Reference Guide  2.18.0
The Integrative Modeling Platform
version 2.18.0
algebra/__init__.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.7
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-2022 IMP Inventors. All rights reserved.
10 
11 from __future__ import print_function, division, absolute_import
12 
13 
14 
15 
16 
17 from sys import version_info
18 if version_info >= (2, 6, 0):
19  def swig_import_helper():
20  from os.path import dirname
21  import imp
22  fp = None
23  try:
24  fp, pathname, description = imp.find_module('_IMP_algebra', [dirname(__file__)])
25  except ImportError:
26  import _IMP_algebra
27  return _IMP_algebra
28  if fp is not None:
29  try:
30  _mod = imp.load_module('_IMP_algebra', fp, pathname, description)
31  finally:
32  fp.close()
33  return _mod
34  _IMP_algebra = swig_import_helper()
35  del swig_import_helper
36 else:
37  import _IMP_algebra
38 del version_info
39 try:
40  _swig_property = property
41 except NameError:
42  pass # Python < 2.2 doesn't have 'property'.
43 
44 
45 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
46  if (name == "thisown"):
47  return self.this.own(value)
48  if (name == "this"):
49  if type(value).__name__ == 'SwigPyObject':
50  self.__dict__[name] = value
51  return
52  method = class_type.__swig_setmethods__.get(name, None)
53  if method:
54  return method(self, value)
55  if (not static):
56  object.__setattr__(self, name, value)
57  else:
58  raise AttributeError("You cannot add attributes to %s" % self)
59 
60 
61 def _swig_setattr(self, class_type, name, value):
62  return _swig_setattr_nondynamic(self, class_type, name, value, 0)
63 
64 
65 def _swig_getattr_nondynamic(self, class_type, name, static=1):
66  if (name == "thisown"):
67  return self.this.own()
68  method = class_type.__swig_getmethods__.get(name, None)
69  if method:
70  return method(self)
71  if (not static):
72  return object.__getattr__(self, name)
73  else:
74  raise AttributeError(name)
75 
76 def _swig_getattr(self, class_type, name):
77  return _swig_getattr_nondynamic(self, class_type, name, 0)
78 
79 
80 def _swig_repr(self):
81  try:
82  strthis = "proxy of " + self.this.__repr__()
83  except:
84  strthis = ""
85  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
86 
87 try:
88  _object = object
89  _newclass = 1
90 except AttributeError:
91  class _object:
92  pass
93  _newclass = 0
94 
95 
96 
97 def _swig_setattr_nondynamic_method(set):
98  def set_attr(self, name, value):
99  if (name == "thisown"):
100  return self.this.own(value)
101  if hasattr(self, name) or (name == "this"):
102  set(self, name, value)
103  else:
104  raise AttributeError("You cannot add attributes to %s" % self)
105  return set_attr
106 
107 
108 try:
109  import weakref
110  weakref_proxy = weakref.proxy
111 except:
112  weakref_proxy = lambda x: x
113 
114 
115 class IMP_ALGEBRA_SwigPyIterator(object):
116  """Proxy of C++ swig::IMP_ALGEBRA_SwigPyIterator class"""
117  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
118 
119  def __init__(self, *args, **kwargs):
120  raise AttributeError("No constructor defined - class is abstract")
121  __repr__ = _swig_repr
122  __swig_destroy__ = _IMP_algebra.delete_IMP_ALGEBRA_SwigPyIterator
123  __del__ = lambda self: None
124 
125  def value(self):
126  """value(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
127  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_value(self)
128 
129 
130  def incr(self, n=1):
131  """
132  incr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator
133  incr(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator
134  """
135  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_incr(self, n)
136 
137 
138  def decr(self, n=1):
139  """
140  decr(IMP_ALGEBRA_SwigPyIterator self, size_t n=1) -> IMP_ALGEBRA_SwigPyIterator
141  decr(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator
142  """
143  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_decr(self, n)
144 
145 
146  def distance(self, x):
147  """distance(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t"""
148  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_distance(self, x)
149 
150 
151  def equal(self, x):
152  """equal(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
153  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_equal(self, x)
154 
155 
156  def copy(self):
157  """copy(IMP_ALGEBRA_SwigPyIterator self) -> IMP_ALGEBRA_SwigPyIterator"""
158  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_copy(self)
159 
160 
161  def next(self):
162  """next(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
163  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_next(self)
164 
165 
166  def __next__(self):
167  """__next__(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
168  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___next__(self)
169 
170 
171  def previous(self):
172  """previous(IMP_ALGEBRA_SwigPyIterator self) -> PyObject *"""
173  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_previous(self)
174 
175 
176  def advance(self, n):
177  """advance(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
178  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_advance(self, n)
179 
180 
181  def __eq__(self, x):
182  """__eq__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
183  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___eq__(self, x)
184 
185 
186  def __ne__(self, x):
187  """__ne__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> bool"""
188  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___ne__(self, x)
189 
190 
191  def __iadd__(self, n):
192  """__iadd__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
193  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___iadd__(self, n)
194 
195 
196  def __isub__(self, n):
197  """__isub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
198  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___isub__(self, n)
199 
200 
201  def __add__(self, n):
202  """__add__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator"""
203  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___add__(self, n)
204 
205 
206  def __sub__(self, *args):
207  """
208  __sub__(IMP_ALGEBRA_SwigPyIterator self, ptrdiff_t n) -> IMP_ALGEBRA_SwigPyIterator
209  __sub__(IMP_ALGEBRA_SwigPyIterator self, IMP_ALGEBRA_SwigPyIterator x) -> ptrdiff_t
210  """
211  return _IMP_algebra.IMP_ALGEBRA_SwigPyIterator___sub__(self, *args)
212 
213  def __iter__(self):
214  return self
215 IMP_ALGEBRA_SwigPyIterator_swigregister = _IMP_algebra.IMP_ALGEBRA_SwigPyIterator_swigregister
216 IMP_ALGEBRA_SwigPyIterator_swigregister(IMP_ALGEBRA_SwigPyIterator)
217 
218 
219 _value_types=[]
220 _object_types=[]
221 _raii_types=[]
222 _plural_types=[]
223 
224 
225 _IMP_algebra.IMP_DEBUG_swigconstant(_IMP_algebra)
226 IMP_DEBUG = _IMP_algebra.IMP_DEBUG
227 
228 _IMP_algebra.IMP_RELEASE_swigconstant(_IMP_algebra)
229 IMP_RELEASE = _IMP_algebra.IMP_RELEASE
230 
231 _IMP_algebra.IMP_SILENT_swigconstant(_IMP_algebra)
232 IMP_SILENT = _IMP_algebra.IMP_SILENT
233 
234 _IMP_algebra.IMP_PROGRESS_swigconstant(_IMP_algebra)
235 IMP_PROGRESS = _IMP_algebra.IMP_PROGRESS
236 
237 _IMP_algebra.IMP_TERSE_swigconstant(_IMP_algebra)
238 IMP_TERSE = _IMP_algebra.IMP_TERSE
239 
240 _IMP_algebra.IMP_VERBOSE_swigconstant(_IMP_algebra)
241 IMP_VERBOSE = _IMP_algebra.IMP_VERBOSE
242 
243 _IMP_algebra.IMP_MEMORY_swigconstant(_IMP_algebra)
244 IMP_MEMORY = _IMP_algebra.IMP_MEMORY
245 
246 _IMP_algebra.IMP_NONE_swigconstant(_IMP_algebra)
247 IMP_NONE = _IMP_algebra.IMP_NONE
248 
249 _IMP_algebra.IMP_USAGE_swigconstant(_IMP_algebra)
250 IMP_USAGE = _IMP_algebra.IMP_USAGE
251 
252 _IMP_algebra.IMP_INTERNAL_swigconstant(_IMP_algebra)
253 IMP_INTERNAL = _IMP_algebra.IMP_INTERNAL
254 
255 _IMP_algebra.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_algebra)
256 IMP_KERNEL_HAS_LOG4CXX = _IMP_algebra.IMP_KERNEL_HAS_LOG4CXX
257 
258 _IMP_algebra.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_algebra)
259 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_algebra.IMP_COMPILER_HAS_DEBUG_VECTOR
260 
261 _IMP_algebra.IMP_COMPILER_HAS_RANDOM_SHUFFLE_swigconstant(_IMP_algebra)
262 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_algebra.IMP_COMPILER_HAS_RANDOM_SHUFFLE
263 
264 _IMP_algebra.IMP_COMPILER_HAS_THREE_WAY_swigconstant(_IMP_algebra)
265 IMP_COMPILER_HAS_THREE_WAY = _IMP_algebra.IMP_COMPILER_HAS_THREE_WAY
266 
267 _IMP_algebra.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_algebra)
268 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_KERNEL_HAS_BOOST_RANDOM
269 
270 _IMP_algebra.IMP_KERNEL_HAS_NUMPY_swigconstant(_IMP_algebra)
271 IMP_KERNEL_HAS_NUMPY = _IMP_algebra.IMP_KERNEL_HAS_NUMPY
272 
273 _IMP_algebra.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_algebra)
274 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_algebra.IMP_KERNEL_HAS_GPERFTOOLS
275 
276 _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_algebra)
277 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
278 
279 _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_algebra)
280 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_algebra.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
281 
282 _IMP_algebra.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_algebra)
283 IMPKERNEL_SHOW_WARNINGS = _IMP_algebra.IMPKERNEL_SHOW_WARNINGS
284 
285 import sys
286 class _DirectorObjects(object):
287  """@internal Simple class to keep references to director objects
288  to prevent premature deletion."""
289  def __init__(self):
290  self._objects = []
291  def register(self, obj):
292  """Take a reference to a director object; will only work for
293  refcounted C++ classes"""
294  if hasattr(obj, 'get_ref_count'):
295  self._objects.append(obj)
296  def cleanup(self):
297  """Only drop our reference and allow cleanup by Python if no other
298  Python references exist (we hold 3 references: one in self._objects,
299  one in x, and one in the argument list for getrefcount) *and* no
300  other C++ references exist (the Python object always holds one)"""
301  objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
302  or x.get_ref_count() > 1]
303 # Do in two steps so the references are kept until the end of the
304 # function (deleting references may trigger a fresh call to this method)
305  self._objects = objs
306  def get_object_count(self):
307  """Get number of director objects (useful for testing only)"""
308  return len(self._objects)
309 _director_objects = _DirectorObjects()
310 
311 class _ostream(object):
312  """Proxy of C++ std::ostream class"""
313  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
314 
315  def __init__(self, *args, **kwargs):
316  raise AttributeError("No constructor defined")
317  __repr__ = _swig_repr
318 
319  def write(self, osa_buf):
320  """write(_ostream self, char const * osa_buf)"""
321  return _IMP_algebra._ostream_write(self, osa_buf)
322 
323 _ostream_swigregister = _IMP_algebra._ostream_swigregister
324 _ostream_swigregister(_ostream)
325 
326 
327 _IMP_algebra.IMP_HAS_NOEXCEPT_swigconstant(_IMP_algebra)
328 IMP_HAS_NOEXCEPT = _IMP_algebra.IMP_HAS_NOEXCEPT
329 
330 _IMP_algebra.IMP_C_OPEN_BINARY_swigconstant(_IMP_algebra)
331 IMP_C_OPEN_BINARY = _IMP_algebra.IMP_C_OPEN_BINARY
332 import IMP
333 
334 _IMP_algebra.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_algebra)
335 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_FILESYSTEM
336 
337 _IMP_algebra.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_algebra)
338 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
339 
340 _IMP_algebra.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_algebra)
341 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_algebra.IMP_CGAL_HAS_BOOST_RANDOM
342 
343 _IMP_algebra.IMP_CGAL_HAS_BOOST_SERIALIZATION_swigconstant(_IMP_algebra)
344 IMP_CGAL_HAS_BOOST_SERIALIZATION = _IMP_algebra.IMP_CGAL_HAS_BOOST_SERIALIZATION
345 
346 _IMP_algebra.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_algebra)
347 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_CGAL_HAS_BOOST_SYSTEM
348 
349 _IMP_algebra.IMP_CGAL_HAS_NUMPY_swigconstant(_IMP_algebra)
350 IMP_CGAL_HAS_NUMPY = _IMP_algebra.IMP_CGAL_HAS_NUMPY
351 
352 _IMP_algebra.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_algebra)
353 IMPCGAL_SHOW_WARNINGS = _IMP_algebra.IMPCGAL_SHOW_WARNINGS
354 import IMP.cgal
355 
356 _IMP_algebra.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_algebra)
357 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_IMP_CGAL
358 
359 _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_algebra)
360 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
361 
362 _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_algebra)
363 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
364 
365 _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_algebra)
366 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_RANDOM
367 
368 _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SERIALIZATION_swigconstant(_IMP_algebra)
369 IMP_ALGEBRA_HAS_BOOST_SERIALIZATION = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SERIALIZATION
370 
371 _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_algebra)
372 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_algebra.IMP_ALGEBRA_HAS_BOOST_SYSTEM
373 
374 _IMP_algebra.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_algebra)
375 IMP_ALGEBRA_HAS_CGAL = _IMP_algebra.IMP_ALGEBRA_HAS_CGAL
376 
377 _IMP_algebra.IMP_ALGEBRA_HAS_NUMPY_swigconstant(_IMP_algebra)
378 IMP_ALGEBRA_HAS_NUMPY = _IMP_algebra.IMP_ALGEBRA_HAS_NUMPY
379 
380 _IMP_algebra.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_algebra)
381 IMP_ALGEBRA_HAS_ANN = _IMP_algebra.IMP_ALGEBRA_HAS_ANN
382 
383 _IMP_algebra.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_algebra)
384 IMPALGEBRA_SHOW_WARNINGS = _IMP_algebra.IMPALGEBRA_SHOW_WARNINGS
385 
386 def get_vector(v):
387  try:
388  return v.get_coordinates()
389  except:
390  return v
391 def get_sphere(v):
392  try:
393  return v.get_sphere()
394  except:
395  return v
396 
397 
398 _object_types.append("VectorKDMetric")
399 
400 
401 def _object_cast_to_VectorKDMetric(o):
402  """_object_cast_to_VectorKDMetric(Object o) -> VectorKDMetric"""
403  return _IMP_algebra._object_cast_to_VectorKDMetric(o)
404 
405 _object_types.append("EuclideanVectorKDMetric")
406 
407 
408 def _object_cast_to_EuclideanVectorKDMetric(o):
409  """_object_cast_to_EuclideanVectorKDMetric(Object o) -> EuclideanVectorKDMetric"""
410  return _IMP_algebra._object_cast_to_EuclideanVectorKDMetric(o)
411 
412 _object_types.append("MaxVectorKDMetric")
413 
414 
415 def _object_cast_to_MaxVectorKDMetric(o):
416  """_object_cast_to_MaxVectorKDMetric(Object o) -> MaxVectorKDMetric"""
417  return _IMP_algebra._object_cast_to_MaxVectorKDMetric(o)
418 
419 _object_types.append("DynamicNearestNeighbor3D")
420 
421 
422 def _object_cast_to_DynamicNearestNeighbor3D(o):
423  """_object_cast_to_DynamicNearestNeighbor3D(Object o) -> DynamicNearestNeighbor3D"""
424  return _IMP_algebra._object_cast_to_DynamicNearestNeighbor3D(o)
425 
426 Rotation2Ds=list
427 _plural_types.append("Rotation2Ds")
428 _value_types.append("Rotation2D")
429 
430 
431 Rotation3Ds=list
432 _plural_types.append("Rotation3Ds")
433 _value_types.append("Rotation3D")
434 
435 
436 Reflection3Ds=list
437 _plural_types.append("Reflection3Ds")
438 _value_types.append("Reflection3D")
439 
440 
441 Transformation2Ds=list
442 _plural_types.append("Transformation2Ds")
443 _value_types.append("Transformation2D")
444 
445 
446 Transformation3Ds=list
447 _plural_types.append("Transformation3Ds")
448 _value_types.append("Transformation3D")
449 
450 
451 SphericalVector3Ds=list
452 _plural_types.append("SphericalVector3Ds")
453 _value_types.append("SphericalVector3D")
454 
455 
456 Triangle3Ds=list
457 _plural_types.append("Triangle3Ds")
458 _value_types.append("Triangle3D")
459 
460 
461 Cone3Ds=list
462 _plural_types.append("Cone3Ds")
463 _value_types.append("Cone3D")
464 
465 
466 Cylinder3Ds=list
467 _plural_types.append("Cylinder3Ds")
468 _value_types.append("Cylinder3D")
469 
470 
471 Ellipsoid3Ds=list
472 _plural_types.append("Ellipsoid3Ds")
473 _value_types.append("Ellipsoid3D")
474 
475 
476 Line3Ds=list
477 _plural_types.append("Line3Ds")
478 _value_types.append("Line3D")
479 
480 
481 Plane3Ds=list
482 _plural_types.append("Plane3Ds")
483 _value_types.append("Plane3D")
484 
485 
486 Segment3Ds=list
487 _plural_types.append("Segment3Ds")
488 _value_types.append("Segment3D")
489 
490 
491 SpherePatch3Ds=list
492 _plural_types.append("SpherePatch3Ds")
493 _value_types.append("SpherePatch3D")
494 
495 
496 ConnollySurfacePoints=list
497 _plural_types.append("ConnollySurfacePoints")
498 _value_types.append("ConnollySurfacePoint")
499 
500 
501 Sphere1Ds=list
502 _plural_types.append("Sphere1Ds")
503 _value_types.append("Sphere1D")
504 
505 
506 Sphere2Ds=list
507 _plural_types.append("Sphere2Ds")
508 _value_types.append("Sphere2D")
509 
510 
511 Sphere3Ds=list
512 _plural_types.append("Sphere3Ds")
513 _value_types.append("Sphere3D")
514 
515 
516 Sphere4Ds=list
517 _plural_types.append("Sphere4Ds")
518 _value_types.append("Sphere4D")
519 
520 
521 Sphere5Ds=list
522 _plural_types.append("Sphere5Ds")
523 _value_types.append("Sphere5D")
524 
525 
526 Sphere6Ds=list
527 _plural_types.append("Sphere6Ds")
528 _value_types.append("Sphere6D")
529 
530 
531 Sphere1Ds=list
532 _plural_types.append("Sphere1Ds")
533 _value_types.append("SphereD<1>")
534 
535 
536 Sphere2Ds=list
537 _plural_types.append("Sphere2Ds")
538 _value_types.append("SphereD<2>")
539 
540 
541 Sphere3Ds=list
542 _plural_types.append("Sphere3Ds")
543 _value_types.append("SphereD<3>")
544 
545 
546 Sphere4Ds=list
547 _plural_types.append("Sphere4Ds")
548 _value_types.append("SphereD<4>")
549 
550 
551 Sphere5Ds=list
552 _plural_types.append("Sphere5Ds")
553 _value_types.append("SphereD<5>")
554 
555 
556 Sphere6Ds=list
557 _plural_types.append("Sphere6Ds")
558 _value_types.append("SphereD<6>")
559 
560 
561 SphereKDs=list
562 _plural_types.append("SphereKDs")
563 _value_types.append("SphereKD")
564 
565 
566 SphereKDs=list
567 _plural_types.append("SphereKDs")
568 _value_types.append("SphereD<-1>")
569 
570 
571 UnitSimplex1Ds=list
572 _plural_types.append("UnitSimplex1Ds")
573 _value_types.append("UnitSimplex1D")
574 
575 
576 UnitSimplex2Ds=list
577 _plural_types.append("UnitSimplex2Ds")
578 _value_types.append("UnitSimplex2D")
579 
580 
581 UnitSimplex3Ds=list
582 _plural_types.append("UnitSimplex3Ds")
583 _value_types.append("UnitSimplex3D")
584 
585 
586 UnitSimplex4Ds=list
587 _plural_types.append("UnitSimplex4Ds")
588 _value_types.append("UnitSimplex4D")
589 
590 
591 UnitSimplex5Ds=list
592 _plural_types.append("UnitSimplex5Ds")
593 _value_types.append("UnitSimplex5D")
594 
595 
596 UnitSimplex6Ds=list
597 _plural_types.append("UnitSimplex6Ds")
598 _value_types.append("UnitSimplex6D")
599 
600 
601 UnitSimplex1Ds=list
602 _plural_types.append("UnitSimplex1Ds")
603 _value_types.append("UnitSimplexD<1>")
604 
605 
606 UnitSimplex2Ds=list
607 _plural_types.append("UnitSimplex2Ds")
608 _value_types.append("UnitSimplexD<2>")
609 
610 
611 UnitSimplex3Ds=list
612 _plural_types.append("UnitSimplex3Ds")
613 _value_types.append("UnitSimplexD<3>")
614 
615 
616 UnitSimplex4Ds=list
617 _plural_types.append("UnitSimplex4Ds")
618 _value_types.append("UnitSimplexD<4>")
619 
620 
621 UnitSimplex5Ds=list
622 _plural_types.append("UnitSimplex5Ds")
623 _value_types.append("UnitSimplexD<5>")
624 
625 
626 UnitSimplex6Ds=list
627 _plural_types.append("UnitSimplex6Ds")
628 _value_types.append("UnitSimplexD<6>")
629 
630 
631 UnitSimplexKDs=list
632 _plural_types.append("UnitSimplexKDs")
633 _value_types.append("UnitSimplexKD")
634 
635 
636 UnitSimplexKDs=list
637 _plural_types.append("UnitSimplexKDs")
638 _value_types.append("UnitSimplexD<-1>")
639 
640 
641 BoundingBox1Ds=list
642 _plural_types.append("BoundingBox1Ds")
643 _value_types.append("BoundingBox1D")
644 
645 
646 BoundingBox2Ds=list
647 _plural_types.append("BoundingBox2Ds")
648 _value_types.append("BoundingBox2D")
649 
650 
651 BoundingBox3Ds=list
652 _plural_types.append("BoundingBox3Ds")
653 _value_types.append("BoundingBox3D")
654 
655 
656 BoundingBox4Ds=list
657 _plural_types.append("BoundingBox4Ds")
658 _value_types.append("BoundingBox4D")
659 
660 
661 BoundingBox5Ds=list
662 _plural_types.append("BoundingBox5Ds")
663 _value_types.append("BoundingBox5D")
664 
665 
666 BoundingBox6Ds=list
667 _plural_types.append("BoundingBox6Ds")
668 _value_types.append("BoundingBox6D")
669 
670 
671 BoundingBox1Ds=list
672 _plural_types.append("BoundingBox1Ds")
673 _value_types.append("BoundingBoxD<1>")
674 
675 
676 BoundingBox2Ds=list
677 _plural_types.append("BoundingBox2Ds")
678 _value_types.append("BoundingBoxD<2>")
679 
680 
681 BoundingBox3Ds=list
682 _plural_types.append("BoundingBox3Ds")
683 _value_types.append("BoundingBoxD<3>")
684 
685 
686 BoundingBox4Ds=list
687 _plural_types.append("BoundingBox4Ds")
688 _value_types.append("BoundingBoxD<4>")
689 
690 
691 BoundingBox5Ds=list
692 _plural_types.append("BoundingBox5Ds")
693 _value_types.append("BoundingBoxD<5>")
694 
695 
696 BoundingBox6Ds=list
697 _plural_types.append("BoundingBox6Ds")
698 _value_types.append("BoundingBoxD<6>")
699 
700 
701 BoundingBoxKDs=list
702 _plural_types.append("BoundingBoxKDs")
703 _value_types.append("BoundingBoxKD")
704 
705 
706 BoundingBoxKDs=list
707 _plural_types.append("BoundingBoxKDs")
708 _value_types.append("BoundingBoxD<-1>")
709 
710 
711 PrincipalComponentAnalysis1Ds=list
712 _plural_types.append("PrincipalComponentAnalysis1Ds")
713 _value_types.append("PrincipalComponentAnalysis1D")
714 
715 
716 PrincipalComponentAnalysis2Ds=list
717 _plural_types.append("PrincipalComponentAnalysis2Ds")
718 _value_types.append("PrincipalComponentAnalysis2D")
719 
720 
721 PrincipalComponentAnalysis3Ds=list
722 _plural_types.append("PrincipalComponentAnalysis3Ds")
723 _value_types.append("PrincipalComponentAnalysis3D")
724 
725 
726 PrincipalComponentAnalysis4Ds=list
727 _plural_types.append("PrincipalComponentAnalysis4Ds")
728 _value_types.append("PrincipalComponentAnalysis4D")
729 
730 
731 PrincipalComponentAnalysis5Ds=list
732 _plural_types.append("PrincipalComponentAnalysis5Ds")
733 _value_types.append("PrincipalComponentAnalysis5D")
734 
735 
736 PrincipalComponentAnalysis6Ds=list
737 _plural_types.append("PrincipalComponentAnalysis6Ds")
738 _value_types.append("PrincipalComponentAnalysis6D")
739 
740 
741 PrincipalComponentAnalysis1Ds=list
742 _plural_types.append("PrincipalComponentAnalysis1Ds")
743 _value_types.append("PrincipalComponentAnalysisD<1>")
744 
745 
746 PrincipalComponentAnalysis2Ds=list
747 _plural_types.append("PrincipalComponentAnalysis2Ds")
748 _value_types.append("PrincipalComponentAnalysisD<2>")
749 
750 
751 PrincipalComponentAnalysis3Ds=list
752 _plural_types.append("PrincipalComponentAnalysis3Ds")
753 _value_types.append("PrincipalComponentAnalysisD<3>")
754 
755 
756 PrincipalComponentAnalysis4Ds=list
757 _plural_types.append("PrincipalComponentAnalysis4Ds")
758 _value_types.append("PrincipalComponentAnalysisD<4>")
759 
760 
761 PrincipalComponentAnalysis5Ds=list
762 _plural_types.append("PrincipalComponentAnalysis5Ds")
763 _value_types.append("PrincipalComponentAnalysisD<5>")
764 
765 
766 PrincipalComponentAnalysis6Ds=list
767 _plural_types.append("PrincipalComponentAnalysis6Ds")
768 _value_types.append("PrincipalComponentAnalysisD<6>")
769 
770 
771 PrincipalComponentAnalysisKDs=list
772 _plural_types.append("PrincipalComponentAnalysisKDs")
773 _value_types.append("PrincipalComponentAnalysisKD")
774 
775 
776 PrincipalComponentAnalysisKDs=list
777 _plural_types.append("PrincipalComponentAnalysisKDs")
778 _value_types.append("PrincipalComponentAnalysisD<-1>")
779 
780 
781 _object_types.append("NearestNeighbor1D")
782 
783 
784 def _object_cast_to_NearestNeighbor1D(o):
785  """_object_cast_to_NearestNeighbor1D(Object o) -> NearestNeighbor1D"""
786  return _IMP_algebra._object_cast_to_NearestNeighbor1D(o)
787 
788 _object_types.append("NearestNeighbor2D")
789 
790 
791 def _object_cast_to_NearestNeighbor2D(o):
792  """_object_cast_to_NearestNeighbor2D(Object o) -> NearestNeighbor2D"""
793  return _IMP_algebra._object_cast_to_NearestNeighbor2D(o)
794 
795 _object_types.append("NearestNeighbor3D")
796 
797 
798 def _object_cast_to_NearestNeighbor3D(o):
799  """_object_cast_to_NearestNeighbor3D(Object o) -> NearestNeighbor3D"""
800  return _IMP_algebra._object_cast_to_NearestNeighbor3D(o)
801 
802 _object_types.append("NearestNeighbor4D")
803 
804 
805 def _object_cast_to_NearestNeighbor4D(o):
806  """_object_cast_to_NearestNeighbor4D(Object o) -> NearestNeighbor4D"""
807  return _IMP_algebra._object_cast_to_NearestNeighbor4D(o)
808 
809 _object_types.append("NearestNeighbor5D")
810 
811 
812 def _object_cast_to_NearestNeighbor5D(o):
813  """_object_cast_to_NearestNeighbor5D(Object o) -> NearestNeighbor5D"""
814  return _IMP_algebra._object_cast_to_NearestNeighbor5D(o)
815 
816 _object_types.append("NearestNeighbor6D")
817 
818 
819 def _object_cast_to_NearestNeighbor6D(o):
820  """_object_cast_to_NearestNeighbor6D(Object o) -> NearestNeighbor6D"""
821  return _IMP_algebra._object_cast_to_NearestNeighbor6D(o)
822 
823 _object_types.append("NearestNeighborKD")
824 
825 
826 def _object_cast_to_NearestNeighborKD(o):
827  """_object_cast_to_NearestNeighborKD(Object o) -> NearestNeighborKD"""
828  return _IMP_algebra._object_cast_to_NearestNeighborKD(o)
829 
830 ReferenceFrame3Ds=list
831 _plural_types.append("ReferenceFrame3Ds")
832 _value_types.append("ReferenceFrame3D")
833 
834 
835 Gaussian3Ds=list
836 _plural_types.append("Gaussian3Ds")
837 _value_types.append("Gaussian3D")
838 
839 
840 DefaultEmbedding1Ds=list
841 _plural_types.append("DefaultEmbedding1Ds")
842 _value_types.append("DefaultEmbedding1D")
843 
844 
845 DefaultEmbedding2Ds=list
846 _plural_types.append("DefaultEmbedding2Ds")
847 _value_types.append("DefaultEmbedding2D")
848 
849 
850 DefaultEmbedding3Ds=list
851 _plural_types.append("DefaultEmbedding3Ds")
852 _value_types.append("DefaultEmbedding3D")
853 
854 
855 DefaultEmbedding4Ds=list
856 _plural_types.append("DefaultEmbedding4Ds")
857 _value_types.append("DefaultEmbedding4D")
858 
859 
860 DefaultEmbedding5Ds=list
861 _plural_types.append("DefaultEmbedding5Ds")
862 _value_types.append("DefaultEmbedding5D")
863 
864 
865 DefaultEmbedding6Ds=list
866 _plural_types.append("DefaultEmbedding6Ds")
867 _value_types.append("DefaultEmbedding6D")
868 
869 
870 DefaultEmbedding1Ds=list
871 _plural_types.append("DefaultEmbedding1Ds")
872 _value_types.append("DefaultEmbeddingD<1>")
873 
874 
875 DefaultEmbedding2Ds=list
876 _plural_types.append("DefaultEmbedding2Ds")
877 _value_types.append("DefaultEmbeddingD<2>")
878 
879 
880 DefaultEmbedding3Ds=list
881 _plural_types.append("DefaultEmbedding3Ds")
882 _value_types.append("DefaultEmbeddingD<3>")
883 
884 
885 DefaultEmbedding4Ds=list
886 _plural_types.append("DefaultEmbedding4Ds")
887 _value_types.append("DefaultEmbeddingD<4>")
888 
889 
890 DefaultEmbedding5Ds=list
891 _plural_types.append("DefaultEmbedding5Ds")
892 _value_types.append("DefaultEmbeddingD<5>")
893 
894 
895 DefaultEmbedding6Ds=list
896 _plural_types.append("DefaultEmbedding6Ds")
897 _value_types.append("DefaultEmbeddingD<6>")
898 
899 
900 DefaultEmbeddingKDs=list
901 _plural_types.append("DefaultEmbeddingKDs")
902 _value_types.append("DefaultEmbeddingKD")
903 
904 
905 DefaultEmbeddingKDs=list
906 _plural_types.append("DefaultEmbeddingKDs")
907 _value_types.append("DefaultEmbeddingD<-1>")
908 
909 
910 LogEmbedding1Ds=list
911 _plural_types.append("LogEmbedding1Ds")
912 _value_types.append("LogEmbedding1D")
913 
914 
915 LogEmbedding2Ds=list
916 _plural_types.append("LogEmbedding2Ds")
917 _value_types.append("LogEmbedding2D")
918 
919 
920 LogEmbedding3Ds=list
921 _plural_types.append("LogEmbedding3Ds")
922 _value_types.append("LogEmbedding3D")
923 
924 
925 LogEmbedding4Ds=list
926 _plural_types.append("LogEmbedding4Ds")
927 _value_types.append("LogEmbedding4D")
928 
929 
930 LogEmbedding5Ds=list
931 _plural_types.append("LogEmbedding5Ds")
932 _value_types.append("LogEmbedding5D")
933 
934 
935 LogEmbedding6Ds=list
936 _plural_types.append("LogEmbedding6Ds")
937 _value_types.append("LogEmbedding6D")
938 
939 
940 LogEmbedding1Ds=list
941 _plural_types.append("LogEmbedding1Ds")
942 _value_types.append("LogEmbeddingD<1>")
943 
944 
945 LogEmbedding2Ds=list
946 _plural_types.append("LogEmbedding2Ds")
947 _value_types.append("LogEmbeddingD<2>")
948 
949 
950 LogEmbedding3Ds=list
951 _plural_types.append("LogEmbedding3Ds")
952 _value_types.append("LogEmbeddingD<3>")
953 
954 
955 LogEmbedding4Ds=list
956 _plural_types.append("LogEmbedding4Ds")
957 _value_types.append("LogEmbeddingD<4>")
958 
959 
960 LogEmbedding5Ds=list
961 _plural_types.append("LogEmbedding5Ds")
962 _value_types.append("LogEmbeddingD<5>")
963 
964 
965 LogEmbedding6Ds=list
966 _plural_types.append("LogEmbedding6Ds")
967 _value_types.append("LogEmbeddingD<6>")
968 
969 
970 LogEmbeddingKDs=list
971 _plural_types.append("LogEmbeddingKDs")
972 _value_types.append("LogEmbeddingKD")
973 
974 
975 LogEmbeddingKDs=list
976 _plural_types.append("LogEmbeddingKDs")
977 _value_types.append("LogEmbeddingD<-1>")
978 
979 
980 GridIndex1Ds=list
981 _plural_types.append("GridIndex1Ds")
982 _value_types.append("GridIndex1D")
983 
984 
985 GridIndex2Ds=list
986 _plural_types.append("GridIndex2Ds")
987 _value_types.append("GridIndex2D")
988 
989 
990 GridIndex3Ds=list
991 _plural_types.append("GridIndex3Ds")
992 _value_types.append("GridIndex3D")
993 
994 
995 GridIndex4Ds=list
996 _plural_types.append("GridIndex4Ds")
997 _value_types.append("GridIndex4D")
998 
999 
1000 GridIndex5Ds=list
1001 _plural_types.append("GridIndex5Ds")
1002 _value_types.append("GridIndex5D")
1003 
1004 
1005 GridIndex6Ds=list
1006 _plural_types.append("GridIndex6Ds")
1007 _value_types.append("GridIndex6D")
1008 
1009 
1010 GridIndex1Ds=list
1011 _plural_types.append("GridIndex1Ds")
1012 _value_types.append("GridIndexD<1>")
1013 
1014 
1015 GridIndex2Ds=list
1016 _plural_types.append("GridIndex2Ds")
1017 _value_types.append("GridIndexD<2>")
1018 
1019 
1020 GridIndex3Ds=list
1021 _plural_types.append("GridIndex3Ds")
1022 _value_types.append("GridIndexD<3>")
1023 
1024 
1025 GridIndex4Ds=list
1026 _plural_types.append("GridIndex4Ds")
1027 _value_types.append("GridIndexD<4>")
1028 
1029 
1030 GridIndex5Ds=list
1031 _plural_types.append("GridIndex5Ds")
1032 _value_types.append("GridIndexD<5>")
1033 
1034 
1035 GridIndex6Ds=list
1036 _plural_types.append("GridIndex6Ds")
1037 _value_types.append("GridIndexD<6>")
1038 
1039 
1040 GridIndexKDs=list
1041 _plural_types.append("GridIndexKDs")
1042 _value_types.append("GridIndexKD")
1043 
1044 
1045 GridIndexKDs=list
1046 _plural_types.append("GridIndexKDs")
1047 _value_types.append("GridIndexD<-1>")
1048 
1049 
1050 ExtendedGridIndex1Ds=list
1051 _plural_types.append("ExtendedGridIndex1Ds")
1052 _value_types.append("ExtendedGridIndex1D")
1053 
1054 
1055 ExtendedGridIndex2Ds=list
1056 _plural_types.append("ExtendedGridIndex2Ds")
1057 _value_types.append("ExtendedGridIndex2D")
1058 
1059 
1060 ExtendedGridIndex3Ds=list
1061 _plural_types.append("ExtendedGridIndex3Ds")
1062 _value_types.append("ExtendedGridIndex3D")
1063 
1064 
1065 ExtendedGridIndex4Ds=list
1066 _plural_types.append("ExtendedGridIndex4Ds")
1067 _value_types.append("ExtendedGridIndex4D")
1068 
1069 
1070 ExtendedGridIndex5Ds=list
1071 _plural_types.append("ExtendedGridIndex5Ds")
1072 _value_types.append("ExtendedGridIndex5D")
1073 
1074 
1075 ExtendedGridIndex6Ds=list
1076 _plural_types.append("ExtendedGridIndex6Ds")
1077 _value_types.append("ExtendedGridIndex6D")
1078 
1079 
1080 ExtendedGridIndex1Ds=list
1081 _plural_types.append("ExtendedGridIndex1Ds")
1082 _value_types.append("ExtendedGridIndexD<1>")
1083 
1084 
1085 ExtendedGridIndex2Ds=list
1086 _plural_types.append("ExtendedGridIndex2Ds")
1087 _value_types.append("ExtendedGridIndexD<2>")
1088 
1089 
1090 ExtendedGridIndex3Ds=list
1091 _plural_types.append("ExtendedGridIndex3Ds")
1092 _value_types.append("ExtendedGridIndexD<3>")
1093 
1094 
1095 ExtendedGridIndex4Ds=list
1096 _plural_types.append("ExtendedGridIndex4Ds")
1097 _value_types.append("ExtendedGridIndexD<4>")
1098 
1099 
1100 ExtendedGridIndex5Ds=list
1101 _plural_types.append("ExtendedGridIndex5Ds")
1102 _value_types.append("ExtendedGridIndexD<5>")
1103 
1104 
1105 ExtendedGridIndex6Ds=list
1106 _plural_types.append("ExtendedGridIndex6Ds")
1107 _value_types.append("ExtendedGridIndexD<6>")
1108 
1109 
1110 ExtendedGridIndexKDs=list
1111 _plural_types.append("ExtendedGridIndexKDs")
1112 _value_types.append("ExtendedGridIndexKD")
1113 
1114 
1115 ExtendedGridIndexKDs=list
1116 _plural_types.append("ExtendedGridIndexKDs")
1117 _value_types.append("ExtendedGridIndexD<-1>")
1118 
1119 
1120 BoundedGridRange1Ds=list
1121 _plural_types.append("BoundedGridRange1Ds")
1122 _value_types.append("BoundedGridRange1D")
1123 
1124 
1125 BoundedGridRange2Ds=list
1126 _plural_types.append("BoundedGridRange2Ds")
1127 _value_types.append("BoundedGridRange2D")
1128 
1129 
1130 BoundedGridRange3Ds=list
1131 _plural_types.append("BoundedGridRange3Ds")
1132 _value_types.append("BoundedGridRange3D")
1133 
1134 
1135 BoundedGridRange4Ds=list
1136 _plural_types.append("BoundedGridRange4Ds")
1137 _value_types.append("BoundedGridRange4D")
1138 
1139 
1140 BoundedGridRange5Ds=list
1141 _plural_types.append("BoundedGridRange5Ds")
1142 _value_types.append("BoundedGridRange5D")
1143 
1144 
1145 BoundedGridRange6Ds=list
1146 _plural_types.append("BoundedGridRange6Ds")
1147 _value_types.append("BoundedGridRange6D")
1148 
1149 
1150 BoundedGridRange1Ds=list
1151 _plural_types.append("BoundedGridRange1Ds")
1152 _value_types.append("BoundedGridRangeD<1>")
1153 
1154 
1155 BoundedGridRange2Ds=list
1156 _plural_types.append("BoundedGridRange2Ds")
1157 _value_types.append("BoundedGridRangeD<2>")
1158 
1159 
1160 BoundedGridRange3Ds=list
1161 _plural_types.append("BoundedGridRange3Ds")
1162 _value_types.append("BoundedGridRangeD<3>")
1163 
1164 
1165 BoundedGridRange4Ds=list
1166 _plural_types.append("BoundedGridRange4Ds")
1167 _value_types.append("BoundedGridRangeD<4>")
1168 
1169 
1170 BoundedGridRange5Ds=list
1171 _plural_types.append("BoundedGridRange5Ds")
1172 _value_types.append("BoundedGridRangeD<5>")
1173 
1174 
1175 BoundedGridRange6Ds=list
1176 _plural_types.append("BoundedGridRange6Ds")
1177 _value_types.append("BoundedGridRangeD<6>")
1178 
1179 
1180 BoundedGridRangeKDs=list
1181 _plural_types.append("BoundedGridRangeKDs")
1182 _value_types.append("BoundedGridRangeKD")
1183 
1184 
1185 BoundedGridRangeKDs=list
1186 _plural_types.append("BoundedGridRangeKDs")
1187 _value_types.append("BoundedGridRangeD<-1>")
1188 
1189 
1190 UnboundedGridRange1Ds=list
1191 _plural_types.append("UnboundedGridRange1Ds")
1192 _value_types.append("UnboundedGridRange1D")
1193 
1194 
1195 UnboundedGridRange2Ds=list
1196 _plural_types.append("UnboundedGridRange2Ds")
1197 _value_types.append("UnboundedGridRange2D")
1198 
1199 
1200 UnboundedGridRange3Ds=list
1201 _plural_types.append("UnboundedGridRange3Ds")
1202 _value_types.append("UnboundedGridRange3D")
1203 
1204 
1205 UnboundedGridRange4Ds=list
1206 _plural_types.append("UnboundedGridRange4Ds")
1207 _value_types.append("UnboundedGridRange4D")
1208 
1209 
1210 UnboundedGridRange5Ds=list
1211 _plural_types.append("UnboundedGridRange5Ds")
1212 _value_types.append("UnboundedGridRange5D")
1213 
1214 
1215 UnboundedGridRange6Ds=list
1216 _plural_types.append("UnboundedGridRange6Ds")
1217 _value_types.append("UnboundedGridRange6D")
1218 
1219 
1220 UnboundedGridRange1Ds=list
1221 _plural_types.append("UnboundedGridRange1Ds")
1222 _value_types.append("UnboundedGridRangeD<1>")
1223 
1224 
1225 UnboundedGridRange2Ds=list
1226 _plural_types.append("UnboundedGridRange2Ds")
1227 _value_types.append("UnboundedGridRangeD<2>")
1228 
1229 
1230 UnboundedGridRange3Ds=list
1231 _plural_types.append("UnboundedGridRange3Ds")
1232 _value_types.append("UnboundedGridRangeD<3>")
1233 
1234 
1235 UnboundedGridRange4Ds=list
1236 _plural_types.append("UnboundedGridRange4Ds")
1237 _value_types.append("UnboundedGridRangeD<4>")
1238 
1239 
1240 UnboundedGridRange5Ds=list
1241 _plural_types.append("UnboundedGridRange5Ds")
1242 _value_types.append("UnboundedGridRangeD<5>")
1243 
1244 
1245 UnboundedGridRange6Ds=list
1246 _plural_types.append("UnboundedGridRange6Ds")
1247 _value_types.append("UnboundedGridRangeD<6>")
1248 
1249 
1250 UnboundedGridRangeKDs=list
1251 _plural_types.append("UnboundedGridRangeKDs")
1252 _value_types.append("UnboundedGridRangeKD")
1253 
1254 
1255 UnboundedGridRangeKDs=list
1256 _plural_types.append("UnboundedGridRangeKDs")
1257 _value_types.append("UnboundedGridRangeD<-1>")
1258 
1259 
1260 LinearFit2Ds=list
1261 _plural_types.append("LinearFit2Ds")
1262 _value_types.append("LinearFit2D")
1263 
1264 
1265 ParabolicFit2Ds=list
1266 _plural_types.append("ParabolicFit2Ds")
1267 _value_types.append("ParabolicFit2D")
1268 
1269 
1270 FixedXYZs=list
1271 _plural_types.append("FixedXYZs")
1272 _value_types.append("FixedXYZ")
1273 
1274 class _GeometricPrimitive1D(object):
1275  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(1)> class"""
1276  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1277 
1278  def __init__(self, *args, **kwargs):
1279  raise AttributeError("No constructor defined")
1280  __repr__ = _swig_repr
1281  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive1D
1282  __del__ = lambda self: None
1283 _GeometricPrimitive1D_swigregister = _IMP_algebra._GeometricPrimitive1D_swigregister
1284 _GeometricPrimitive1D_swigregister(_GeometricPrimitive1D)
1285 
1286 class _GeometricPrimitive2D(object):
1287  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(2)> class"""
1288  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1289 
1290  def __init__(self, *args, **kwargs):
1291  raise AttributeError("No constructor defined")
1292  __repr__ = _swig_repr
1293  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive2D
1294  __del__ = lambda self: None
1295 _GeometricPrimitive2D_swigregister = _IMP_algebra._GeometricPrimitive2D_swigregister
1296 _GeometricPrimitive2D_swigregister(_GeometricPrimitive2D)
1297 
1298 class _GeometricPrimitive3D(object):
1299  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(3)> class"""
1300  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1301 
1302  def __init__(self, *args, **kwargs):
1303  raise AttributeError("No constructor defined")
1304  __repr__ = _swig_repr
1305  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive3D
1306  __del__ = lambda self: None
1307 _GeometricPrimitive3D_swigregister = _IMP_algebra._GeometricPrimitive3D_swigregister
1308 _GeometricPrimitive3D_swigregister(_GeometricPrimitive3D)
1309 
1310 class _GeometricPrimitive4D(object):
1311  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(4)> class"""
1312  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1313 
1314  def __init__(self, *args, **kwargs):
1315  raise AttributeError("No constructor defined")
1316  __repr__ = _swig_repr
1317  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive4D
1318  __del__ = lambda self: None
1319 _GeometricPrimitive4D_swigregister = _IMP_algebra._GeometricPrimitive4D_swigregister
1320 _GeometricPrimitive4D_swigregister(_GeometricPrimitive4D)
1321 
1322 class _GeometricPrimitive5D(object):
1323  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(5)> class"""
1324  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1325 
1326  def __init__(self, *args, **kwargs):
1327  raise AttributeError("No constructor defined")
1328  __repr__ = _swig_repr
1329  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive5D
1330  __del__ = lambda self: None
1331 _GeometricPrimitive5D_swigregister = _IMP_algebra._GeometricPrimitive5D_swigregister
1332 _GeometricPrimitive5D_swigregister(_GeometricPrimitive5D)
1333 
1334 class _GeometricPrimitive6D(object):
1335  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(6)> class"""
1336  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1337 
1338  def __init__(self, *args, **kwargs):
1339  raise AttributeError("No constructor defined")
1340  __repr__ = _swig_repr
1341  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitive6D
1342  __del__ = lambda self: None
1343 _GeometricPrimitive6D_swigregister = _IMP_algebra._GeometricPrimitive6D_swigregister
1344 _GeometricPrimitive6D_swigregister(_GeometricPrimitive6D)
1345 
1346 class _GeometricPrimitiveKD(object):
1347  """Proxy of C++ IMP::algebra::GeometricPrimitiveD<(-1)> class"""
1348  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1349 
1350  def __init__(self, *args, **kwargs):
1351  raise AttributeError("No constructor defined")
1352  __repr__ = _swig_repr
1353  __swig_destroy__ = _IMP_algebra.delete__GeometricPrimitiveKD
1354  __del__ = lambda self: None
1355 _GeometricPrimitiveKD_swigregister = _IMP_algebra._GeometricPrimitiveKD_swigregister
1356 _GeometricPrimitiveKD_swigregister(_GeometricPrimitiveKD)
1357 
1358 
1359 Vector1Ds=list
1360 _plural_types.append("Vector1Ds")
1361 _value_types.append("Vector1D")
1362 
1363 
1364 Vector2Ds=list
1365 _plural_types.append("Vector2Ds")
1366 _value_types.append("Vector2D")
1367 
1368 
1369 Vector3Ds=list
1370 _plural_types.append("Vector3Ds")
1371 _value_types.append("Vector3D")
1372 
1373 
1374 Vector4Ds=list
1375 _plural_types.append("Vector4Ds")
1376 _value_types.append("Vector4D")
1377 
1378 
1379 Vector5Ds=list
1380 _plural_types.append("Vector5Ds")
1381 _value_types.append("Vector5D")
1382 
1383 
1384 Vector6Ds=list
1385 _plural_types.append("Vector6Ds")
1386 _value_types.append("Vector6D")
1387 
1388 
1389 Vector1Ds=list
1390 _plural_types.append("Vector1Ds")
1391 _value_types.append("VectorD<1>")
1392 
1393 
1394 Vector2Ds=list
1395 _plural_types.append("Vector2Ds")
1396 _value_types.append("VectorD<2>")
1397 
1398 
1399 Vector3Ds=list
1400 _plural_types.append("Vector3Ds")
1401 _value_types.append("VectorD<3>")
1402 
1403 
1404 Vector4Ds=list
1405 _plural_types.append("Vector4Ds")
1406 _value_types.append("VectorD<4>")
1407 
1408 
1409 Vector5Ds=list
1410 _plural_types.append("Vector5Ds")
1411 _value_types.append("VectorD<5>")
1412 
1413 
1414 Vector6Ds=list
1415 _plural_types.append("Vector6Ds")
1416 _value_types.append("VectorD<6>")
1417 
1418 
1419 VectorKDs=list
1420 _plural_types.append("VectorKDs")
1421 _value_types.append("VectorKD")
1422 
1423 
1424 VectorKDs=list
1425 _plural_types.append("VectorKDs")
1426 _value_types.append("VectorD<-1>")
1427 
1428 class _VectorBaseKD(_GeometricPrimitiveKD):
1429  """Proxy of C++ IMP::algebra::VectorBaseD<(-1)> class"""
1430  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1431  __repr__ = _swig_repr
1432 
1433  def __init__(self):
1434  """__init__(IMP::algebra::VectorBaseD<(-1)> self) -> _VectorBaseKD"""
1435  this = _IMP_algebra.new__VectorBaseKD()
1436  try:
1437  self.this.append(this)
1438  except:
1439  self.this = this
1440 
1441  def get_scalar_product(self, o):
1442  """get_scalar_product(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1443  return _IMP_algebra._VectorBaseKD_get_scalar_product(self, o)
1444 
1445 
1446  def get_squared_magnitude(self):
1447  """get_squared_magnitude(_VectorBaseKD self) -> double"""
1448  return _IMP_algebra._VectorBaseKD_get_squared_magnitude(self)
1449 
1450 
1451  def get_magnitude(self):
1452  """get_magnitude(_VectorBaseKD self) -> double"""
1453  return _IMP_algebra._VectorBaseKD_get_magnitude(self)
1454 
1455 
1456  def __mul__(self, o):
1457  """__mul__(_VectorBaseKD self, _VectorBaseKD o) -> double"""
1458  return _IMP_algebra._VectorBaseKD___mul__(self, o)
1459 
1460 
1461  def __iadd__(self, o):
1462  """__iadd__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1463  return _IMP_algebra._VectorBaseKD___iadd__(self, o)
1464 
1465 
1466  def __isub__(self, o):
1467  """__isub__(_VectorBaseKD self, _VectorBaseKD o) -> _VectorBaseKD"""
1468  return _IMP_algebra._VectorBaseKD___isub__(self, o)
1469 
1470 
1471  def __idiv__(self, f):
1472  """__idiv__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1473  return _IMP_algebra._VectorBaseKD___idiv__(self, f)
1474 
1475 
1476  def __imul__(self, f):
1477  """__imul__(_VectorBaseKD self, double f) -> _VectorBaseKD"""
1478  return _IMP_algebra._VectorBaseKD___imul__(self, f)
1479 
1480 
1481  def show(self, *args):
1482  """
1483  show(_VectorBaseKD self, _ostream out, std::string delim, bool parens=True)
1484  show(_VectorBaseKD self, _ostream out, std::string delim)
1485  show(_VectorBaseKD self, _ostream out)
1486  show(_VectorBaseKD self)
1487  """
1488  return _IMP_algebra._VectorBaseKD_show(self, *args)
1489 
1490 
1491  def get_dimension(self):
1492  """get_dimension(_VectorBaseKD self) -> unsigned int"""
1493  return _IMP_algebra._VectorBaseKD_get_dimension(self)
1494 
1495  __swig_destroy__ = _IMP_algebra.delete__VectorBaseKD
1496  __del__ = lambda self: None
1497 _VectorBaseKD_swigregister = _IMP_algebra._VectorBaseKD_swigregister
1498 _VectorBaseKD_swigregister(_VectorBaseKD)
1499 
1500 class _VectorBase1D(_GeometricPrimitive1D):
1501  """Proxy of C++ IMP::algebra::VectorBaseD<(1)> class"""
1502  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1503  __repr__ = _swig_repr
1504 
1505  def __init__(self):
1506  """__init__(IMP::algebra::VectorBaseD<(1)> self) -> _VectorBase1D"""
1507  this = _IMP_algebra.new__VectorBase1D()
1508  try:
1509  self.this.append(this)
1510  except:
1511  self.this = this
1512 
1513  def get_scalar_product(self, o):
1514  """get_scalar_product(_VectorBase1D self, _VectorBase1D o) -> double"""
1515  return _IMP_algebra._VectorBase1D_get_scalar_product(self, o)
1516 
1517 
1518  def get_squared_magnitude(self):
1519  """get_squared_magnitude(_VectorBase1D self) -> double"""
1520  return _IMP_algebra._VectorBase1D_get_squared_magnitude(self)
1521 
1522 
1523  def get_magnitude(self):
1524  """get_magnitude(_VectorBase1D self) -> double"""
1525  return _IMP_algebra._VectorBase1D_get_magnitude(self)
1526 
1527 
1528  def __mul__(self, o):
1529  """__mul__(_VectorBase1D self, _VectorBase1D o) -> double"""
1530  return _IMP_algebra._VectorBase1D___mul__(self, o)
1531 
1532 
1533  def __iadd__(self, o):
1534  """__iadd__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1535  return _IMP_algebra._VectorBase1D___iadd__(self, o)
1536 
1537 
1538  def __isub__(self, o):
1539  """__isub__(_VectorBase1D self, _VectorBase1D o) -> _VectorBase1D"""
1540  return _IMP_algebra._VectorBase1D___isub__(self, o)
1541 
1542 
1543  def __idiv__(self, f):
1544  """__idiv__(_VectorBase1D self, double f) -> _VectorBase1D"""
1545  return _IMP_algebra._VectorBase1D___idiv__(self, f)
1546 
1547 
1548  def __imul__(self, f):
1549  """__imul__(_VectorBase1D self, double f) -> _VectorBase1D"""
1550  return _IMP_algebra._VectorBase1D___imul__(self, f)
1551 
1552 
1553  def show(self, *args):
1554  """
1555  show(_VectorBase1D self, _ostream out, std::string delim, bool parens=True)
1556  show(_VectorBase1D self, _ostream out, std::string delim)
1557  show(_VectorBase1D self, _ostream out)
1558  show(_VectorBase1D self)
1559  """
1560  return _IMP_algebra._VectorBase1D_show(self, *args)
1561 
1562 
1563  def get_dimension(self):
1564  """get_dimension(_VectorBase1D self) -> unsigned int"""
1565  return _IMP_algebra._VectorBase1D_get_dimension(self)
1566 
1567  __swig_destroy__ = _IMP_algebra.delete__VectorBase1D
1568  __del__ = lambda self: None
1569 _VectorBase1D_swigregister = _IMP_algebra._VectorBase1D_swigregister
1570 _VectorBase1D_swigregister(_VectorBase1D)
1571 
1572 class _VectorBase2D(_GeometricPrimitive2D):
1573  """Proxy of C++ IMP::algebra::VectorBaseD<(2)> class"""
1574  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1575  __repr__ = _swig_repr
1576 
1577  def __init__(self):
1578  """__init__(IMP::algebra::VectorBaseD<(2)> self) -> _VectorBase2D"""
1579  this = _IMP_algebra.new__VectorBase2D()
1580  try:
1581  self.this.append(this)
1582  except:
1583  self.this = this
1584 
1585  def get_scalar_product(self, o):
1586  """get_scalar_product(_VectorBase2D self, _VectorBase2D o) -> double"""
1587  return _IMP_algebra._VectorBase2D_get_scalar_product(self, o)
1588 
1589 
1590  def get_squared_magnitude(self):
1591  """get_squared_magnitude(_VectorBase2D self) -> double"""
1592  return _IMP_algebra._VectorBase2D_get_squared_magnitude(self)
1593 
1594 
1595  def get_magnitude(self):
1596  """get_magnitude(_VectorBase2D self) -> double"""
1597  return _IMP_algebra._VectorBase2D_get_magnitude(self)
1598 
1599 
1600  def __mul__(self, o):
1601  """__mul__(_VectorBase2D self, _VectorBase2D o) -> double"""
1602  return _IMP_algebra._VectorBase2D___mul__(self, o)
1603 
1604 
1605  def __iadd__(self, o):
1606  """__iadd__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1607  return _IMP_algebra._VectorBase2D___iadd__(self, o)
1608 
1609 
1610  def __isub__(self, o):
1611  """__isub__(_VectorBase2D self, _VectorBase2D o) -> _VectorBase2D"""
1612  return _IMP_algebra._VectorBase2D___isub__(self, o)
1613 
1614 
1615  def __idiv__(self, f):
1616  """__idiv__(_VectorBase2D self, double f) -> _VectorBase2D"""
1617  return _IMP_algebra._VectorBase2D___idiv__(self, f)
1618 
1619 
1620  def __imul__(self, f):
1621  """__imul__(_VectorBase2D self, double f) -> _VectorBase2D"""
1622  return _IMP_algebra._VectorBase2D___imul__(self, f)
1623 
1624 
1625  def show(self, *args):
1626  """
1627  show(_VectorBase2D self, _ostream out, std::string delim, bool parens=True)
1628  show(_VectorBase2D self, _ostream out, std::string delim)
1629  show(_VectorBase2D self, _ostream out)
1630  show(_VectorBase2D self)
1631  """
1632  return _IMP_algebra._VectorBase2D_show(self, *args)
1633 
1634 
1635  def get_dimension(self):
1636  """get_dimension(_VectorBase2D self) -> unsigned int"""
1637  return _IMP_algebra._VectorBase2D_get_dimension(self)
1638 
1639  __swig_destroy__ = _IMP_algebra.delete__VectorBase2D
1640  __del__ = lambda self: None
1641 _VectorBase2D_swigregister = _IMP_algebra._VectorBase2D_swigregister
1642 _VectorBase2D_swigregister(_VectorBase2D)
1643 
1644 class _VectorBase3D(_GeometricPrimitive3D):
1645  """Proxy of C++ IMP::algebra::VectorBaseD<(3)> class"""
1646  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1647  __repr__ = _swig_repr
1648 
1649  def __init__(self):
1650  """__init__(IMP::algebra::VectorBaseD<(3)> self) -> _VectorBase3D"""
1651  this = _IMP_algebra.new__VectorBase3D()
1652  try:
1653  self.this.append(this)
1654  except:
1655  self.this = this
1656 
1657  def get_scalar_product(self, o):
1658  """get_scalar_product(_VectorBase3D self, _VectorBase3D o) -> double"""
1659  return _IMP_algebra._VectorBase3D_get_scalar_product(self, o)
1660 
1661 
1662  def get_squared_magnitude(self):
1663  """get_squared_magnitude(_VectorBase3D self) -> double"""
1664  return _IMP_algebra._VectorBase3D_get_squared_magnitude(self)
1665 
1666 
1667  def get_magnitude(self):
1668  """get_magnitude(_VectorBase3D self) -> double"""
1669  return _IMP_algebra._VectorBase3D_get_magnitude(self)
1670 
1671 
1672  def __mul__(self, o):
1673  """__mul__(_VectorBase3D self, _VectorBase3D o) -> double"""
1674  return _IMP_algebra._VectorBase3D___mul__(self, o)
1675 
1676 
1677  def __iadd__(self, o):
1678  """__iadd__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1679  return _IMP_algebra._VectorBase3D___iadd__(self, o)
1680 
1681 
1682  def __isub__(self, o):
1683  """__isub__(_VectorBase3D self, _VectorBase3D o) -> _VectorBase3D"""
1684  return _IMP_algebra._VectorBase3D___isub__(self, o)
1685 
1686 
1687  def __idiv__(self, f):
1688  """__idiv__(_VectorBase3D self, double f) -> _VectorBase3D"""
1689  return _IMP_algebra._VectorBase3D___idiv__(self, f)
1690 
1691 
1692  def __imul__(self, f):
1693  """__imul__(_VectorBase3D self, double f) -> _VectorBase3D"""
1694  return _IMP_algebra._VectorBase3D___imul__(self, f)
1695 
1696 
1697  def show(self, *args):
1698  """
1699  show(_VectorBase3D self, _ostream out, std::string delim, bool parens=True)
1700  show(_VectorBase3D self, _ostream out, std::string delim)
1701  show(_VectorBase3D self, _ostream out)
1702  show(_VectorBase3D self)
1703  """
1704  return _IMP_algebra._VectorBase3D_show(self, *args)
1705 
1706 
1707  def get_dimension(self):
1708  """get_dimension(_VectorBase3D self) -> unsigned int"""
1709  return _IMP_algebra._VectorBase3D_get_dimension(self)
1710 
1711  __swig_destroy__ = _IMP_algebra.delete__VectorBase3D
1712  __del__ = lambda self: None
1713 _VectorBase3D_swigregister = _IMP_algebra._VectorBase3D_swigregister
1714 _VectorBase3D_swigregister(_VectorBase3D)
1715 
1716 class _VectorBase4D(_GeometricPrimitive4D):
1717  """Proxy of C++ IMP::algebra::VectorBaseD<(4)> class"""
1718  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1719  __repr__ = _swig_repr
1720 
1721  def __init__(self):
1722  """__init__(IMP::algebra::VectorBaseD<(4)> self) -> _VectorBase4D"""
1723  this = _IMP_algebra.new__VectorBase4D()
1724  try:
1725  self.this.append(this)
1726  except:
1727  self.this = this
1728 
1729  def get_scalar_product(self, o):
1730  """get_scalar_product(_VectorBase4D self, _VectorBase4D o) -> double"""
1731  return _IMP_algebra._VectorBase4D_get_scalar_product(self, o)
1732 
1733 
1734  def get_squared_magnitude(self):
1735  """get_squared_magnitude(_VectorBase4D self) -> double"""
1736  return _IMP_algebra._VectorBase4D_get_squared_magnitude(self)
1737 
1738 
1739  def get_magnitude(self):
1740  """get_magnitude(_VectorBase4D self) -> double"""
1741  return _IMP_algebra._VectorBase4D_get_magnitude(self)
1742 
1743 
1744  def __mul__(self, o):
1745  """__mul__(_VectorBase4D self, _VectorBase4D o) -> double"""
1746  return _IMP_algebra._VectorBase4D___mul__(self, o)
1747 
1748 
1749  def __iadd__(self, o):
1750  """__iadd__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1751  return _IMP_algebra._VectorBase4D___iadd__(self, o)
1752 
1753 
1754  def __isub__(self, o):
1755  """__isub__(_VectorBase4D self, _VectorBase4D o) -> _VectorBase4D"""
1756  return _IMP_algebra._VectorBase4D___isub__(self, o)
1757 
1758 
1759  def __idiv__(self, f):
1760  """__idiv__(_VectorBase4D self, double f) -> _VectorBase4D"""
1761  return _IMP_algebra._VectorBase4D___idiv__(self, f)
1762 
1763 
1764  def __imul__(self, f):
1765  """__imul__(_VectorBase4D self, double f) -> _VectorBase4D"""
1766  return _IMP_algebra._VectorBase4D___imul__(self, f)
1767 
1768 
1769  def show(self, *args):
1770  """
1771  show(_VectorBase4D self, _ostream out, std::string delim, bool parens=True)
1772  show(_VectorBase4D self, _ostream out, std::string delim)
1773  show(_VectorBase4D self, _ostream out)
1774  show(_VectorBase4D self)
1775  """
1776  return _IMP_algebra._VectorBase4D_show(self, *args)
1777 
1778 
1779  def get_dimension(self):
1780  """get_dimension(_VectorBase4D self) -> unsigned int"""
1781  return _IMP_algebra._VectorBase4D_get_dimension(self)
1782 
1783  __swig_destroy__ = _IMP_algebra.delete__VectorBase4D
1784  __del__ = lambda self: None
1785 _VectorBase4D_swigregister = _IMP_algebra._VectorBase4D_swigregister
1786 _VectorBase4D_swigregister(_VectorBase4D)
1787 
1788 class _VectorBase5D(_GeometricPrimitive5D):
1789  """Proxy of C++ IMP::algebra::VectorBaseD<(5)> class"""
1790  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1791  __repr__ = _swig_repr
1792 
1793  def __init__(self):
1794  """__init__(IMP::algebra::VectorBaseD<(5)> self) -> _VectorBase5D"""
1795  this = _IMP_algebra.new__VectorBase5D()
1796  try:
1797  self.this.append(this)
1798  except:
1799  self.this = this
1800 
1801  def get_scalar_product(self, o):
1802  """get_scalar_product(_VectorBase5D self, _VectorBase5D o) -> double"""
1803  return _IMP_algebra._VectorBase5D_get_scalar_product(self, o)
1804 
1805 
1806  def get_squared_magnitude(self):
1807  """get_squared_magnitude(_VectorBase5D self) -> double"""
1808  return _IMP_algebra._VectorBase5D_get_squared_magnitude(self)
1809 
1810 
1811  def get_magnitude(self):
1812  """get_magnitude(_VectorBase5D self) -> double"""
1813  return _IMP_algebra._VectorBase5D_get_magnitude(self)
1814 
1815 
1816  def __mul__(self, o):
1817  """__mul__(_VectorBase5D self, _VectorBase5D o) -> double"""
1818  return _IMP_algebra._VectorBase5D___mul__(self, o)
1819 
1820 
1821  def __iadd__(self, o):
1822  """__iadd__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1823  return _IMP_algebra._VectorBase5D___iadd__(self, o)
1824 
1825 
1826  def __isub__(self, o):
1827  """__isub__(_VectorBase5D self, _VectorBase5D o) -> _VectorBase5D"""
1828  return _IMP_algebra._VectorBase5D___isub__(self, o)
1829 
1830 
1831  def __idiv__(self, f):
1832  """__idiv__(_VectorBase5D self, double f) -> _VectorBase5D"""
1833  return _IMP_algebra._VectorBase5D___idiv__(self, f)
1834 
1835 
1836  def __imul__(self, f):
1837  """__imul__(_VectorBase5D self, double f) -> _VectorBase5D"""
1838  return _IMP_algebra._VectorBase5D___imul__(self, f)
1839 
1840 
1841  def show(self, *args):
1842  """
1843  show(_VectorBase5D self, _ostream out, std::string delim, bool parens=True)
1844  show(_VectorBase5D self, _ostream out, std::string delim)
1845  show(_VectorBase5D self, _ostream out)
1846  show(_VectorBase5D self)
1847  """
1848  return _IMP_algebra._VectorBase5D_show(self, *args)
1849 
1850 
1851  def get_dimension(self):
1852  """get_dimension(_VectorBase5D self) -> unsigned int"""
1853  return _IMP_algebra._VectorBase5D_get_dimension(self)
1854 
1855  __swig_destroy__ = _IMP_algebra.delete__VectorBase5D
1856  __del__ = lambda self: None
1857 _VectorBase5D_swigregister = _IMP_algebra._VectorBase5D_swigregister
1858 _VectorBase5D_swigregister(_VectorBase5D)
1859 
1860 class _VectorBase6D(_GeometricPrimitive6D):
1861  """Proxy of C++ IMP::algebra::VectorBaseD<(6)> class"""
1862  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1863  __repr__ = _swig_repr
1864 
1865  def __init__(self):
1866  """__init__(IMP::algebra::VectorBaseD<(6)> self) -> _VectorBase6D"""
1867  this = _IMP_algebra.new__VectorBase6D()
1868  try:
1869  self.this.append(this)
1870  except:
1871  self.this = this
1872 
1873  def get_scalar_product(self, o):
1874  """get_scalar_product(_VectorBase6D self, _VectorBase6D o) -> double"""
1875  return _IMP_algebra._VectorBase6D_get_scalar_product(self, o)
1876 
1877 
1878  def get_squared_magnitude(self):
1879  """get_squared_magnitude(_VectorBase6D self) -> double"""
1880  return _IMP_algebra._VectorBase6D_get_squared_magnitude(self)
1881 
1882 
1883  def get_magnitude(self):
1884  """get_magnitude(_VectorBase6D self) -> double"""
1885  return _IMP_algebra._VectorBase6D_get_magnitude(self)
1886 
1887 
1888  def __mul__(self, o):
1889  """__mul__(_VectorBase6D self, _VectorBase6D o) -> double"""
1890  return _IMP_algebra._VectorBase6D___mul__(self, o)
1891 
1892 
1893  def __iadd__(self, o):
1894  """__iadd__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1895  return _IMP_algebra._VectorBase6D___iadd__(self, o)
1896 
1897 
1898  def __isub__(self, o):
1899  """__isub__(_VectorBase6D self, _VectorBase6D o) -> _VectorBase6D"""
1900  return _IMP_algebra._VectorBase6D___isub__(self, o)
1901 
1902 
1903  def __idiv__(self, f):
1904  """__idiv__(_VectorBase6D self, double f) -> _VectorBase6D"""
1905  return _IMP_algebra._VectorBase6D___idiv__(self, f)
1906 
1907 
1908  def __imul__(self, f):
1909  """__imul__(_VectorBase6D self, double f) -> _VectorBase6D"""
1910  return _IMP_algebra._VectorBase6D___imul__(self, f)
1911 
1912 
1913  def show(self, *args):
1914  """
1915  show(_VectorBase6D self, _ostream out, std::string delim, bool parens=True)
1916  show(_VectorBase6D self, _ostream out, std::string delim)
1917  show(_VectorBase6D self, _ostream out)
1918  show(_VectorBase6D self)
1919  """
1920  return _IMP_algebra._VectorBase6D_show(self, *args)
1921 
1922 
1923  def get_dimension(self):
1924  """get_dimension(_VectorBase6D self) -> unsigned int"""
1925  return _IMP_algebra._VectorBase6D_get_dimension(self)
1926 
1927  __swig_destroy__ = _IMP_algebra.delete__VectorBase6D
1928  __del__ = lambda self: None
1929 _VectorBase6D_swigregister = _IMP_algebra._VectorBase6D_swigregister
1930 _VectorBase6D_swigregister(_VectorBase6D)
1931 
1932 
1933 def get_basis_vector_kd(D, coordinate):
1934  """get_basis_vector_kd(int D, unsigned int coordinate) -> VectorKD"""
1935  return _IMP_algebra.get_basis_vector_kd(D, coordinate)
1936 
1937 def get_zero_vector_kd(D):
1938  """get_zero_vector_kd(int D) -> VectorKD"""
1939  return _IMP_algebra.get_zero_vector_kd(D)
1940 
1941 def get_ones_vector_kd(D, v=1):
1942  """
1943  get_ones_vector_kd(unsigned int D, double v=1) -> VectorKD
1944  get_ones_vector_kd(unsigned int D) -> VectorKD
1945  """
1946  return _IMP_algebra.get_ones_vector_kd(D, v)
1947 
1948 def get_vector_product(p1, p2):
1949  """get_vector_product(Vector3D p1, Vector3D p2) -> Vector3D"""
1950  return _IMP_algebra.get_vector_product(p1, p2)
1951 
1952 def get_orthogonal_vector(v):
1953  """get_orthogonal_vector(Vector3D v) -> Vector3D"""
1954  return _IMP_algebra.get_orthogonal_vector(v)
1955 
1956 def get_centroid(ps):
1957  """get_centroid(IMP::algebra::Vector3Ds const & ps) -> Vector3D"""
1958  return _IMP_algebra.get_centroid(ps)
1959 
1960 def get_radius_of_gyration(ps):
1961  """get_radius_of_gyration(IMP::algebra::Vector3Ds const & ps) -> double"""
1962  return _IMP_algebra.get_radius_of_gyration(ps)
1963 class Rotation3D(_GeometricPrimitive3D):
1964  """Proxy of C++ IMP::algebra::Rotation3D class"""
1965  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1966 
1967  def __init__(self, *args):
1968  """
1969  __init__(IMP::algebra::Rotation3D self, Rotation3D rot) -> Rotation3D
1970  __init__(IMP::algebra::Rotation3D self, Vector4D v, bool assume_normalized=False) -> Rotation3D
1971  __init__(IMP::algebra::Rotation3D self, Vector4D v) -> Rotation3D
1972  __init__(IMP::algebra::Rotation3D self) -> Rotation3D
1973  __init__(IMP::algebra::Rotation3D self, double a, double b, double c, double d) -> Rotation3D
1974  """
1975  this = _IMP_algebra.new_Rotation3D(*args)
1976  try:
1977  self.this.append(this)
1978  except:
1979  self.this = this
1980  __swig_destroy__ = _IMP_algebra.delete_Rotation3D
1981  __del__ = lambda self: None
1982 
1983  def get_rotated_no_cache(self, o):
1984  """get_rotated_no_cache(Rotation3D self, Vector3D o) -> Vector3D"""
1985  return _IMP_algebra.Rotation3D_get_rotated_no_cache(self, o)
1986 
1987 
1988  def get_rotated_one_coordinate_no_cache(self, o, coord):
1989  """get_rotated_one_coordinate_no_cache(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
1990  return _IMP_algebra.Rotation3D_get_rotated_one_coordinate_no_cache(self, o, coord)
1991 
1992 
1993  def get_rotated(self, o):
1994  """get_rotated(Rotation3D self, Vector3D o) -> Vector3D"""
1995  return _IMP_algebra.Rotation3D_get_rotated(self, o)
1996 
1997 
1998  def get_rotated_adjoint(self, v, Dw):
1999  """get_rotated_adjoint(Rotation3D self, Vector3D v, Vector3D Dw) -> _RotatedVector3DAdjoint"""
2000  return _IMP_algebra.Rotation3D_get_rotated_adjoint(self, v, Dw)
2001 
2002 
2003  def get_rotated_one_coordinate(self, o, coord):
2004  """get_rotated_one_coordinate(Rotation3D self, Vector3D o, unsigned int coord) -> double"""
2005  return _IMP_algebra.Rotation3D_get_rotated_one_coordinate(self, o, coord)
2006 
2007 
2008  def get_rotation_matrix_row(self, i):
2009  """get_rotation_matrix_row(Rotation3D self, int i) -> Vector3D"""
2010  return _IMP_algebra.Rotation3D_get_rotation_matrix_row(self, i)
2011 
2012 
2013  def show(self, *args):
2014  """
2015  show(Rotation3D self, _ostream out)
2016  show(Rotation3D self)
2017  """
2018  return _IMP_algebra.Rotation3D_show(self, *args)
2019 
2020 
2021  def get_inverse(self):
2022  """get_inverse(Rotation3D self) -> Rotation3D"""
2023  return _IMP_algebra.Rotation3D_get_inverse(self)
2024 
2025 
2026  def get_quaternion(self):
2027  """get_quaternion(Rotation3D self) -> Vector4D"""
2028  return _IMP_algebra.Rotation3D_get_quaternion(self)
2029 
2030 
2031  def __mul__(self, *args):
2032  """
2033  __mul__(Rotation3D self, Vector3D v) -> Vector3D
2034  __mul__(Rotation3D self, Rotation3D q) -> Rotation3D
2035  """
2036  return _IMP_algebra.Rotation3D___mul__(self, *args)
2037 
2038 
2039  def __div__(self, r):
2040  """__div__(Rotation3D self, Rotation3D r) -> Rotation3D"""
2041  return _IMP_algebra.Rotation3D___div__(self, r)
2042 
2043 
2044  def get_gradient_of_rotated(self, v, i, wrt_unnorm=False):
2045  """
2046  get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=False) -> Vector3D
2047  get_gradient_of_rotated(Rotation3D self, Vector3D v, unsigned int i) -> Vector3D
2048  """
2049  return _IMP_algebra.Rotation3D_get_gradient_of_rotated(self, v, i, wrt_unnorm)
2050 
2051 
2052  def get_derivative(self, v, i, wrt_unnorm=True):
2053  """
2054  get_derivative(Rotation3D self, Vector3D v, unsigned int i, bool wrt_unnorm=True) -> Vector3D
2055  get_derivative(Rotation3D self, Vector3D v, unsigned int i) -> Vector3D
2056  """
2057  return _IMP_algebra.Rotation3D_get_derivative(self, v, i, wrt_unnorm)
2058 
2059 
2060  def get_jacobian_of_rotated(self, v, wrt_unnorm=False):
2061  """
2062  get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=False) -> Eigen::MatrixXd
2063  get_jacobian_of_rotated(Rotation3D self, Eigen::Vector3d const & v) -> Eigen::MatrixXd
2064  """
2065  return _IMP_algebra.Rotation3D_get_jacobian_of_rotated(self, v, wrt_unnorm)
2066 
2067 
2068  def get_gradient(self, v, wrt_unnorm=True):
2069  """
2070  get_gradient(Rotation3D self, Eigen::Vector3d const & v, bool wrt_unnorm=True) -> Eigen::MatrixXd
2071  get_gradient(Rotation3D self, Eigen::Vector3d const & v) -> Eigen::MatrixXd
2072  """
2073  return _IMP_algebra.Rotation3D_get_gradient(self, v, wrt_unnorm)
2074 
2075 
2076  def get_is_valid(self):
2077  """get_is_valid(Rotation3D self) -> bool"""
2078  return _IMP_algebra.Rotation3D_get_is_valid(self)
2079 
2080 
2081  def __str__(self):
2082  """__str__(Rotation3D self) -> std::string"""
2083  return _IMP_algebra.Rotation3D___str__(self)
2084 
2085 
2086  def __repr__(self):
2087  """__repr__(Rotation3D self) -> std::string"""
2088  return _IMP_algebra.Rotation3D___repr__(self)
2089 
2090 
2091  def _get_as_binary(self):
2092  """_get_as_binary(Rotation3D self) -> PyObject *"""
2093  return _IMP_algebra.Rotation3D__get_as_binary(self)
2094 
2095 
2096  def _set_from_binary(self, p):
2097  """_set_from_binary(Rotation3D self, PyObject * p)"""
2098  return _IMP_algebra.Rotation3D__set_from_binary(self, p)
2099 
2100 
2101  def __getstate__(self):
2102  p = self._get_as_binary()
2103  if len(self.__dict__) > 1:
2104  d = self.__dict__.copy()
2105  del d['this']
2106  p = (d, p)
2107  return p
2108 
2109  def __setstate__(self, p):
2110  if not hasattr(self, 'this'):
2111  self.__init__()
2112  if isinstance(p, tuple):
2113  d, p = p
2114  self.__dict__.update(d)
2115  return self._set_from_binary(p)
2116 
2117 
2118  __truediv__ = __div__
2119 
2120 Rotation3D_swigregister = _IMP_algebra.Rotation3D_swigregister
2121 Rotation3D_swigregister(Rotation3D)
2122 
2123 
2124 def get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm=False):
2125  """
2126  get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd
2127  get_jacobian_of_composed_wrt_first(Rotation3D q, Rotation3D p) -> Eigen::MatrixXd
2128  """
2129  return _IMP_algebra.get_jacobian_of_composed_wrt_first(q, p, wrt_unnorm)
2130 
2131 def get_gradient_of_composed_with_respect_to_first(q, p, wrt_unnorm=True):
2132  """
2133  get_gradient_of_composed_with_respect_to_first(Rotation3D q, Rotation3D p, bool wrt_unnorm=True) -> Eigen::MatrixXd
2134  get_gradient_of_composed_with_respect_to_first(Rotation3D q, Rotation3D p) -> Eigen::MatrixXd
2135  """
2136  return _IMP_algebra.get_gradient_of_composed_with_respect_to_first(q, p, wrt_unnorm)
2137 
2138 def get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm=False):
2139  """
2140  get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=False) -> Eigen::MatrixXd
2141  get_jacobian_of_composed_wrt_second(Rotation3D q, Rotation3D p) -> Eigen::MatrixXd
2142  """
2143  return _IMP_algebra.get_jacobian_of_composed_wrt_second(q, p, wrt_unnorm)
2144 
2145 def get_gradient_of_composed_with_respect_to_second(q, p, wrt_unnorm=True):
2146  """
2147  get_gradient_of_composed_with_respect_to_second(Rotation3D q, Rotation3D p, bool wrt_unnorm=True) -> Eigen::MatrixXd
2148  get_gradient_of_composed_with_respect_to_second(Rotation3D q, Rotation3D p) -> Eigen::MatrixXd
2149  """
2150  return _IMP_algebra.get_gradient_of_composed_with_respect_to_second(q, p, wrt_unnorm)
2151 
2152 def get_identity_rotation_3d():
2153  """get_identity_rotation_3d() -> Rotation3D"""
2154  return _IMP_algebra.get_identity_rotation_3d()
2155 
2156 def get_rotation_about_normalized_axis(axis_norm, angle):
2157  """get_rotation_about_normalized_axis(Vector3D axis_norm, double angle) -> Rotation3D"""
2158  return _IMP_algebra.get_rotation_about_normalized_axis(axis_norm, angle)
2159 
2160 def get_rotation_about_axis(axis, angle):
2161  """get_rotation_about_axis(Vector3D axis, double angle) -> Rotation3D"""
2162  return _IMP_algebra.get_rotation_about_axis(axis, angle)
2163 
2164 def get_rotation_taking_first_to_second(v1, v2):
2165  """get_rotation_taking_first_to_second(Vector3D v1, Vector3D v2) -> Rotation3D"""
2166  return _IMP_algebra.get_rotation_taking_first_to_second(v1, v2)
2167 
2168 def get_rotation_from_matrix(*args):
2169  """
2170  get_rotation_from_matrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22) -> Rotation3D
2171  get_rotation_from_matrix(Eigen::Matrix3d m) -> Rotation3D
2172  """
2173  return _IMP_algebra.get_rotation_from_matrix(*args)
2174 
2175 def get_random_rotation_3d(*args):
2176  """
2177  get_random_rotation_3d() -> Rotation3D
2178  get_random_rotation_3d(Rotation3D center, double distance) -> Rotation3D
2179  """
2180  return _IMP_algebra.get_random_rotation_3d(*args)
2181 
2182 def get_uniform_cover_rotations_3d(num_points):
2183  """get_uniform_cover_rotations_3d(unsigned int num_points) -> IMP::algebra::Rotation3Ds"""
2184  return _IMP_algebra.get_uniform_cover_rotations_3d(num_points)
2185 
2186 def get_uniformly_sampled_rotations(delta):
2187  """get_uniformly_sampled_rotations(double delta) -> IMP::algebra::Rotation3Ds"""
2188  return _IMP_algebra.get_uniformly_sampled_rotations(delta)
2189 
2190 def get_rotation_from_vector4d(v):
2191  """get_rotation_from_vector4d(Vector4D v) -> Rotation3D"""
2192  return _IMP_algebra.get_rotation_from_vector4d(v)
2193 
2194 def get_rotation_from_fixed_xyz(xr, yr, zr):
2195  """get_rotation_from_fixed_xyz(double xr, double yr, double zr) -> Rotation3D"""
2196  return _IMP_algebra.get_rotation_from_fixed_xyz(xr, yr, zr)
2197 
2198 def get_rotation_from_fixed_zxz(phi, theta, psi):
2199  """get_rotation_from_fixed_zxz(double phi, double theta, double psi) -> Rotation3D"""
2200  return _IMP_algebra.get_rotation_from_fixed_zxz(phi, theta, psi)
2201 
2202 def get_rotation_from_fixed_zyz(Rot, Tilt, Psi):
2203  """get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi) -> Rotation3D"""
2204  return _IMP_algebra.get_rotation_from_fixed_zyz(Rot, Tilt, Psi)
2205 class FixedXYZ(_GeometricPrimitive3D):
2206  """Proxy of C++ IMP::algebra::FixedXYZ class"""
2207  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2208 
2209  def __init__(self, *args):
2210  """
2211  __init__(IMP::algebra::FixedXYZ self) -> FixedXYZ
2212  __init__(IMP::algebra::FixedXYZ self, double x, double y, double z) -> FixedXYZ
2213  """
2214  this = _IMP_algebra.new_FixedXYZ(*args)
2215  try:
2216  self.this.append(this)
2217  except:
2218  self.this = this
2219 
2220  def get_x(self):
2221  """get_x(FixedXYZ self) -> double"""
2222  return _IMP_algebra.FixedXYZ_get_x(self)
2223 
2224 
2225  def get_y(self):
2226  """get_y(FixedXYZ self) -> double"""
2227  return _IMP_algebra.FixedXYZ_get_y(self)
2228 
2229 
2230  def get_z(self):
2231  """get_z(FixedXYZ self) -> double"""
2232  return _IMP_algebra.FixedXYZ_get_z(self)
2233 
2234 
2235  def show(self, *args):
2236  """
2237  show(FixedXYZ self, _ostream out)
2238  show(FixedXYZ self)
2239  """
2240  return _IMP_algebra.FixedXYZ_show(self, *args)
2241 
2242 
2243  def __str__(self):
2244  """__str__(FixedXYZ self) -> std::string"""
2245  return _IMP_algebra.FixedXYZ___str__(self)
2246 
2247 
2248  def __repr__(self):
2249  """__repr__(FixedXYZ self) -> std::string"""
2250  return _IMP_algebra.FixedXYZ___repr__(self)
2251 
2252 
2253  def _get_as_binary(self):
2254  """_get_as_binary(FixedXYZ self) -> PyObject *"""
2255  return _IMP_algebra.FixedXYZ__get_as_binary(self)
2256 
2257 
2258  def _set_from_binary(self, p):
2259  """_set_from_binary(FixedXYZ self, PyObject * p)"""
2260  return _IMP_algebra.FixedXYZ__set_from_binary(self, p)
2261 
2262 
2263  def __getstate__(self):
2264  p = self._get_as_binary()
2265  if len(self.__dict__) > 1:
2266  d = self.__dict__.copy()
2267  del d['this']
2268  p = (d, p)
2269  return p
2270 
2271  def __setstate__(self, p):
2272  if not hasattr(self, 'this'):
2273  self.__init__()
2274  if isinstance(p, tuple):
2275  d, p = p
2276  self.__dict__.update(d)
2277  return self._set_from_binary(p)
2278 
2279  __swig_destroy__ = _IMP_algebra.delete_FixedXYZ
2280  __del__ = lambda self: None
2281 FixedXYZ_swigregister = _IMP_algebra.FixedXYZ_swigregister
2282 FixedXYZ_swigregister(FixedXYZ)
2283 
2284 
2285 def get_fixed_xyz_from_rotation(r):
2286  """get_fixed_xyz_from_rotation(Rotation3D r) -> FixedXYZ"""
2287  return _IMP_algebra.get_fixed_xyz_from_rotation(r)
2288 
2289 def get_interpolated(a, b, f):
2290  """get_interpolated(Rotation3D a, Rotation3D b, double f) -> Rotation3D"""
2291  return _IMP_algebra.get_interpolated(a, b, f)
2292 
2293 def get_rotation_from_x_y_axes(x, y):
2294  """get_rotation_from_x_y_axes(Vector3D x, Vector3D y) -> Rotation3D"""
2295  return _IMP_algebra.get_rotation_from_x_y_axes(x, y)
2296 
2297 def get_axis_and_angle(rot):
2298  """get_axis_and_angle(Rotation3D rot) -> _AxisAnglePair"""
2299  return _IMP_algebra.get_axis_and_angle(rot)
2300 
2301 def get_unit_bounding_box_kd(d):
2302  """get_unit_bounding_box_kd(unsigned int d) -> BoundingBoxKD"""
2303  return _IMP_algebra.get_unit_bounding_box_kd(d)
2304 
2305 def get_cube_kd(d, radius):
2306  """get_cube_kd(unsigned int d, double radius) -> BoundingBoxKD"""
2307  return _IMP_algebra.get_cube_kd(d, radius)
2308 
2309 def get_edges(arg1):
2310  """get_edges(BoundingBox3D arg1) -> IMP::IntPairs"""
2311  return _IMP_algebra.get_edges(arg1)
2312 class Transformation3D(_GeometricPrimitive3D):
2313  """Proxy of C++ IMP::algebra::Transformation3D class"""
2314  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2315 
2316  def __init__(self, *args):
2317  """
2318  __init__(IMP::algebra::Transformation3D self) -> Transformation3D
2319  __init__(IMP::algebra::Transformation3D self, Rotation3D r, Vector3D t) -> Transformation3D
2320  __init__(IMP::algebra::Transformation3D self, Rotation3D r) -> Transformation3D
2321  __init__(IMP::algebra::Transformation3D self, Vector3D t) -> Transformation3D
2322  """
2323  this = _IMP_algebra.new_Transformation3D(*args)
2324  try:
2325  self.this.append(this)
2326  except:
2327  self.this = this
2328  __swig_destroy__ = _IMP_algebra.delete_Transformation3D
2329  __del__ = lambda self: None
2330 
2331  def get_transformed(self, o):
2332  """get_transformed(Transformation3D self, Vector3D o) -> Vector3D"""
2333  return _IMP_algebra.Transformation3D_get_transformed(self, o)
2334 
2335 
2336  def get_transformed_adjoint(self, v, Dw):
2337  """get_transformed_adjoint(Transformation3D self, Vector3D v, Vector3D Dw) -> _TransformedVector3DAdjoint"""
2338  return _IMP_algebra.Transformation3D_get_transformed_adjoint(self, v, Dw)
2339 
2340 
2341  def __mul__(self, *args):
2342  """
2343  __mul__(Transformation3D self, Vector3D v) -> Vector3D
2344  __mul__(Transformation3D self, Transformation3D tr) -> Transformation3D
2345  """
2346  return _IMP_algebra.Transformation3D___mul__(self, *args)
2347 
2348 
2349  def __div__(self, b):
2350  """__div__(Transformation3D self, Transformation3D b) -> Transformation3D"""
2351  return _IMP_algebra.Transformation3D___div__(self, b)
2352 
2353 
2354  def get_rotation(self):
2355  """get_rotation(Transformation3D self) -> Rotation3D"""
2356  return _IMP_algebra.Transformation3D_get_rotation(self)
2357 
2358 
2359  def get_translation(self):
2360  """get_translation(Transformation3D self) -> Vector3D"""
2361  return _IMP_algebra.Transformation3D_get_translation(self)
2362 
2363 
2364  def show(self, *args):
2365  """
2366  show(Transformation3D self, _ostream out)
2367  show(Transformation3D self)
2368  """
2369  return _IMP_algebra.Transformation3D_show(self, *args)
2370 
2371 
2372  def get_inverse(self):
2373  """get_inverse(Transformation3D self) -> Transformation3D"""
2374  return _IMP_algebra.Transformation3D_get_inverse(self)
2375 
2376 
2377  def get_is_valid(self):
2378  """get_is_valid(Transformation3D self) -> bool"""
2379  return _IMP_algebra.Transformation3D_get_is_valid(self)
2380 
2381 
2382  def __str__(self):
2383  """__str__(Transformation3D self) -> std::string"""
2384  return _IMP_algebra.Transformation3D___str__(self)
2385 
2386 
2387  def __repr__(self):
2388  """__repr__(Transformation3D self) -> std::string"""
2389  return _IMP_algebra.Transformation3D___repr__(self)
2390 
2391 
2392  def _get_as_binary(self):
2393  """_get_as_binary(Transformation3D self) -> PyObject *"""
2394  return _IMP_algebra.Transformation3D__get_as_binary(self)
2395 
2396 
2397  def _set_from_binary(self, p):
2398  """_set_from_binary(Transformation3D self, PyObject * p)"""
2399  return _IMP_algebra.Transformation3D__set_from_binary(self, p)
2400 
2401 
2402  def __getstate__(self):
2403  p = self._get_as_binary()
2404  if len(self.__dict__) > 1:
2405  d = self.__dict__.copy()
2406  del d['this']
2407  p = (d, p)
2408  return p
2409 
2410  def __setstate__(self, p):
2411  if not hasattr(self, 'this'):
2412  self.__init__()
2413  if isinstance(p, tuple):
2414  d, p = p
2415  self.__dict__.update(d)
2416  return self._set_from_binary(p)
2417 
2418 
2419  __truediv__ = __div__
2420 
2421 Transformation3D_swigregister = _IMP_algebra.Transformation3D_swigregister
2422 Transformation3D_swigregister(Transformation3D)
2423 
2424 
2425 def get_identity_transformation_3d():
2426  """get_identity_transformation_3d() -> Transformation3D"""
2427  return _IMP_algebra.get_identity_transformation_3d()
2428 
2429 def compose_adjoint(*args):
2430  """
2431  compose_adjoint(Rotation3D A, Rotation3D B, Vector4D DC) -> _ComposeRotation3DAdjoint
2432  compose_adjoint(Transformation3D TA, Transformation3D TB, _Transformation3DAdjoint DTC) -> _ComposeTransformation3DAdjoint
2433  """
2434  return _IMP_algebra.compose_adjoint(*args)
2435 
2436 def get_transformation_3d(t2d):
2437  """get_transformation_3d(Transformation2D t2d) -> Transformation3D"""
2438  return _IMP_algebra.get_transformation_3d(t2d)
2439 
2440 def get_random_local_transformation(origin, max_translation=5., max_angle_in_rad=0.26):
2441  """
2442  get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26) -> Transformation3D
2443  get_random_local_transformation(Vector3D origin, double max_translation=5.) -> Transformation3D
2444  get_random_local_transformation(Vector3D origin) -> Transformation3D
2445  """
2446  return _IMP_algebra.get_random_local_transformation(origin, max_translation, max_angle_in_rad)
2447 class Rotation2D(_GeometricPrimitive2D):
2448  """Proxy of C++ IMP::algebra::Rotation2D class"""
2449  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2450 
2451  def __init__(self, *args):
2452  """
2453  __init__(IMP::algebra::Rotation2D self) -> Rotation2D
2454  __init__(IMP::algebra::Rotation2D self, double angle) -> Rotation2D
2455  """
2456  this = _IMP_algebra.new_Rotation2D(*args)
2457  try:
2458  self.this.append(this)
2459  except:
2460  self.this = this
2461 
2462  def get_rotated(self, *args):
2463  """
2464  get_rotated(Rotation2D self, Vector2D o) -> Vector2D
2465  get_rotated(Rotation2D self, double const x, double const y) -> Vector2D
2466  """
2467  return _IMP_algebra.Rotation2D_get_rotated(self, *args)
2468 
2469 
2470  def get_inverse(self):
2471  """get_inverse(Rotation2D self) -> Rotation2D"""
2472  return _IMP_algebra.Rotation2D_get_inverse(self)
2473 
2474 
2475  def set_angle(self, angle):
2476  """set_angle(Rotation2D self, double angle)"""
2477  return _IMP_algebra.Rotation2D_set_angle(self, angle)
2478 
2479 
2480  def get_angle(self):
2481  """get_angle(Rotation2D self) -> double"""
2482  return _IMP_algebra.Rotation2D_get_angle(self)
2483 
2484 
2485  def show(self, *args):
2486  """
2487  show(Rotation2D self, _ostream out)
2488  show(Rotation2D self)
2489  """
2490  return _IMP_algebra.Rotation2D_show(self, *args)
2491 
2492 
2493  def __str__(self):
2494  """__str__(Rotation2D self) -> std::string"""
2495  return _IMP_algebra.Rotation2D___str__(self)
2496 
2497 
2498  def __repr__(self):
2499  """__repr__(Rotation2D self) -> std::string"""
2500  return _IMP_algebra.Rotation2D___repr__(self)
2501 
2502 
2503  def _get_as_binary(self):
2504  """_get_as_binary(Rotation2D self) -> PyObject *"""
2505  return _IMP_algebra.Rotation2D__get_as_binary(self)
2506 
2507 
2508  def _set_from_binary(self, p):
2509  """_set_from_binary(Rotation2D self, PyObject * p)"""
2510  return _IMP_algebra.Rotation2D__set_from_binary(self, p)
2511 
2512 
2513  def __getstate__(self):
2514  p = self._get_as_binary()
2515  if len(self.__dict__) > 1:
2516  d = self.__dict__.copy()
2517  del d['this']
2518  p = (d, p)
2519  return p
2520 
2521  def __setstate__(self, p):
2522  if not hasattr(self, 'this'):
2523  self.__init__()
2524  if isinstance(p, tuple):
2525  d, p = p
2526  self.__dict__.update(d)
2527  return self._set_from_binary(p)
2528 
2529  __swig_destroy__ = _IMP_algebra.delete_Rotation2D
2530  __del__ = lambda self: None
2531 Rotation2D_swigregister = _IMP_algebra.Rotation2D_swigregister
2532 Rotation2D_swigregister(Rotation2D)
2533 
2534 
2535 def get_identity_rotation_2d():
2536  """get_identity_rotation_2d() -> Rotation2D"""
2537  return _IMP_algebra.get_identity_rotation_2d()
2538 
2539 def get_random_rotation_2d():
2540  """get_random_rotation_2d() -> Rotation2D"""
2541  return _IMP_algebra.get_random_rotation_2d()
2542 
2543 def get_rotation_to_x_axis(v):
2544  """get_rotation_to_x_axis(Vector2D v) -> Rotation2D"""
2545  return _IMP_algebra.get_rotation_to_x_axis(v)
2546 class Transformation2D(_GeometricPrimitive2D):
2547  """Proxy of C++ IMP::algebra::Transformation2D class"""
2548  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2549 
2550  def __init__(self, *args):
2551  """
2552  __init__(IMP::algebra::Transformation2D self) -> Transformation2D
2553  __init__(IMP::algebra::Transformation2D self, Rotation2D r, Vector2D t) -> Transformation2D
2554  __init__(IMP::algebra::Transformation2D self, Rotation2D r) -> Transformation2D
2555  __init__(IMP::algebra::Transformation2D self, Vector2D t) -> Transformation2D
2556  """
2557  this = _IMP_algebra.new_Transformation2D(*args)
2558  try:
2559  self.this.append(this)
2560  except:
2561  self.this = this
2562  __swig_destroy__ = _IMP_algebra.delete_Transformation2D
2563  __del__ = lambda self: None
2564 
2565  def get_transformed(self, o):
2566  """get_transformed(Transformation2D self, Vector2D o) -> Vector2D"""
2567  return _IMP_algebra.Transformation2D_get_transformed(self, o)
2568 
2569 
2570  def __mul__(self, *args):
2571  """
2572  __mul__(Transformation2D self, Vector2D v) -> Vector2D
2573  __mul__(Transformation2D self, Transformation2D tr) -> Transformation2D
2574  """
2575  return _IMP_algebra.Transformation2D___mul__(self, *args)
2576 
2577 
2578  def __div__(self, b):
2579  """__div__(Transformation2D self, Transformation2D b) -> Transformation2D"""
2580  return _IMP_algebra.Transformation2D___div__(self, b)
2581 
2582 
2583  def get_rotation(self):
2584  """get_rotation(Transformation2D self) -> Rotation2D"""
2585  return _IMP_algebra.Transformation2D_get_rotation(self)
2586 
2587 
2588  def set_rotation(self, angle):
2589  """set_rotation(Transformation2D self, double angle)"""
2590  return _IMP_algebra.Transformation2D_set_rotation(self, angle)
2591 
2592 
2593  def get_translation(self):
2594  """get_translation(Transformation2D self) -> Vector2D"""
2595  return _IMP_algebra.Transformation2D_get_translation(self)
2596 
2597 
2598  def set_translation(self, v):
2599  """set_translation(Transformation2D self, Vector2D v)"""
2600  return _IMP_algebra.Transformation2D_set_translation(self, v)
2601 
2602 
2603  def show(self, *args):
2604  """
2605  show(Transformation2D self, _ostream out)
2606  show(Transformation2D self)
2607  """
2608  return _IMP_algebra.Transformation2D_show(self, *args)
2609 
2610 
2611  def get_inverse(self):
2612  """get_inverse(Transformation2D self) -> Transformation2D"""
2613  return _IMP_algebra.Transformation2D_get_inverse(self)
2614 
2615 
2616  def __str__(self):
2617  """__str__(Transformation2D self) -> std::string"""
2618  return _IMP_algebra.Transformation2D___str__(self)
2619 
2620 
2621  def __repr__(self):
2622  """__repr__(Transformation2D self) -> std::string"""
2623  return _IMP_algebra.Transformation2D___repr__(self)
2624 
2625 
2626  def _get_as_binary(self):
2627  """_get_as_binary(Transformation2D self) -> PyObject *"""
2628  return _IMP_algebra.Transformation2D__get_as_binary(self)
2629 
2630 
2631  def _set_from_binary(self, p):
2632  """_set_from_binary(Transformation2D self, PyObject * p)"""
2633  return _IMP_algebra.Transformation2D__set_from_binary(self, p)
2634 
2635 
2636  def __getstate__(self):
2637  p = self._get_as_binary()
2638  if len(self.__dict__) > 1:
2639  d = self.__dict__.copy()
2640  del d['this']
2641  p = (d, p)
2642  return p
2643 
2644  def __setstate__(self, p):
2645  if not hasattr(self, 'this'):
2646  self.__init__()
2647  if isinstance(p, tuple):
2648  d, p = p
2649  self.__dict__.update(d)
2650  return self._set_from_binary(p)
2651 
2652 
2653  __truediv__ = __div__
2654 
2655 Transformation2D_swigregister = _IMP_algebra.Transformation2D_swigregister
2656 Transformation2D_swigregister(Transformation2D)
2657 
2658 
2659 def get_identity_transformation_2d():
2660  """get_identity_transformation_2d() -> Transformation2D"""
2661  return _IMP_algebra.get_identity_transformation_2d()
2662 
2663 def get_rotation_about_point(*args):
2664  """
2665  get_rotation_about_point(Vector3D point, Rotation3D rotation) -> Transformation3D
2666  get_rotation_about_point(Vector2D point, Rotation2D rotation) -> Transformation2D
2667  """
2668  return _IMP_algebra.get_rotation_about_point(*args)
2669 
2670 def compose(*args):
2671  """
2672  compose(Rotation3D a, Rotation3D b) -> Rotation3D
2673  compose(Transformation3D a, Transformation3D b) -> Transformation3D
2674  compose(Rotation2D a, Rotation2D b) -> Rotation2D
2675  compose(Transformation2D a, Transformation2D b) -> Transformation2D
2676  """
2677  return _IMP_algebra.compose(*args)
2678 
2679 def get_unit_sphere_kd(d):
2680  """get_unit_sphere_kd(unsigned int d) -> SphereKD"""
2681  return _IMP_algebra.get_unit_sphere_kd(d)
2682 
2683 def get_enclosing_sphere(*args):
2684  """
2685  get_enclosing_sphere(IMP::algebra::Sphere3Ds const & ss) -> Sphere3D
2686  get_enclosing_sphere(IMP::algebra::Vector3Ds const & ss) -> Sphere3D
2687  """
2688  return _IMP_algebra.get_enclosing_sphere(*args)
2689 
2690 def get_ball_radius_from_volume_3d(volume):
2691  """get_ball_radius_from_volume_3d(double volume) -> double"""
2692  return _IMP_algebra.get_ball_radius_from_volume_3d(volume)
2693 
2694 def get_surface_area_and_volume(ss):
2695  """get_surface_area_and_volume(IMP::algebra::Sphere3Ds const & ss) -> IMP::FloatPair"""
2696  return _IMP_algebra.get_surface_area_and_volume(ss)
2697 
2698 def get_simplified_from_volume(arg1, maximum_allowed_error_angstroms):
2699  """get_simplified_from_volume(IMP::algebra::Sphere3Ds arg1, double maximum_allowed_error_angstroms) -> IMP::algebra::Sphere3Ds"""
2700  return _IMP_algebra.get_simplified_from_volume(arg1, maximum_allowed_error_angstroms)
2701 
2702 def get_triangle_3d(s):
2703  """get_triangle_3d(UnitSimplex3D s) -> Triangle3D"""
2704  return _IMP_algebra.get_triangle_3d(s)
2705 class _UnitSimplexBaseKD(_GeometricPrimitiveKD):
2706  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(-1)> class"""
2707  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2708 
2709  def __init__(self, *args, **kwargs):
2710  raise AttributeError("No constructor defined - class is abstract")
2711  __repr__ = _swig_repr
2712 
2713  def get_dimension(self):
2714  """get_dimension(_UnitSimplexBaseKD self) -> int"""
2715  return _IMP_algebra._UnitSimplexBaseKD_get_dimension(self)
2716 
2717 
2718  def get_barycenter(self):
2719  """get_barycenter(_UnitSimplexBaseKD self) -> VectorKD"""
2720  return _IMP_algebra._UnitSimplexBaseKD_get_barycenter(self)
2721 
2722 
2723  def get_contains(self, *args):
2724  """
2725  get_contains(_UnitSimplexBaseKD self, VectorKD p, double atol) -> bool
2726  get_contains(_UnitSimplexBaseKD self, VectorKD p) -> bool
2727  """
2728  return _IMP_algebra._UnitSimplexBaseKD_get_contains(self, *args)
2729 
2730  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBaseKD
2731  __del__ = lambda self: None
2732 _UnitSimplexBaseKD_swigregister = _IMP_algebra._UnitSimplexBaseKD_swigregister
2733 _UnitSimplexBaseKD_swigregister(_UnitSimplexBaseKD)
2734 
2735 class _UnitSimplexBase1D(_GeometricPrimitive1D):
2736  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(1)> class"""
2737  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2738 
2739  def __init__(self, *args, **kwargs):
2740  raise AttributeError("No constructor defined - class is abstract")
2741  __repr__ = _swig_repr
2742 
2743  def get_dimension(self):
2744  """get_dimension(_UnitSimplexBase1D self) -> int"""
2745  return _IMP_algebra._UnitSimplexBase1D_get_dimension(self)
2746 
2747 
2748  def get_barycenter(self):
2749  """get_barycenter(_UnitSimplexBase1D self) -> Vector1D"""
2750  return _IMP_algebra._UnitSimplexBase1D_get_barycenter(self)
2751 
2752 
2753  def get_contains(self, *args):
2754  """
2755  get_contains(_UnitSimplexBase1D self, Vector1D p, double atol) -> bool
2756  get_contains(_UnitSimplexBase1D self, Vector1D p) -> bool
2757  """
2758  return _IMP_algebra._UnitSimplexBase1D_get_contains(self, *args)
2759 
2760  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase1D
2761  __del__ = lambda self: None
2762 _UnitSimplexBase1D_swigregister = _IMP_algebra._UnitSimplexBase1D_swigregister
2763 _UnitSimplexBase1D_swigregister(_UnitSimplexBase1D)
2764 
2765 class _UnitSimplexBase2D(_GeometricPrimitive2D):
2766  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(2)> class"""
2767  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2768 
2769  def __init__(self, *args, **kwargs):
2770  raise AttributeError("No constructor defined - class is abstract")
2771  __repr__ = _swig_repr
2772 
2773  def get_dimension(self):
2774  """get_dimension(_UnitSimplexBase2D self) -> int"""
2775  return _IMP_algebra._UnitSimplexBase2D_get_dimension(self)
2776 
2777 
2778  def get_barycenter(self):
2779  """get_barycenter(_UnitSimplexBase2D self) -> Vector2D"""
2780  return _IMP_algebra._UnitSimplexBase2D_get_barycenter(self)
2781 
2782 
2783  def get_contains(self, *args):
2784  """
2785  get_contains(_UnitSimplexBase2D self, Vector2D p, double atol) -> bool
2786  get_contains(_UnitSimplexBase2D self, Vector2D p) -> bool
2787  """
2788  return _IMP_algebra._UnitSimplexBase2D_get_contains(self, *args)
2789 
2790  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase2D
2791  __del__ = lambda self: None
2792 _UnitSimplexBase2D_swigregister = _IMP_algebra._UnitSimplexBase2D_swigregister
2793 _UnitSimplexBase2D_swigregister(_UnitSimplexBase2D)
2794 
2795 class _UnitSimplexBase3D(_GeometricPrimitive3D):
2796  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(3)> class"""
2797  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2798 
2799  def __init__(self, *args, **kwargs):
2800  raise AttributeError("No constructor defined - class is abstract")
2801  __repr__ = _swig_repr
2802 
2803  def get_dimension(self):
2804  """get_dimension(_UnitSimplexBase3D self) -> int"""
2805  return _IMP_algebra._UnitSimplexBase3D_get_dimension(self)
2806 
2807 
2808  def get_barycenter(self):
2809  """get_barycenter(_UnitSimplexBase3D self) -> Vector3D"""
2810  return _IMP_algebra._UnitSimplexBase3D_get_barycenter(self)
2811 
2812 
2813  def get_contains(self, *args):
2814  """
2815  get_contains(_UnitSimplexBase3D self, Vector3D p, double atol) -> bool
2816  get_contains(_UnitSimplexBase3D self, Vector3D p) -> bool
2817  """
2818  return _IMP_algebra._UnitSimplexBase3D_get_contains(self, *args)
2819 
2820  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase3D
2821  __del__ = lambda self: None
2822 _UnitSimplexBase3D_swigregister = _IMP_algebra._UnitSimplexBase3D_swigregister
2823 _UnitSimplexBase3D_swigregister(_UnitSimplexBase3D)
2824 
2825 class _UnitSimplexBase4D(_GeometricPrimitive4D):
2826  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(4)> class"""
2827  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2828 
2829  def __init__(self, *args, **kwargs):
2830  raise AttributeError("No constructor defined - class is abstract")
2831  __repr__ = _swig_repr
2832 
2833  def get_dimension(self):
2834  """get_dimension(_UnitSimplexBase4D self) -> int"""
2835  return _IMP_algebra._UnitSimplexBase4D_get_dimension(self)
2836 
2837 
2838  def get_barycenter(self):
2839  """get_barycenter(_UnitSimplexBase4D self) -> Vector4D"""
2840  return _IMP_algebra._UnitSimplexBase4D_get_barycenter(self)
2841 
2842 
2843  def get_contains(self, *args):
2844  """
2845  get_contains(_UnitSimplexBase4D self, Vector4D p, double atol) -> bool
2846  get_contains(_UnitSimplexBase4D self, Vector4D p) -> bool
2847  """
2848  return _IMP_algebra._UnitSimplexBase4D_get_contains(self, *args)
2849 
2850  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase4D
2851  __del__ = lambda self: None
2852 _UnitSimplexBase4D_swigregister = _IMP_algebra._UnitSimplexBase4D_swigregister
2853 _UnitSimplexBase4D_swigregister(_UnitSimplexBase4D)
2854 
2855 class _UnitSimplexBase5D(_GeometricPrimitive5D):
2856  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(5)> class"""
2857  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2858 
2859  def __init__(self, *args, **kwargs):
2860  raise AttributeError("No constructor defined - class is abstract")
2861  __repr__ = _swig_repr
2862 
2863  def get_dimension(self):
2864  """get_dimension(_UnitSimplexBase5D self) -> int"""
2865  return _IMP_algebra._UnitSimplexBase5D_get_dimension(self)
2866 
2867 
2868  def get_barycenter(self):
2869  """get_barycenter(_UnitSimplexBase5D self) -> Vector5D"""
2870  return _IMP_algebra._UnitSimplexBase5D_get_barycenter(self)
2871 
2872 
2873  def get_contains(self, *args):
2874  """
2875  get_contains(_UnitSimplexBase5D self, Vector5D p, double atol) -> bool
2876  get_contains(_UnitSimplexBase5D self, Vector5D p) -> bool
2877  """
2878  return _IMP_algebra._UnitSimplexBase5D_get_contains(self, *args)
2879 
2880  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase5D
2881  __del__ = lambda self: None
2882 _UnitSimplexBase5D_swigregister = _IMP_algebra._UnitSimplexBase5D_swigregister
2883 _UnitSimplexBase5D_swigregister(_UnitSimplexBase5D)
2884 
2885 class _UnitSimplexBase6D(_GeometricPrimitive6D):
2886  """Proxy of C++ IMP::algebra::UnitSimplexBaseD<(6)> class"""
2887  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2888 
2889  def __init__(self, *args, **kwargs):
2890  raise AttributeError("No constructor defined - class is abstract")
2891  __repr__ = _swig_repr
2892 
2893  def get_dimension(self):
2894  """get_dimension(_UnitSimplexBase6D self) -> int"""
2895  return _IMP_algebra._UnitSimplexBase6D_get_dimension(self)
2896 
2897 
2898  def get_barycenter(self):
2899  """get_barycenter(_UnitSimplexBase6D self) -> Vector6D"""
2900  return _IMP_algebra._UnitSimplexBase6D_get_barycenter(self)
2901 
2902 
2903  def get_contains(self, *args):
2904  """
2905  get_contains(_UnitSimplexBase6D self, Vector6D p, double atol) -> bool
2906  get_contains(_UnitSimplexBase6D self, Vector6D p) -> bool
2907  """
2908  return _IMP_algebra._UnitSimplexBase6D_get_contains(self, *args)
2909 
2910  __swig_destroy__ = _IMP_algebra.delete__UnitSimplexBase6D
2911  __del__ = lambda self: None
2912 _UnitSimplexBase6D_swigregister = _IMP_algebra._UnitSimplexBase6D_swigregister
2913 _UnitSimplexBase6D_swigregister(_UnitSimplexBase6D)
2914 
2915 class Vector1D(_VectorBase1D):
2916  """Proxy of C++ IMP::algebra::VectorD<(1)> class"""
2917  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2918 
2919  def get_unit_vector(self):
2920  """get_unit_vector(Vector1D self) -> Vector1D"""
2921  return _IMP_algebra.Vector1D_get_unit_vector(self)
2922 
2923 
2924  def __div__(self, s):
2925  """__div__(Vector1D self, double s) -> Vector1D"""
2926  return _IMP_algebra.Vector1D___div__(self, s)
2927 
2928 
2929  def __neg__(self):
2930  """__neg__(Vector1D self) -> Vector1D"""
2931  return _IMP_algebra.Vector1D___neg__(self)
2932 
2933 
2934  def __sub__(self, o):
2935  """__sub__(Vector1D self, Vector1D o) -> Vector1D"""
2936  return _IMP_algebra.Vector1D___sub__(self, o)
2937 
2938 
2939  def __add__(self, ret):
2940  """__add__(Vector1D self, Vector1D ret) -> Vector1D"""
2941  return _IMP_algebra.Vector1D___add__(self, ret)
2942 
2943 
2944  def __mul__(self, *args):
2945  """
2946  __mul__(Vector1D self, double s) -> Vector1D
2947  __mul__(Vector1D self, Vector1D o) -> double
2948  """
2949  return _IMP_algebra.Vector1D___mul__(self, *args)
2950 
2951 
2952  def __init__(self, *args):
2953  """
2954  __init__(IMP::algebra::VectorD<(1)> self, IMP::Floats const & f) -> Vector1D
2955  __init__(IMP::algebra::VectorD<(1)> self) -> Vector1D
2956  __init__(IMP::algebra::VectorD<(1)> self, double x) -> Vector1D
2957  """
2958  this = _IMP_algebra.new_Vector1D(*args)
2959  try:
2960  self.this.append(this)
2961  except:
2962  self.this = this
2963 
2964  def __iadd__(self, *args):
2965  _IMP_algebra.Vector1D___iadd__(self, *args)
2966  return self
2967 
2968 
2969 
2970  def __imul__(self, *args):
2971  _IMP_algebra.Vector1D___imul__(self, *args)
2972  return self
2973 
2974 
2975 
2976  def __idiv__(self, *args):
2977  _IMP_algebra.Vector1D___idiv__(self, *args)
2978  return self
2979 
2980 
2981 
2982  def __isub__(self, *args):
2983  _IMP_algebra.Vector1D___isub__(self, *args)
2984  return self
2985 
2986 
2987 
2988  def __len__(self):
2989  """__len__(Vector1D self) -> unsigned int"""
2990  return _IMP_algebra.Vector1D___len__(self)
2991 
2992 
2993  def __rmul__(self, f):
2994  """__rmul__(Vector1D self, double f) -> Vector1D"""
2995  return _IMP_algebra.Vector1D___rmul__(self, f)
2996 
2997 
2998  def __str__(self):
2999  """__str__(Vector1D self) -> std::string"""
3000  return _IMP_algebra.Vector1D___str__(self)
3001 
3002 
3003  def __repr__(self):
3004  """__repr__(Vector1D self) -> std::string"""
3005  return _IMP_algebra.Vector1D___repr__(self)
3006 
3007 
3008  def __cmp__(self, arg2):
3009  """__cmp__(Vector1D self, Vector1D arg2) -> int"""
3010  return _IMP_algebra.Vector1D___cmp__(self, arg2)
3011 
3012 
3013  def __eq__(self, arg2):
3014  """__eq__(Vector1D self, Vector1D arg2) -> bool"""
3015  return _IMP_algebra.Vector1D___eq__(self, arg2)
3016 
3017 
3018  __truediv__ = __div__
3019  __itruediv__ = __idiv__
3020 
3021 
3022  def _get_as_binary(self):
3023  """_get_as_binary(Vector1D self) -> PyObject *"""
3024  return _IMP_algebra.Vector1D__get_as_binary(self)
3025 
3026 
3027  def _set_from_binary(self, p):
3028  """_set_from_binary(Vector1D self, PyObject * p)"""
3029  return _IMP_algebra.Vector1D__set_from_binary(self, p)
3030 
3031 
3032  def __getstate__(self):
3033  p = self._get_as_binary()
3034  if len(self.__dict__) > 1:
3035  d = self.__dict__.copy()
3036  del d['this']
3037  p = (d, p)
3038  return p
3039 
3040  def __setstate__(self, p):
3041  if not hasattr(self, 'this'):
3042  self.__init__()
3043  if isinstance(p, tuple):
3044  d, p = p
3045  self.__dict__.update(d)
3046  return self._set_from_binary(p)
3047 
3048 
3049  def __getitem__(self, index):
3050  """__getitem__(Vector1D self, int index) -> double"""
3051  return _IMP_algebra.Vector1D___getitem__(self, index)
3052 
3053 
3054  def __setitem__(self, index, val):
3055  """__setitem__(Vector1D self, int index, double val)"""
3056  return _IMP_algebra.Vector1D___setitem__(self, index, val)
3057 
3058  __swig_destroy__ = _IMP_algebra.delete_Vector1D
3059  __del__ = lambda self: None
3060 Vector1D_swigregister = _IMP_algebra.Vector1D_swigregister
3061 Vector1D_swigregister(Vector1D)
3062 
3063 class Vector2D(_VectorBase2D):
3064  """Proxy of C++ IMP::algebra::VectorD<(2)> class"""
3065  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3066 
3067  def get_unit_vector(self):
3068  """get_unit_vector(Vector2D self) -> Vector2D"""
3069  return _IMP_algebra.Vector2D_get_unit_vector(self)
3070 
3071 
3072  def __div__(self, s):
3073  """__div__(Vector2D self, double s) -> Vector2D"""
3074  return _IMP_algebra.Vector2D___div__(self, s)
3075 
3076 
3077  def __neg__(self):
3078  """__neg__(Vector2D self) -> Vector2D"""
3079  return _IMP_algebra.Vector2D___neg__(self)
3080 
3081 
3082  def __sub__(self, o):
3083  """__sub__(Vector2D self, Vector2D o) -> Vector2D"""
3084  return _IMP_algebra.Vector2D___sub__(self, o)
3085 
3086 
3087  def __add__(self, ret):
3088  """__add__(Vector2D self, Vector2D ret) -> Vector2D"""
3089  return _IMP_algebra.Vector2D___add__(self, ret)
3090 
3091 
3092  def __mul__(self, *args):
3093  """
3094  __mul__(Vector2D self, double s) -> Vector2D
3095  __mul__(Vector2D self, Vector2D o) -> double
3096  """
3097  return _IMP_algebra.Vector2D___mul__(self, *args)
3098 
3099 
3100  def __init__(self, *args):
3101  """
3102  __init__(IMP::algebra::VectorD<(2)> self, IMP::Floats const & f) -> Vector2D
3103  __init__(IMP::algebra::VectorD<(2)> self) -> Vector2D
3104  __init__(IMP::algebra::VectorD<(2)> self, double x, double y) -> Vector2D
3105  """
3106  this = _IMP_algebra.new_Vector2D(*args)
3107  try:
3108  self.this.append(this)
3109  except:
3110  self.this = this
3111 
3112  def __iadd__(self, *args):
3113  _IMP_algebra.Vector2D___iadd__(self, *args)
3114  return self
3115 
3116 
3117 
3118  def __imul__(self, *args):
3119  _IMP_algebra.Vector2D___imul__(self, *args)
3120  return self
3121 
3122 
3123 
3124  def __idiv__(self, *args):
3125  _IMP_algebra.Vector2D___idiv__(self, *args)
3126  return self
3127 
3128 
3129 
3130  def __isub__(self, *args):
3131  _IMP_algebra.Vector2D___isub__(self, *args)
3132  return self
3133 
3134 
3135 
3136  def __len__(self):
3137  """__len__(Vector2D self) -> unsigned int"""
3138  return _IMP_algebra.Vector2D___len__(self)
3139 
3140 
3141  def __rmul__(self, f):
3142  """__rmul__(Vector2D self, double f) -> Vector2D"""
3143  return _IMP_algebra.Vector2D___rmul__(self, f)
3144 
3145 
3146  def __str__(self):
3147  """__str__(Vector2D self) -> std::string"""
3148  return _IMP_algebra.Vector2D___str__(self)
3149 
3150 
3151  def __repr__(self):
3152  """__repr__(Vector2D self) -> std::string"""
3153  return _IMP_algebra.Vector2D___repr__(self)
3154 
3155 
3156  def __cmp__(self, arg2):
3157  """__cmp__(Vector2D self, Vector2D arg2) -> int"""
3158  return _IMP_algebra.Vector2D___cmp__(self, arg2)
3159 
3160 
3161  def __eq__(self, arg2):
3162  """__eq__(Vector2D self, Vector2D arg2) -> bool"""
3163  return _IMP_algebra.Vector2D___eq__(self, arg2)
3164 
3165 
3166  __truediv__ = __div__
3167  __itruediv__ = __idiv__
3168 
3169 
3170  def _get_as_binary(self):
3171  """_get_as_binary(Vector2D self) -> PyObject *"""
3172  return _IMP_algebra.Vector2D__get_as_binary(self)
3173 
3174 
3175  def _set_from_binary(self, p):
3176  """_set_from_binary(Vector2D self, PyObject * p)"""
3177  return _IMP_algebra.Vector2D__set_from_binary(self, p)
3178 
3179 
3180  def __getstate__(self):
3181  p = self._get_as_binary()
3182  if len(self.__dict__) > 1:
3183  d = self.__dict__.copy()
3184  del d['this']
3185  p = (d, p)
3186  return p
3187 
3188  def __setstate__(self, p):
3189  if not hasattr(self, 'this'):
3190  self.__init__()
3191  if isinstance(p, tuple):
3192  d, p = p
3193  self.__dict__.update(d)
3194  return self._set_from_binary(p)
3195 
3196 
3197  def __getitem__(self, index):
3198  """__getitem__(Vector2D self, int index) -> double"""
3199  return _IMP_algebra.Vector2D___getitem__(self, index)
3200 
3201 
3202  def __setitem__(self, index, val):
3203  """__setitem__(Vector2D self, int index, double val)"""
3204  return _IMP_algebra.Vector2D___setitem__(self, index, val)
3205 
3206  __swig_destroy__ = _IMP_algebra.delete_Vector2D
3207  __del__ = lambda self: None
3208 Vector2D_swigregister = _IMP_algebra.Vector2D_swigregister
3209 Vector2D_swigregister(Vector2D)
3210 
3211 class Vector3D(_VectorBase3D):
3212  """Proxy of C++ IMP::algebra::VectorD<(3)> class"""
3213  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3214 
3215  def get_unit_vector(self):
3216  """get_unit_vector(Vector3D self) -> Vector3D"""
3217  return _IMP_algebra.Vector3D_get_unit_vector(self)
3218 
3219 
3220  def __div__(self, s):
3221  """__div__(Vector3D self, double s) -> Vector3D"""
3222  return _IMP_algebra.Vector3D___div__(self, s)
3223 
3224 
3225  def __neg__(self):
3226  """__neg__(Vector3D self) -> Vector3D"""
3227  return _IMP_algebra.Vector3D___neg__(self)
3228 
3229 
3230  def __sub__(self, o):
3231  """__sub__(Vector3D self, Vector3D o) -> Vector3D"""
3232  return _IMP_algebra.Vector3D___sub__(self, o)
3233 
3234 
3235  def __add__(self, ret):
3236  """__add__(Vector3D self, Vector3D ret) -> Vector3D"""
3237  return _IMP_algebra.Vector3D___add__(self, ret)
3238 
3239 
3240  def __mul__(self, *args):
3241  """
3242  __mul__(Vector3D self, double s) -> Vector3D
3243  __mul__(Vector3D self, Vector3D o) -> double
3244  """
3245  return _IMP_algebra.Vector3D___mul__(self, *args)
3246 
3247 
3248  def __init__(self, *args):
3249  """
3250  __init__(IMP::algebra::VectorD<(3)> self, IMP::Floats const & f) -> Vector3D
3251  __init__(IMP::algebra::VectorD<(3)> self) -> Vector3D
3252  __init__(IMP::algebra::VectorD<(3)> self, double x, double y, double z) -> Vector3D
3253  """
3254  this = _IMP_algebra.new_Vector3D(*args)
3255  try:
3256  self.this.append(this)
3257  except:
3258  self.this = this
3259 
3260  def __iadd__(self, *args):
3261  _IMP_algebra.Vector3D___iadd__(self, *args)
3262  return self
3263 
3264 
3265 
3266  def __imul__(self, *args):
3267  _IMP_algebra.Vector3D___imul__(self, *args)
3268  return self
3269 
3270 
3271 
3272  def __idiv__(self, *args):
3273  _IMP_algebra.Vector3D___idiv__(self, *args)
3274  return self
3275 
3276 
3277 
3278  def __isub__(self, *args):
3279  _IMP_algebra.Vector3D___isub__(self, *args)
3280  return self
3281 
3282 
3283 
3284  def __len__(self):
3285  """__len__(Vector3D self) -> unsigned int"""
3286  return _IMP_algebra.Vector3D___len__(self)
3287 
3288 
3289  def __rmul__(self, f):
3290  """__rmul__(Vector3D self, double f) -> Vector3D"""
3291  return _IMP_algebra.Vector3D___rmul__(self, f)
3292 
3293 
3294  def __str__(self):
3295  """__str__(Vector3D self) -> std::string"""
3296  return _IMP_algebra.Vector3D___str__(self)
3297 
3298 
3299  def __repr__(self):
3300  """__repr__(Vector3D self) -> std::string"""
3301  return _IMP_algebra.Vector3D___repr__(self)
3302 
3303 
3304  def __cmp__(self, arg2):
3305  """__cmp__(Vector3D self, Vector3D arg2) -> int"""
3306  return _IMP_algebra.Vector3D___cmp__(self, arg2)
3307 
3308 
3309  def __eq__(self, arg2):
3310  """__eq__(Vector3D self, Vector3D arg2) -> bool"""
3311  return _IMP_algebra.Vector3D___eq__(self, arg2)
3312 
3313 
3314  __truediv__ = __div__
3315  __itruediv__ = __idiv__
3316 
3317 
3318  def _get_as_binary(self):
3319  """_get_as_binary(Vector3D self) -> PyObject *"""
3320  return _IMP_algebra.Vector3D__get_as_binary(self)
3321 
3322 
3323  def _set_from_binary(self, p):
3324  """_set_from_binary(Vector3D self, PyObject * p)"""
3325  return _IMP_algebra.Vector3D__set_from_binary(self, p)
3326 
3327 
3328  def __getstate__(self):
3329  p = self._get_as_binary()
3330  if len(self.__dict__) > 1:
3331  d = self.__dict__.copy()
3332  del d['this']
3333  p = (d, p)
3334  return p
3335 
3336  def __setstate__(self, p):
3337  if not hasattr(self, 'this'):
3338  self.__init__()
3339  if isinstance(p, tuple):
3340  d, p = p
3341  self.__dict__.update(d)
3342  return self._set_from_binary(p)
3343 
3344 
3345  def __getitem__(self, index):
3346  """__getitem__(Vector3D self, int index) -> double"""
3347  return _IMP_algebra.Vector3D___getitem__(self, index)
3348 
3349 
3350  def __setitem__(self, index, val):
3351  """__setitem__(Vector3D self, int index, double val)"""
3352  return _IMP_algebra.Vector3D___setitem__(self, index, val)
3353 
3354  __swig_destroy__ = _IMP_algebra.delete_Vector3D
3355  __del__ = lambda self: None
3356 Vector3D_swigregister = _IMP_algebra.Vector3D_swigregister
3357 Vector3D_swigregister(Vector3D)
3358 
3359 class Vector4D(_VectorBase4D):
3360  """Proxy of C++ IMP::algebra::VectorD<(4)> class"""
3361  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3362 
3363  def get_unit_vector(self):
3364  """get_unit_vector(Vector4D self) -> Vector4D"""
3365  return _IMP_algebra.Vector4D_get_unit_vector(self)
3366 
3367 
3368  def __div__(self, s):
3369  """__div__(Vector4D self, double s) -> Vector4D"""
3370  return _IMP_algebra.Vector4D___div__(self, s)
3371 
3372 
3373  def __neg__(self):
3374  """__neg__(Vector4D self) -> Vector4D"""
3375  return _IMP_algebra.Vector4D___neg__(self)
3376 
3377 
3378  def __sub__(self, o):
3379  """__sub__(Vector4D self, Vector4D o) -> Vector4D"""
3380  return _IMP_algebra.Vector4D___sub__(self, o)
3381 
3382 
3383  def __add__(self, ret):
3384  """__add__(Vector4D self, Vector4D ret) -> Vector4D"""
3385  return _IMP_algebra.Vector4D___add__(self, ret)
3386 
3387 
3388  def __mul__(self, *args):
3389  """
3390  __mul__(Vector4D self, double s) -> Vector4D
3391  __mul__(Vector4D self, Vector4D o) -> double
3392  """
3393  return _IMP_algebra.Vector4D___mul__(self, *args)
3394 
3395 
3396  def __init__(self, *args):
3397  """
3398  __init__(IMP::algebra::VectorD<(4)> self, IMP::Floats const & f) -> Vector4D
3399  __init__(IMP::algebra::VectorD<(4)> self) -> Vector4D
3400  __init__(IMP::algebra::VectorD<(4)> self, double x0, double x1, double x2, double x3) -> Vector4D
3401  """
3402  this = _IMP_algebra.new_Vector4D(*args)
3403  try:
3404  self.this.append(this)
3405  except:
3406  self.this = this
3407 
3408  def __iadd__(self, *args):
3409  _IMP_algebra.Vector4D___iadd__(self, *args)
3410  return self
3411 
3412 
3413 
3414  def __imul__(self, *args):
3415  _IMP_algebra.Vector4D___imul__(self, *args)
3416  return self
3417 
3418 
3419 
3420  def __idiv__(self, *args):
3421  _IMP_algebra.Vector4D___idiv__(self, *args)
3422  return self
3423 
3424 
3425 
3426  def __isub__(self, *args):
3427  _IMP_algebra.Vector4D___isub__(self, *args)
3428  return self
3429 
3430 
3431 
3432  def __len__(self):
3433  """__len__(Vector4D self) -> unsigned int"""
3434  return _IMP_algebra.Vector4D___len__(self)
3435 
3436 
3437  def __rmul__(self, f):
3438  """__rmul__(Vector4D self, double f) -> Vector4D"""
3439  return _IMP_algebra.Vector4D___rmul__(self, f)
3440 
3441 
3442  def __str__(self):
3443  """__str__(Vector4D self) -> std::string"""
3444  return _IMP_algebra.Vector4D___str__(self)
3445 
3446 
3447  def __repr__(self):
3448  """__repr__(Vector4D self) -> std::string"""
3449  return _IMP_algebra.Vector4D___repr__(self)
3450 
3451 
3452  def __cmp__(self, arg2):
3453  """__cmp__(Vector4D self, Vector4D arg2) -> int"""
3454  return _IMP_algebra.Vector4D___cmp__(self, arg2)
3455 
3456 
3457  def __eq__(self, arg2):
3458  """__eq__(Vector4D self, Vector4D arg2) -> bool"""
3459  return _IMP_algebra.Vector4D___eq__(self, arg2)
3460 
3461 
3462  __truediv__ = __div__
3463  __itruediv__ = __idiv__
3464 
3465 
3466  def _get_as_binary(self):
3467  """_get_as_binary(Vector4D self) -> PyObject *"""
3468  return _IMP_algebra.Vector4D__get_as_binary(self)
3469 
3470 
3471  def _set_from_binary(self, p):
3472  """_set_from_binary(Vector4D self, PyObject * p)"""
3473  return _IMP_algebra.Vector4D__set_from_binary(self, p)
3474 
3475 
3476  def __getstate__(self):
3477  p = self._get_as_binary()
3478  if len(self.__dict__) > 1:
3479  d = self.__dict__.copy()
3480  del d['this']
3481  p = (d, p)
3482  return p
3483 
3484  def __setstate__(self, p):
3485  if not hasattr(self, 'this'):
3486  self.__init__()
3487  if isinstance(p, tuple):
3488  d, p = p
3489  self.__dict__.update(d)
3490  return self._set_from_binary(p)
3491 
3492 
3493  def __getitem__(self, index):
3494  """__getitem__(Vector4D self, int index) -> double"""
3495  return _IMP_algebra.Vector4D___getitem__(self, index)
3496 
3497 
3498  def __setitem__(self, index, val):
3499  """__setitem__(Vector4D self, int index, double val)"""
3500  return _IMP_algebra.Vector4D___setitem__(self, index, val)
3501 
3502  __swig_destroy__ = _IMP_algebra.delete_Vector4D
3503  __del__ = lambda self: None
3504 Vector4D_swigregister = _IMP_algebra.Vector4D_swigregister
3505 Vector4D_swigregister(Vector4D)
3506 
3507 class Vector5D(_VectorBase5D):
3508  """Proxy of C++ IMP::algebra::VectorD<(5)> class"""
3509  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3510 
3511  def get_unit_vector(self):
3512  """get_unit_vector(Vector5D self) -> Vector5D"""
3513  return _IMP_algebra.Vector5D_get_unit_vector(self)
3514 
3515 
3516  def __div__(self, s):
3517  """__div__(Vector5D self, double s) -> Vector5D"""
3518  return _IMP_algebra.Vector5D___div__(self, s)
3519 
3520 
3521  def __neg__(self):
3522  """__neg__(Vector5D self) -> Vector5D"""
3523  return _IMP_algebra.Vector5D___neg__(self)
3524 
3525 
3526  def __sub__(self, o):
3527  """__sub__(Vector5D self, Vector5D o) -> Vector5D"""
3528  return _IMP_algebra.Vector5D___sub__(self, o)
3529 
3530 
3531  def __add__(self, ret):
3532  """__add__(Vector5D self, Vector5D ret) -> Vector5D"""
3533  return _IMP_algebra.Vector5D___add__(self, ret)
3534 
3535 
3536  def __mul__(self, *args):
3537  """
3538  __mul__(Vector5D self, double s) -> Vector5D
3539  __mul__(Vector5D self, Vector5D o) -> double
3540  """
3541  return _IMP_algebra.Vector5D___mul__(self, *args)
3542 
3543 
3544  def __init__(self, *args):
3545  """
3546  __init__(IMP::algebra::VectorD<(5)> self, IMP::Floats const & f) -> Vector5D
3547  __init__(IMP::algebra::VectorD<(5)> self) -> Vector5D
3548  __init__(IMP::algebra::VectorD<(5)> self, double x0, double x1, double x2, double x3, double x4) -> Vector5D
3549  """
3550  this = _IMP_algebra.new_Vector5D(*args)
3551  try:
3552  self.this.append(this)
3553  except:
3554  self.this = this
3555 
3556  def __iadd__(self, *args):
3557  _IMP_algebra.Vector5D___iadd__(self, *args)
3558  return self
3559 
3560 
3561 
3562  def __imul__(self, *args):
3563  _IMP_algebra.Vector5D___imul__(self, *args)
3564  return self
3565 
3566 
3567 
3568  def __idiv__(self, *args):
3569  _IMP_algebra.Vector5D___idiv__(self, *args)
3570  return self
3571 
3572 
3573 
3574  def __isub__(self, *args):
3575  _IMP_algebra.Vector5D___isub__(self, *args)
3576  return self
3577 
3578 
3579 
3580  def __len__(self):
3581  """__len__(Vector5D self) -> unsigned int"""
3582  return _IMP_algebra.Vector5D___len__(self)
3583 
3584 
3585  def __rmul__(self, f):
3586  """__rmul__(Vector5D self, double f) -> Vector5D"""
3587  return _IMP_algebra.Vector5D___rmul__(self, f)
3588 
3589 
3590  def __str__(self):
3591  """__str__(Vector5D self) -> std::string"""
3592  return _IMP_algebra.Vector5D___str__(self)
3593 
3594 
3595  def __repr__(self):
3596  """__repr__(Vector5D self) -> std::string"""
3597  return _IMP_algebra.Vector5D___repr__(self)
3598 
3599 
3600  def __cmp__(self, arg2):
3601  """__cmp__(Vector5D self, Vector5D arg2) -> int"""
3602  return _IMP_algebra.Vector5D___cmp__(self, arg2)
3603 
3604 
3605  def __eq__(self, arg2):
3606  """__eq__(Vector5D self, Vector5D arg2) -> bool"""
3607  return _IMP_algebra.Vector5D___eq__(self, arg2)
3608 
3609 
3610  __truediv__ = __div__
3611  __itruediv__ = __idiv__
3612 
3613 
3614  def _get_as_binary(self):
3615  """_get_as_binary(Vector5D self) -> PyObject *"""
3616  return _IMP_algebra.Vector5D__get_as_binary(self)
3617 
3618 
3619  def _set_from_binary(self, p):
3620  """_set_from_binary(Vector5D self, PyObject * p)"""
3621  return _IMP_algebra.Vector5D__set_from_binary(self, p)
3622 
3623 
3624  def __getstate__(self):
3625  p = self._get_as_binary()
3626  if len(self.__dict__) > 1:
3627  d = self.__dict__.copy()
3628  del d['this']
3629  p = (d, p)
3630  return p
3631 
3632  def __setstate__(self, p):
3633  if not hasattr(self, 'this'):
3634  self.__init__()
3635  if isinstance(p, tuple):
3636  d, p = p
3637  self.__dict__.update(d)
3638  return self._set_from_binary(p)
3639 
3640 
3641  def __getitem__(self, index):
3642  """__getitem__(Vector5D self, int index) -> double"""
3643  return _IMP_algebra.Vector5D___getitem__(self, index)
3644 
3645 
3646  def __setitem__(self, index, val):
3647  """__setitem__(Vector5D self, int index, double val)"""
3648  return _IMP_algebra.Vector5D___setitem__(self, index, val)
3649 
3650  __swig_destroy__ = _IMP_algebra.delete_Vector5D
3651  __del__ = lambda self: None
3652 Vector5D_swigregister = _IMP_algebra.Vector5D_swigregister
3653 Vector5D_swigregister(Vector5D)
3654 
3655 class Vector6D(_VectorBase6D):
3656  """Proxy of C++ IMP::algebra::VectorD<(6)> class"""
3657  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3658 
3659  def get_unit_vector(self):
3660  """get_unit_vector(Vector6D self) -> Vector6D"""
3661  return _IMP_algebra.Vector6D_get_unit_vector(self)
3662 
3663 
3664  def __div__(self, s):
3665  """__div__(Vector6D self, double s) -> Vector6D"""
3666  return _IMP_algebra.Vector6D___div__(self, s)
3667 
3668 
3669  def __neg__(self):
3670  """__neg__(Vector6D self) -> Vector6D"""
3671  return _IMP_algebra.Vector6D___neg__(self)
3672 
3673 
3674  def __sub__(self, o):
3675  """__sub__(Vector6D self, Vector6D o) -> Vector6D"""
3676  return _IMP_algebra.Vector6D___sub__(self, o)
3677 
3678 
3679  def __add__(self, ret):
3680  """__add__(Vector6D self, Vector6D ret) -> Vector6D"""
3681  return _IMP_algebra.Vector6D___add__(self, ret)
3682 
3683 
3684  def __mul__(self, *args):
3685  """
3686  __mul__(Vector6D self, double s) -> Vector6D
3687  __mul__(Vector6D self, Vector6D o) -> double
3688  """
3689  return _IMP_algebra.Vector6D___mul__(self, *args)
3690 
3691 
3692  def __init__(self, *args):
3693  """
3694  __init__(IMP::algebra::VectorD<(6)> self, IMP::Floats const & f) -> Vector6D
3695  __init__(IMP::algebra::VectorD<(6)> self) -> Vector6D
3696  __init__(IMP::algebra::VectorD<(6)> self, double x0, double x1, double x2, double x3, double x4, double x5) -> Vector6D
3697  """
3698  this = _IMP_algebra.new_Vector6D(*args)
3699  try:
3700  self.this.append(this)
3701  except:
3702  self.this = this
3703 
3704  def __iadd__(self, *args):
3705  _IMP_algebra.Vector6D___iadd__(self, *args)
3706  return self
3707 
3708 
3709 
3710  def __imul__(self, *args):
3711  _IMP_algebra.Vector6D___imul__(self, *args)
3712  return self
3713 
3714 
3715 
3716  def __idiv__(self, *args):
3717  _IMP_algebra.Vector6D___idiv__(self, *args)
3718  return self
3719 
3720 
3721 
3722  def __isub__(self, *args):
3723  _IMP_algebra.Vector6D___isub__(self, *args)
3724  return self
3725 
3726 
3727 
3728  def __len__(self):
3729  """__len__(Vector6D self) -> unsigned int"""
3730  return _IMP_algebra.Vector6D___len__(self)
3731 
3732 
3733  def __rmul__(self, f):
3734  """__rmul__(Vector6D self, double f) -> Vector6D"""
3735  return _IMP_algebra.Vector6D___rmul__(self, f)
3736 
3737 
3738  def __str__(self):
3739  """__str__(Vector6D self) -> std::string"""
3740  return _IMP_algebra.Vector6D___str__(self)
3741 
3742 
3743  def __repr__(self):
3744  """__repr__(Vector6D self) -> std::string"""
3745  return _IMP_algebra.Vector6D___repr__(self)
3746 
3747 
3748  def __cmp__(self, arg2):
3749  """__cmp__(Vector6D self, Vector6D arg2) -> int"""
3750  return _IMP_algebra.Vector6D___cmp__(self, arg2)
3751 
3752 
3753  def __eq__(self, arg2):
3754  """__eq__(Vector6D self, Vector6D arg2) -> bool"""
3755  return _IMP_algebra.Vector6D___eq__(self, arg2)
3756 
3757 
3758  __truediv__ = __div__
3759  __itruediv__ = __idiv__
3760 
3761 
3762  def _get_as_binary(self):
3763  """_get_as_binary(Vector6D self) -> PyObject *"""
3764  return _IMP_algebra.Vector6D__get_as_binary(self)
3765 
3766 
3767  def _set_from_binary(self, p):
3768  """_set_from_binary(Vector6D self, PyObject * p)"""
3769  return _IMP_algebra.Vector6D__set_from_binary(self, p)
3770 
3771 
3772  def __getstate__(self):
3773  p = self._get_as_binary()
3774  if len(self.__dict__) > 1:
3775  d = self.__dict__.copy()
3776  del d['this']
3777  p = (d, p)
3778  return p
3779 
3780  def __setstate__(self, p):
3781  if not hasattr(self, 'this'):
3782  self.__init__()
3783  if isinstance(p, tuple):
3784  d, p = p
3785  self.__dict__.update(d)
3786  return self._set_from_binary(p)
3787 
3788 
3789  def __getitem__(self, index):
3790  """__getitem__(Vector6D self, int index) -> double"""
3791  return _IMP_algebra.Vector6D___getitem__(self, index)
3792 
3793 
3794  def __setitem__(self, index, val):
3795  """__setitem__(Vector6D self, int index, double val)"""
3796  return _IMP_algebra.Vector6D___setitem__(self, index, val)
3797 
3798  __swig_destroy__ = _IMP_algebra.delete_Vector6D
3799  __del__ = lambda self: None
3800 Vector6D_swigregister = _IMP_algebra.Vector6D_swigregister
3801 Vector6D_swigregister(Vector6D)
3802 
3803 class VectorKD(_VectorBaseKD):
3804  """Proxy of C++ IMP::algebra::VectorD<(-1)> class"""
3805  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3806 
3807  def get_unit_vector(self):
3808  """get_unit_vector(VectorKD self) -> VectorKD"""
3809  return _IMP_algebra.VectorKD_get_unit_vector(self)
3810 
3811 
3812  def __div__(self, s):
3813  """__div__(VectorKD self, double s) -> VectorKD"""
3814  return _IMP_algebra.VectorKD___div__(self, s)
3815 
3816 
3817  def __neg__(self):
3818  """__neg__(VectorKD self) -> VectorKD"""
3819  return _IMP_algebra.VectorKD___neg__(self)
3820 
3821 
3822  def __sub__(self, o):
3823  """__sub__(VectorKD self, VectorKD o) -> VectorKD"""
3824  return _IMP_algebra.VectorKD___sub__(self, o)
3825 
3826 
3827  def __add__(self, ret):
3828  """__add__(VectorKD self, VectorKD ret) -> VectorKD"""
3829  return _IMP_algebra.VectorKD___add__(self, ret)
3830 
3831 
3832  def __mul__(self, *args):
3833  """
3834  __mul__(VectorKD self, double s) -> VectorKD
3835  __mul__(VectorKD self, VectorKD o) -> double
3836  """
3837  return _IMP_algebra.VectorKD___mul__(self, *args)
3838 
3839 
3840  def __init__(self, *args):
3841  """
3842  __init__(IMP::algebra::VectorD<(-1)> self, IMP::Floats const & f) -> VectorKD
3843  __init__(IMP::algebra::VectorD<(-1)> self) -> VectorKD
3844  __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1, double x2, double x3, double x4, double x5) -> VectorKD
3845  __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1, double x2, double x3, double x4) -> VectorKD
3846  __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1, double x2, double x3) -> VectorKD
3847  __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1, double x2) -> VectorKD
3848  __init__(IMP::algebra::VectorD<(-1)> self, double x0, double x1) -> VectorKD
3849  __init__(IMP::algebra::VectorD<(-1)> self, double x0) -> VectorKD
3850  """
3851  this = _IMP_algebra.new_VectorKD(*args)
3852  try:
3853  self.this.append(this)
3854  except:
3855  self.this = this
3856 
3857  def __iadd__(self, *args):
3858  _IMP_algebra.VectorKD___iadd__(self, *args)
3859  return self
3860 
3861 
3862 
3863  def __imul__(self, *args):
3864  _IMP_algebra.VectorKD___imul__(self, *args)
3865  return self
3866 
3867 
3868 
3869  def __idiv__(self, *args):
3870  _IMP_algebra.VectorKD___idiv__(self, *args)
3871  return self
3872 
3873 
3874 
3875  def __isub__(self, *args):
3876  _IMP_algebra.VectorKD___isub__(self, *args)
3877  return self
3878 
3879 
3880 
3881  def __len__(self):
3882  """__len__(VectorKD self) -> unsigned int"""
3883  return _IMP_algebra.VectorKD___len__(self)
3884 
3885 
3886  def __rmul__(self, f):
3887  """__rmul__(VectorKD self, double f) -> VectorKD"""
3888  return _IMP_algebra.VectorKD___rmul__(self, f)
3889 
3890 
3891  def __str__(self):
3892  """__str__(VectorKD self) -> std::string"""
3893  return _IMP_algebra.VectorKD___str__(self)
3894 
3895 
3896  def __repr__(self):
3897  """__repr__(VectorKD self) -> std::string"""
3898  return _IMP_algebra.VectorKD___repr__(self)
3899 
3900 
3901  def __cmp__(self, arg2):
3902  """__cmp__(VectorKD self, VectorKD arg2) -> int"""
3903  return _IMP_algebra.VectorKD___cmp__(self, arg2)
3904 
3905 
3906  def __eq__(self, arg2):
3907  """__eq__(VectorKD self, VectorKD arg2) -> bool"""
3908  return _IMP_algebra.VectorKD___eq__(self, arg2)
3909 
3910 
3911  __truediv__ = __div__
3912  __itruediv__ = __idiv__
3913 
3914 
3915  def _get_as_binary(self):
3916  """_get_as_binary(VectorKD self) -> PyObject *"""
3917  return _IMP_algebra.VectorKD__get_as_binary(self)
3918 
3919 
3920  def _set_from_binary(self, p):
3921  """_set_from_binary(VectorKD self, PyObject * p)"""
3922  return _IMP_algebra.VectorKD__set_from_binary(self, p)
3923 
3924 
3925  def __getstate__(self):
3926  p = self._get_as_binary()
3927  if len(self.__dict__) > 1:
3928  d = self.__dict__.copy()
3929  del d['this']
3930  p = (d, p)
3931  return p
3932 
3933  def __setstate__(self, p):
3934  if not hasattr(self, 'this'):
3935  self.__init__()
3936  if isinstance(p, tuple):
3937  d, p = p
3938  self.__dict__.update(d)
3939  return self._set_from_binary(p)
3940 
3941 
3942  def __getitem__(self, index):
3943  """__getitem__(VectorKD self, int index) -> double"""
3944  return _IMP_algebra.VectorKD___getitem__(self, index)
3945 
3946 
3947  def __setitem__(self, index, val):
3948  """__setitem__(VectorKD self, int index, double val)"""
3949  return _IMP_algebra.VectorKD___setitem__(self, index, val)
3950 
3951  __swig_destroy__ = _IMP_algebra.delete_VectorKD
3952  __del__ = lambda self: None
3953 VectorKD_swigregister = _IMP_algebra.VectorKD_swigregister
3954 VectorKD_swigregister(VectorKD)
3955 
3956 class BoundingBox1D(object):
3957  """Proxy of C++ IMP::algebra::BoundingBoxD<(1)> class"""
3958  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3959 
3960  def get_dimension(self):
3961  """get_dimension(BoundingBox1D self) -> unsigned int"""
3962  return _IMP_algebra.BoundingBox1D_get_dimension(self)
3963 
3964 
3965  def get_corner(self, i):
3966  """get_corner(BoundingBox1D self, unsigned int i) -> Vector1D"""
3967  return _IMP_algebra.BoundingBox1D_get_corner(self, i)
3968 
3969 
3970  def get_contains(self, *args):
3971  """
3972  get_contains(BoundingBox1D self, Vector1D o) -> bool
3973  get_contains(BoundingBox1D self, BoundingBox1D bb) -> bool
3974  """
3975  return _IMP_algebra.BoundingBox1D_get_contains(self, *args)
3976 
3977 
3978  def show(self, *args):
3979  """
3980  show(BoundingBox1D self, _ostream out)
3981  show(BoundingBox1D self)
3982  """
3983  return _IMP_algebra.BoundingBox1D_show(self, *args)
3984 
3985 
3986  def __str__(self):
3987  """__str__(BoundingBox1D self) -> std::string"""
3988  return _IMP_algebra.BoundingBox1D___str__(self)
3989 
3990 
3991  def __repr__(self):
3992  """__repr__(BoundingBox1D self) -> std::string"""
3993  return _IMP_algebra.BoundingBox1D___repr__(self)
3994 
3995 
3996  def __cmp__(self, arg2):
3997  """__cmp__(BoundingBox1D self, BoundingBox1D arg2) -> int"""
3998  return _IMP_algebra.BoundingBox1D___cmp__(self, arg2)
3999 
4000 
4001  def __eq__(self, arg2):
4002  """__eq__(BoundingBox1D self, BoundingBox1D arg2) -> bool"""
4003  return _IMP_algebra.BoundingBox1D___eq__(self, arg2)
4004 
4005 
4006  def __init__(self, *args):
4007  """
4008  __init__(IMP::algebra::BoundingBoxD<(1)> self, unsigned int d) -> BoundingBox1D
4009  __init__(IMP::algebra::BoundingBoxD<(1)> self, Vector1D lb, Vector1D ub) -> BoundingBox1D
4010  __init__(IMP::algebra::BoundingBoxD<(1)> self, Vector1D v) -> BoundingBox1D
4011  __init__(IMP::algebra::BoundingBoxD<(1)> self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & points) -> BoundingBox1D
4012  __init__(IMP::algebra::BoundingBoxD<(1)> self) -> BoundingBox1D
4013  """
4014  this = _IMP_algebra.new_BoundingBox1D(*args)
4015  try:
4016  self.this.append(this)
4017  except:
4018  self.this = this
4019 
4020  def __getitem__(self, index):
4021  """__getitem__(BoundingBox1D self, unsigned int index) -> Vector1D"""
4022  return _IMP_algebra.BoundingBox1D___getitem__(self, index)
4023 
4024 
4025  def __iadd__(self, *args):
4026  _IMP_algebra.BoundingBox1D___iadd__(self, *args)
4027  return self
4028 
4029 
4030 
4031  def __len__(self):
4032  """__len__(BoundingBox1D self) -> unsigned int"""
4033  return _IMP_algebra.BoundingBox1D___len__(self)
4034 
4035 
4036  def __add__(self, *args):
4037  """
4038  __add__(BoundingBox1D self, BoundingBox1D o) -> BoundingBox1D
4039  __add__(BoundingBox1D self, Vector1D o) -> BoundingBox1D
4040  __add__(BoundingBox1D self, double o) -> BoundingBox1D
4041  """
4042  return _IMP_algebra.BoundingBox1D___add__(self, *args)
4043 
4044 
4045  def _get_as_binary(self):
4046  """_get_as_binary(BoundingBox1D self) -> PyObject *"""
4047  return _IMP_algebra.BoundingBox1D__get_as_binary(self)
4048 
4049 
4050  def _set_from_binary(self, p):
4051  """_set_from_binary(BoundingBox1D self, PyObject * p)"""
4052  return _IMP_algebra.BoundingBox1D__set_from_binary(self, p)
4053 
4054 
4055  def __getstate__(self):
4056  p = self._get_as_binary()
4057  if len(self.__dict__) > 1:
4058  d = self.__dict__.copy()
4059  del d['this']
4060  p = (d, p)
4061  return p
4062 
4063  def __setstate__(self, p):
4064  if not hasattr(self, 'this'):
4065  self.__init__()
4066  if isinstance(p, tuple):
4067  d, p = p
4068  self.__dict__.update(d)
4069  return self._set_from_binary(p)
4070 
4071  __swig_destroy__ = _IMP_algebra.delete_BoundingBox1D
4072  __del__ = lambda self: None
4073 BoundingBox1D_swigregister = _IMP_algebra.BoundingBox1D_swigregister
4074 BoundingBox1D_swigregister(BoundingBox1D)
4075 
4076 class BoundingBox2D(object):
4077  """Proxy of C++ IMP::algebra::BoundingBoxD<(2)> class"""
4078  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4079 
4080  def get_dimension(self):
4081  """get_dimension(BoundingBox2D self) -> unsigned int"""
4082  return _IMP_algebra.BoundingBox2D_get_dimension(self)
4083 
4084 
4085  def get_corner(self, i):
4086  """get_corner(BoundingBox2D self, unsigned int i) -> Vector2D"""
4087  return _IMP_algebra.BoundingBox2D_get_corner(self, i)
4088 
4089 
4090  def get_contains(self, *args):
4091  """
4092  get_contains(BoundingBox2D self, Vector2D o) -> bool
4093  get_contains(BoundingBox2D self, BoundingBox2D bb) -> bool
4094  """
4095  return _IMP_algebra.BoundingBox2D_get_contains(self, *args)
4096 
4097 
4098  def show(self, *args):
4099  """
4100  show(BoundingBox2D self, _ostream out)
4101  show(BoundingBox2D self)
4102  """
4103  return _IMP_algebra.BoundingBox2D_show(self, *args)
4104 
4105 
4106  def __str__(self):
4107  """__str__(BoundingBox2D self) -> std::string"""
4108  return _IMP_algebra.BoundingBox2D___str__(self)
4109 
4110 
4111  def __repr__(self):
4112  """__repr__(BoundingBox2D self) -> std::string"""
4113  return _IMP_algebra.BoundingBox2D___repr__(self)
4114 
4115 
4116  def __cmp__(self, arg2):
4117  """__cmp__(BoundingBox2D self, BoundingBox2D arg2) -> int"""
4118  return _IMP_algebra.BoundingBox2D___cmp__(self, arg2)
4119 
4120 
4121  def __eq__(self, arg2):
4122  """__eq__(BoundingBox2D self, BoundingBox2D arg2) -> bool"""
4123  return _IMP_algebra.BoundingBox2D___eq__(self, arg2)
4124 
4125 
4126  def __init__(self, *args):
4127  """
4128  __init__(IMP::algebra::BoundingBoxD<(2)> self, unsigned int d) -> BoundingBox2D
4129  __init__(IMP::algebra::BoundingBoxD<(2)> self, Vector2D lb, Vector2D ub) -> BoundingBox2D
4130  __init__(IMP::algebra::BoundingBoxD<(2)> self, Vector2D v) -> BoundingBox2D
4131  __init__(IMP::algebra::BoundingBoxD<(2)> self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & points) -> BoundingBox2D
4132  __init__(IMP::algebra::BoundingBoxD<(2)> self) -> BoundingBox2D
4133  """
4134  this = _IMP_algebra.new_BoundingBox2D(*args)
4135  try:
4136  self.this.append(this)
4137  except:
4138  self.this = this
4139 
4140  def __getitem__(self, index):
4141  """__getitem__(BoundingBox2D self, unsigned int index) -> Vector2D"""
4142  return _IMP_algebra.BoundingBox2D___getitem__(self, index)
4143 
4144 
4145  def __iadd__(self, *args):
4146  _IMP_algebra.BoundingBox2D___iadd__(self, *args)
4147  return self
4148 
4149 
4150 
4151  def __len__(self):
4152  """__len__(BoundingBox2D self) -> unsigned int"""
4153  return _IMP_algebra.BoundingBox2D___len__(self)
4154 
4155 
4156  def __add__(self, *args):
4157  """
4158  __add__(BoundingBox2D self, BoundingBox2D o) -> BoundingBox2D
4159  __add__(BoundingBox2D self, Vector2D o) -> BoundingBox2D
4160  __add__(BoundingBox2D self, double o) -> BoundingBox2D
4161  """
4162  return _IMP_algebra.BoundingBox2D___add__(self, *args)
4163 
4164 
4165  def _get_as_binary(self):
4166  """_get_as_binary(BoundingBox2D self) -> PyObject *"""
4167  return _IMP_algebra.BoundingBox2D__get_as_binary(self)
4168 
4169 
4170  def _set_from_binary(self, p):
4171  """_set_from_binary(BoundingBox2D self, PyObject * p)"""
4172  return _IMP_algebra.BoundingBox2D__set_from_binary(self, p)
4173 
4174 
4175  def __getstate__(self):
4176  p = self._get_as_binary()
4177  if len(self.__dict__) > 1:
4178  d = self.__dict__.copy()
4179  del d['this']
4180  p = (d, p)
4181  return p
4182 
4183  def __setstate__(self, p):
4184  if not hasattr(self, 'this'):
4185  self.__init__()
4186  if isinstance(p, tuple):
4187  d, p = p
4188  self.__dict__.update(d)
4189  return self._set_from_binary(p)
4190 
4191  __swig_destroy__ = _IMP_algebra.delete_BoundingBox2D
4192  __del__ = lambda self: None
4193 BoundingBox2D_swigregister = _IMP_algebra.BoundingBox2D_swigregister
4194 BoundingBox2D_swigregister(BoundingBox2D)
4195 
4196 class BoundingBox3D(object):
4197  """Proxy of C++ IMP::algebra::BoundingBoxD<(3)> class"""
4198  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4199 
4200  def get_dimension(self):
4201  """get_dimension(BoundingBox3D self) -> unsigned int"""
4202  return _IMP_algebra.BoundingBox3D_get_dimension(self)
4203 
4204 
4205  def get_corner(self, i):
4206  """get_corner(BoundingBox3D self, unsigned int i) -> Vector3D"""
4207  return _IMP_algebra.BoundingBox3D_get_corner(self, i)
4208 
4209 
4210  def get_contains(self, *args):
4211  """
4212  get_contains(BoundingBox3D self, Vector3D o) -> bool
4213  get_contains(BoundingBox3D self, BoundingBox3D bb) -> bool
4214  """
4215  return _IMP_algebra.BoundingBox3D_get_contains(self, *args)
4216 
4217 
4218  def show(self, *args):
4219  """
4220  show(BoundingBox3D self, _ostream out)
4221  show(BoundingBox3D self)
4222  """
4223  return _IMP_algebra.BoundingBox3D_show(self, *args)
4224 
4225 
4226  def __str__(self):
4227  """__str__(BoundingBox3D self) -> std::string"""
4228  return _IMP_algebra.BoundingBox3D___str__(self)
4229 
4230 
4231  def __repr__(self):
4232  """__repr__(BoundingBox3D self) -> std::string"""
4233  return _IMP_algebra.BoundingBox3D___repr__(self)
4234 
4235 
4236  def __cmp__(self, arg2):
4237  """__cmp__(BoundingBox3D self, BoundingBox3D arg2) -> int"""
4238  return _IMP_algebra.BoundingBox3D___cmp__(self, arg2)
4239 
4240 
4241  def __eq__(self, arg2):
4242  """__eq__(BoundingBox3D self, BoundingBox3D arg2) -> bool"""
4243  return _IMP_algebra.BoundingBox3D___eq__(self, arg2)
4244 
4245 
4246  def __init__(self, *args):
4247  """
4248  __init__(IMP::algebra::BoundingBoxD<(3)> self, unsigned int d) -> BoundingBox3D
4249  __init__(IMP::algebra::BoundingBoxD<(3)> self, Vector3D lb, Vector3D ub) -> BoundingBox3D
4250  __init__(IMP::algebra::BoundingBoxD<(3)> self, Vector3D v) -> BoundingBox3D
4251  __init__(IMP::algebra::BoundingBoxD<(3)> self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & points) -> BoundingBox3D
4252  __init__(IMP::algebra::BoundingBoxD<(3)> self) -> BoundingBox3D
4253  """
4254  this = _IMP_algebra.new_BoundingBox3D(*args)
4255  try:
4256  self.this.append(this)
4257  except:
4258  self.this = this
4259 
4260  def __getitem__(self, index):
4261  """__getitem__(BoundingBox3D self, unsigned int index) -> Vector3D"""
4262  return _IMP_algebra.BoundingBox3D___getitem__(self, index)
4263 
4264 
4265  def __iadd__(self, *args):
4266  _IMP_algebra.BoundingBox3D___iadd__(self, *args)
4267  return self
4268 
4269 
4270 
4271  def __len__(self):
4272  """__len__(BoundingBox3D self) -> unsigned int"""
4273  return _IMP_algebra.BoundingBox3D___len__(self)
4274 
4275 
4276  def __add__(self, *args):
4277  """
4278  __add__(BoundingBox3D self, BoundingBox3D o) -> BoundingBox3D
4279  __add__(BoundingBox3D self, Vector3D o) -> BoundingBox3D
4280  __add__(BoundingBox3D self, double o) -> BoundingBox3D
4281  """
4282  return _IMP_algebra.BoundingBox3D___add__(self, *args)
4283 
4284 
4285  def _get_as_binary(self):
4286  """_get_as_binary(BoundingBox3D self) -> PyObject *"""
4287  return _IMP_algebra.BoundingBox3D__get_as_binary(self)
4288 
4289 
4290  def _set_from_binary(self, p):
4291  """_set_from_binary(BoundingBox3D self, PyObject * p)"""
4292  return _IMP_algebra.BoundingBox3D__set_from_binary(self, p)
4293 
4294 
4295  def __getstate__(self):
4296  p = self._get_as_binary()
4297  if len(self.__dict__) > 1:
4298  d = self.__dict__.copy()
4299  del d['this']
4300  p = (d, p)
4301  return p
4302 
4303  def __setstate__(self, p):
4304  if not hasattr(self, 'this'):
4305  self.__init__()
4306  if isinstance(p, tuple):
4307  d, p = p
4308  self.__dict__.update(d)
4309  return self._set_from_binary(p)
4310 
4311  __swig_destroy__ = _IMP_algebra.delete_BoundingBox3D
4312  __del__ = lambda self: None
4313 BoundingBox3D_swigregister = _IMP_algebra.BoundingBox3D_swigregister
4314 BoundingBox3D_swigregister(BoundingBox3D)
4315 
4316 class BoundingBox4D(object):
4317  """Proxy of C++ IMP::algebra::BoundingBoxD<(4)> class"""
4318  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4319 
4320  def get_dimension(self):
4321  """get_dimension(BoundingBox4D self) -> unsigned int"""
4322  return _IMP_algebra.BoundingBox4D_get_dimension(self)
4323 
4324 
4325  def get_corner(self, i):
4326  """get_corner(BoundingBox4D self, unsigned int i) -> Vector4D"""
4327  return _IMP_algebra.BoundingBox4D_get_corner(self, i)
4328 
4329 
4330  def get_contains(self, *args):
4331  """
4332  get_contains(BoundingBox4D self, Vector4D o) -> bool
4333  get_contains(BoundingBox4D self, BoundingBox4D bb) -> bool
4334  """
4335  return _IMP_algebra.BoundingBox4D_get_contains(self, *args)
4336 
4337 
4338  def show(self, *args):
4339  """
4340  show(BoundingBox4D self, _ostream out)
4341  show(BoundingBox4D self)
4342  """
4343  return _IMP_algebra.BoundingBox4D_show(self, *args)
4344 
4345 
4346  def __str__(self):
4347  """__str__(BoundingBox4D self) -> std::string"""
4348  return _IMP_algebra.BoundingBox4D___str__(self)
4349 
4350 
4351  def __repr__(self):
4352  """__repr__(BoundingBox4D self) -> std::string"""
4353  return _IMP_algebra.BoundingBox4D___repr__(self)
4354 
4355 
4356  def __cmp__(self, arg2):
4357  """__cmp__(BoundingBox4D self, BoundingBox4D arg2) -> int"""
4358  return _IMP_algebra.BoundingBox4D___cmp__(self, arg2)
4359 
4360 
4361  def __eq__(self, arg2):
4362  """__eq__(BoundingBox4D self, BoundingBox4D arg2) -> bool"""
4363  return _IMP_algebra.BoundingBox4D___eq__(self, arg2)
4364 
4365 
4366  def __init__(self, *args):
4367  """
4368  __init__(IMP::algebra::BoundingBoxD<(4)> self, unsigned int d) -> BoundingBox4D
4369  __init__(IMP::algebra::BoundingBoxD<(4)> self, Vector4D lb, Vector4D ub) -> BoundingBox4D
4370  __init__(IMP::algebra::BoundingBoxD<(4)> self, Vector4D v) -> BoundingBox4D
4371  __init__(IMP::algebra::BoundingBoxD<(4)> self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & points) -> BoundingBox4D
4372  __init__(IMP::algebra::BoundingBoxD<(4)> self) -> BoundingBox4D
4373  """
4374  this = _IMP_algebra.new_BoundingBox4D(*args)
4375  try:
4376  self.this.append(this)
4377  except:
4378  self.this = this
4379 
4380  def __getitem__(self, index):
4381  """__getitem__(BoundingBox4D self, unsigned int index) -> Vector4D"""
4382  return _IMP_algebra.BoundingBox4D___getitem__(self, index)
4383 
4384 
4385  def __iadd__(self, *args):
4386  _IMP_algebra.BoundingBox4D___iadd__(self, *args)
4387  return self
4388 
4389 
4390 
4391  def __len__(self):
4392  """__len__(BoundingBox4D self) -> unsigned int"""
4393  return _IMP_algebra.BoundingBox4D___len__(self)
4394 
4395 
4396  def __add__(self, *args):
4397  """
4398  __add__(BoundingBox4D self, BoundingBox4D o) -> BoundingBox4D
4399  __add__(BoundingBox4D self, Vector4D o) -> BoundingBox4D
4400  __add__(BoundingBox4D self, double o) -> BoundingBox4D
4401  """
4402  return _IMP_algebra.BoundingBox4D___add__(self, *args)
4403 
4404 
4405  def _get_as_binary(self):
4406  """_get_as_binary(BoundingBox4D self) -> PyObject *"""
4407  return _IMP_algebra.BoundingBox4D__get_as_binary(self)
4408 
4409 
4410  def _set_from_binary(self, p):
4411  """_set_from_binary(BoundingBox4D self, PyObject * p)"""
4412  return _IMP_algebra.BoundingBox4D__set_from_binary(self, p)
4413 
4414 
4415  def __getstate__(self):
4416  p = self._get_as_binary()
4417  if len(self.__dict__) > 1:
4418  d = self.__dict__.copy()
4419  del d['this']
4420  p = (d, p)
4421  return p
4422 
4423  def __setstate__(self, p):
4424  if not hasattr(self, 'this'):
4425  self.__init__()
4426  if isinstance(p, tuple):
4427  d, p = p
4428  self.__dict__.update(d)
4429  return self._set_from_binary(p)
4430 
4431  __swig_destroy__ = _IMP_algebra.delete_BoundingBox4D
4432  __del__ = lambda self: None
4433 BoundingBox4D_swigregister = _IMP_algebra.BoundingBox4D_swigregister
4434 BoundingBox4D_swigregister(BoundingBox4D)
4435 
4436 class BoundingBox5D(object):
4437  """Proxy of C++ IMP::algebra::BoundingBoxD<(5)> class"""
4438  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4439 
4440  def get_dimension(self):
4441  """get_dimension(BoundingBox5D self) -> unsigned int"""
4442  return _IMP_algebra.BoundingBox5D_get_dimension(self)
4443 
4444 
4445  def get_corner(self, i):
4446  """get_corner(BoundingBox5D self, unsigned int i) -> Vector5D"""
4447  return _IMP_algebra.BoundingBox5D_get_corner(self, i)
4448 
4449 
4450  def get_contains(self, *args):
4451  """
4452  get_contains(BoundingBox5D self, Vector5D o) -> bool
4453  get_contains(BoundingBox5D self, BoundingBox5D bb) -> bool
4454  """
4455  return _IMP_algebra.BoundingBox5D_get_contains(self, *args)
4456 
4457 
4458  def show(self, *args):
4459  """
4460  show(BoundingBox5D self, _ostream out)
4461  show(BoundingBox5D self)
4462  """
4463  return _IMP_algebra.BoundingBox5D_show(self, *args)
4464 
4465 
4466  def __str__(self):
4467  """__str__(BoundingBox5D self) -> std::string"""
4468  return _IMP_algebra.BoundingBox5D___str__(self)
4469 
4470 
4471  def __repr__(self):
4472  """__repr__(BoundingBox5D self) -> std::string"""
4473  return _IMP_algebra.BoundingBox5D___repr__(self)
4474 
4475 
4476  def __cmp__(self, arg2):
4477  """__cmp__(BoundingBox5D self, BoundingBox5D arg2) -> int"""
4478  return _IMP_algebra.BoundingBox5D___cmp__(self, arg2)
4479 
4480 
4481  def __eq__(self, arg2):
4482  """__eq__(BoundingBox5D self, BoundingBox5D arg2) -> bool"""
4483  return _IMP_algebra.BoundingBox5D___eq__(self, arg2)
4484 
4485 
4486  def __init__(self, *args):
4487  """
4488  __init__(IMP::algebra::BoundingBoxD<(5)> self, unsigned int d) -> BoundingBox5D
4489  __init__(IMP::algebra::BoundingBoxD<(5)> self, Vector5D lb, Vector5D ub) -> BoundingBox5D
4490  __init__(IMP::algebra::BoundingBoxD<(5)> self, Vector5D v) -> BoundingBox5D
4491  __init__(IMP::algebra::BoundingBoxD<(5)> self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & points) -> BoundingBox5D
4492  __init__(IMP::algebra::BoundingBoxD<(5)> self) -> BoundingBox5D
4493  """
4494  this = _IMP_algebra.new_BoundingBox5D(*args)
4495  try:
4496  self.this.append(this)
4497  except:
4498  self.this = this
4499 
4500  def __getitem__(self, index):
4501  """__getitem__(BoundingBox5D self, unsigned int index) -> Vector5D"""
4502  return _IMP_algebra.BoundingBox5D___getitem__(self, index)
4503 
4504 
4505  def __iadd__(self, *args):
4506  _IMP_algebra.BoundingBox5D___iadd__(self, *args)
4507  return self
4508 
4509 
4510 
4511  def __len__(self):
4512  """__len__(BoundingBox5D self) -> unsigned int"""
4513  return _IMP_algebra.BoundingBox5D___len__(self)
4514 
4515 
4516  def __add__(self, *args):
4517  """
4518  __add__(BoundingBox5D self, BoundingBox5D o) -> BoundingBox5D
4519  __add__(BoundingBox5D self, Vector5D o) -> BoundingBox5D
4520  __add__(BoundingBox5D self, double o) -> BoundingBox5D
4521  """
4522  return _IMP_algebra.BoundingBox5D___add__(self, *args)
4523 
4524 
4525  def _get_as_binary(self):
4526  """_get_as_binary(BoundingBox5D self) -> PyObject *"""
4527  return _IMP_algebra.BoundingBox5D__get_as_binary(self)
4528 
4529 
4530  def _set_from_binary(self, p):
4531  """_set_from_binary(BoundingBox5D self, PyObject * p)"""
4532  return _IMP_algebra.BoundingBox5D__set_from_binary(self, p)
4533 
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_BoundingBox5D
4552  __del__ = lambda self: None
4553 BoundingBox5D_swigregister = _IMP_algebra.BoundingBox5D_swigregister
4554 BoundingBox5D_swigregister(BoundingBox5D)
4555 
4556 class BoundingBox6D(object):
4557  """Proxy of C++ IMP::algebra::BoundingBoxD<(6)> class"""
4558  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4559 
4560  def get_dimension(self):
4561  """get_dimension(BoundingBox6D self) -> unsigned int"""
4562  return _IMP_algebra.BoundingBox6D_get_dimension(self)
4563 
4564 
4565  def get_corner(self, i):
4566  """get_corner(BoundingBox6D self, unsigned int i) -> Vector6D"""
4567  return _IMP_algebra.BoundingBox6D_get_corner(self, i)
4568 
4569 
4570  def get_contains(self, *args):
4571  """
4572  get_contains(BoundingBox6D self, Vector6D o) -> bool
4573  get_contains(BoundingBox6D self, BoundingBox6D bb) -> bool
4574  """
4575  return _IMP_algebra.BoundingBox6D_get_contains(self, *args)
4576 
4577 
4578  def show(self, *args):
4579  """
4580  show(BoundingBox6D self, _ostream out)
4581  show(BoundingBox6D self)
4582  """
4583  return _IMP_algebra.BoundingBox6D_show(self, *args)
4584 
4585 
4586  def __str__(self):
4587  """__str__(BoundingBox6D self) -> std::string"""
4588  return _IMP_algebra.BoundingBox6D___str__(self)
4589 
4590 
4591  def __repr__(self):
4592  """__repr__(BoundingBox6D self) -> std::string"""
4593  return _IMP_algebra.BoundingBox6D___repr__(self)
4594 
4595 
4596  def __cmp__(self, arg2):
4597  """__cmp__(BoundingBox6D self, BoundingBox6D arg2) -> int"""
4598  return _IMP_algebra.BoundingBox6D___cmp__(self, arg2)
4599 
4600 
4601  def __eq__(self, arg2):
4602  """__eq__(BoundingBox6D self, BoundingBox6D arg2) -> bool"""
4603  return _IMP_algebra.BoundingBox6D___eq__(self, arg2)
4604 
4605 
4606  def __init__(self, *args):
4607  """
4608  __init__(IMP::algebra::BoundingBoxD<(6)> self, unsigned int d) -> BoundingBox6D
4609  __init__(IMP::algebra::BoundingBoxD<(6)> self, Vector6D lb, Vector6D ub) -> BoundingBox6D
4610  __init__(IMP::algebra::BoundingBoxD<(6)> self, Vector6D v) -> BoundingBox6D
4611  __init__(IMP::algebra::BoundingBoxD<(6)> self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & points) -> BoundingBox6D
4612  __init__(IMP::algebra::BoundingBoxD<(6)> self) -> BoundingBox6D
4613  """
4614  this = _IMP_algebra.new_BoundingBox6D(*args)
4615  try:
4616  self.this.append(this)
4617  except:
4618  self.this = this
4619 
4620  def __getitem__(self, index):
4621  """__getitem__(BoundingBox6D self, unsigned int index) -> Vector6D"""
4622  return _IMP_algebra.BoundingBox6D___getitem__(self, index)
4623 
4624 
4625  def __iadd__(self, *args):
4626  _IMP_algebra.BoundingBox6D___iadd__(self, *args)
4627  return self
4628 
4629 
4630 
4631  def __len__(self):
4632  """__len__(BoundingBox6D self) -> unsigned int"""
4633  return _IMP_algebra.BoundingBox6D___len__(self)
4634 
4635 
4636  def __add__(self, *args):
4637  """
4638  __add__(BoundingBox6D self, BoundingBox6D o) -> BoundingBox6D
4639  __add__(BoundingBox6D self, Vector6D o) -> BoundingBox6D
4640  __add__(BoundingBox6D self, double o) -> BoundingBox6D
4641  """
4642  return _IMP_algebra.BoundingBox6D___add__(self, *args)
4643 
4644 
4645  def _get_as_binary(self):
4646  """_get_as_binary(BoundingBox6D self) -> PyObject *"""
4647  return _IMP_algebra.BoundingBox6D__get_as_binary(self)
4648 
4649 
4650  def _set_from_binary(self, p):
4651  """_set_from_binary(BoundingBox6D self, PyObject * p)"""
4652  return _IMP_algebra.BoundingBox6D__set_from_binary(self, p)
4653 
4654 
4655  def __getstate__(self):
4656  p = self._get_as_binary()
4657  if len(self.__dict__) > 1:
4658  d = self.__dict__.copy()
4659  del d['this']
4660  p = (d, p)
4661  return p
4662 
4663  def __setstate__(self, p):
4664  if not hasattr(self, 'this'):
4665  self.__init__()
4666  if isinstance(p, tuple):
4667  d, p = p
4668  self.__dict__.update(d)
4669  return self._set_from_binary(p)
4670 
4671  __swig_destroy__ = _IMP_algebra.delete_BoundingBox6D
4672  __del__ = lambda self: None
4673 BoundingBox6D_swigregister = _IMP_algebra.BoundingBox6D_swigregister
4674 BoundingBox6D_swigregister(BoundingBox6D)
4675 
4676 class BoundingBoxKD(object):
4677  """Proxy of C++ IMP::algebra::BoundingBoxD<(-1)> class"""
4678  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4679 
4680  def get_dimension(self):
4681  """get_dimension(BoundingBoxKD self) -> unsigned int"""
4682  return _IMP_algebra.BoundingBoxKD_get_dimension(self)
4683 
4684 
4685  def get_corner(self, i):
4686  """get_corner(BoundingBoxKD self, unsigned int i) -> VectorKD"""
4687  return _IMP_algebra.BoundingBoxKD_get_corner(self, i)
4688 
4689 
4690  def get_contains(self, *args):
4691  """
4692  get_contains(BoundingBoxKD self, VectorKD o) -> bool
4693  get_contains(BoundingBoxKD self, BoundingBoxKD bb) -> bool
4694  """
4695  return _IMP_algebra.BoundingBoxKD_get_contains(self, *args)
4696 
4697 
4698  def show(self, *args):
4699  """
4700  show(BoundingBoxKD self, _ostream out)
4701  show(BoundingBoxKD self)
4702  """
4703  return _IMP_algebra.BoundingBoxKD_show(self, *args)
4704 
4705 
4706  def __str__(self):
4707  """__str__(BoundingBoxKD self) -> std::string"""
4708  return _IMP_algebra.BoundingBoxKD___str__(self)
4709 
4710 
4711  def __repr__(self):
4712  """__repr__(BoundingBoxKD self) -> std::string"""
4713  return _IMP_algebra.BoundingBoxKD___repr__(self)
4714 
4715 
4716  def __cmp__(self, arg2):
4717  """__cmp__(BoundingBoxKD self, BoundingBoxKD arg2) -> int"""
4718  return _IMP_algebra.BoundingBoxKD___cmp__(self, arg2)
4719 
4720 
4721  def __eq__(self, arg2):
4722  """__eq__(BoundingBoxKD self, BoundingBoxKD arg2) -> bool"""
4723  return _IMP_algebra.BoundingBoxKD___eq__(self, arg2)
4724 
4725 
4726  def __init__(self, *args):
4727  """
4728  __init__(IMP::algebra::BoundingBoxD<(-1)> self, unsigned int d) -> BoundingBoxKD
4729  __init__(IMP::algebra::BoundingBoxD<(-1)> self, VectorKD lb, VectorKD ub) -> BoundingBoxKD
4730  __init__(IMP::algebra::BoundingBoxD<(-1)> self, VectorKD v) -> BoundingBoxKD
4731  __init__(IMP::algebra::BoundingBoxD<(-1)> self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & points) -> BoundingBoxKD
4732  __init__(IMP::algebra::BoundingBoxD<(-1)> self) -> BoundingBoxKD
4733  """
4734  this = _IMP_algebra.new_BoundingBoxKD(*args)
4735  try:
4736  self.this.append(this)
4737  except:
4738  self.this = this
4739 
4740  def __getitem__(self, index):
4741  """__getitem__(BoundingBoxKD self, unsigned int index) -> VectorKD"""
4742  return _IMP_algebra.BoundingBoxKD___getitem__(self, index)
4743 
4744 
4745  def __iadd__(self, *args):
4746  _IMP_algebra.BoundingBoxKD___iadd__(self, *args)
4747  return self
4748 
4749 
4750 
4751  def __len__(self):
4752  """__len__(BoundingBoxKD self) -> unsigned int"""
4753  return _IMP_algebra.BoundingBoxKD___len__(self)
4754 
4755 
4756  def __add__(self, *args):
4757  """
4758  __add__(BoundingBoxKD self, BoundingBoxKD o) -> BoundingBoxKD
4759  __add__(BoundingBoxKD self, VectorKD o) -> BoundingBoxKD
4760  __add__(BoundingBoxKD self, double o) -> BoundingBoxKD
4761  """
4762  return _IMP_algebra.BoundingBoxKD___add__(self, *args)
4763 
4764 
4765  def _get_as_binary(self):
4766  """_get_as_binary(BoundingBoxKD self) -> PyObject *"""
4767  return _IMP_algebra.BoundingBoxKD__get_as_binary(self)
4768 
4769 
4770  def _set_from_binary(self, p):
4771  """_set_from_binary(BoundingBoxKD self, PyObject * p)"""
4772  return _IMP_algebra.BoundingBoxKD__set_from_binary(self, p)
4773 
4774 
4775  def __getstate__(self):
4776  p = self._get_as_binary()
4777  if len(self.__dict__) > 1:
4778  d = self.__dict__.copy()
4779  del d['this']
4780  p = (d, p)
4781  return p
4782 
4783  def __setstate__(self, p):
4784  if not hasattr(self, 'this'):
4785  self.__init__()
4786  if isinstance(p, tuple):
4787  d, p = p
4788  self.__dict__.update(d)
4789  return self._set_from_binary(p)
4790 
4791  __swig_destroy__ = _IMP_algebra.delete_BoundingBoxKD
4792  __del__ = lambda self: None
4793 BoundingBoxKD_swigregister = _IMP_algebra.BoundingBoxKD_swigregister
4794 BoundingBoxKD_swigregister(BoundingBoxKD)
4795 
4796 class Sphere1D(_GeometricPrimitive1D):
4797  """Proxy of C++ IMP::algebra::SphereD<(1)> class"""
4798  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4799 
4800  def __init__(self, *args):
4801  """
4802  __init__(IMP::algebra::SphereD<(1)> self) -> Sphere1D
4803  __init__(IMP::algebra::SphereD<(1)> self, Vector1D center, double radius) -> Sphere1D
4804  """
4805  this = _IMP_algebra.new_Sphere1D(*args)
4806  try:
4807  self.this.append(this)
4808  except:
4809  self.this = this
4810 
4811  def get_radius(self):
4812  """get_radius(Sphere1D self) -> double"""
4813  return _IMP_algebra.Sphere1D_get_radius(self)
4814 
4815 
4816  def get_center(self):
4817  """get_center(Sphere1D self) -> Vector1D"""
4818  return _IMP_algebra.Sphere1D_get_center(self)
4819 
4820 
4821  def get_contains(self, *args):
4822  """
4823  get_contains(Sphere1D self, Sphere1D o) -> bool
4824  get_contains(Sphere1D self, Vector1D p) -> bool
4825  """
4826  return _IMP_algebra.Sphere1D_get_contains(self, *args)
4827 
4828 
4829  def show(self, *args):
4830  """
4831  show(Sphere1D self, _ostream out)
4832  show(Sphere1D self)
4833  """
4834  return _IMP_algebra.Sphere1D_show(self, *args)
4835 
4836 
4837  def get_dimension(self):
4838  """get_dimension(Sphere1D self) -> unsigned int"""
4839  return _IMP_algebra.Sphere1D_get_dimension(self)
4840 
4841 
4842  def __str__(self):
4843  """__str__(Sphere1D self) -> std::string"""
4844  return _IMP_algebra.Sphere1D___str__(self)
4845 
4846 
4847  def __repr__(self):
4848  """__repr__(Sphere1D self) -> std::string"""
4849  return _IMP_algebra.Sphere1D___repr__(self)
4850 
4851 
4852  def __cmp__(self, arg2):
4853  """__cmp__(Sphere1D self, Sphere1D arg2) -> int"""
4854  return _IMP_algebra.Sphere1D___cmp__(self, arg2)
4855 
4856 
4857  def __eq__(self, arg2):
4858  """__eq__(Sphere1D self, Sphere1D arg2) -> bool"""
4859  return _IMP_algebra.Sphere1D___eq__(self, arg2)
4860 
4861 
4862  def _get_as_binary(self):
4863  """_get_as_binary(Sphere1D self) -> PyObject *"""
4864  return _IMP_algebra.Sphere1D__get_as_binary(self)
4865 
4866 
4867  def _set_from_binary(self, p):
4868  """_set_from_binary(Sphere1D self, PyObject * p)"""
4869  return _IMP_algebra.Sphere1D__set_from_binary(self, p)
4870 
4871 
4872  def __getstate__(self):
4873  p = self._get_as_binary()
4874  if len(self.__dict__) > 1:
4875  d = self.__dict__.copy()
4876  del d['this']
4877  p = (d, p)
4878  return p
4879 
4880  def __setstate__(self, p):
4881  if not hasattr(self, 'this'):
4882  self.__init__()
4883  if isinstance(p, tuple):
4884  d, p = p
4885  self.__dict__.update(d)
4886  return self._set_from_binary(p)
4887 
4888  __swig_destroy__ = _IMP_algebra.delete_Sphere1D
4889  __del__ = lambda self: None
4890 Sphere1D_swigregister = _IMP_algebra.Sphere1D_swigregister
4891 Sphere1D_swigregister(Sphere1D)
4892 
4893 class Sphere2D(_GeometricPrimitive2D):
4894  """Proxy of C++ IMP::algebra::SphereD<(2)> class"""
4895  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4896 
4897  def __init__(self, *args):
4898  """
4899  __init__(IMP::algebra::SphereD<(2)> self) -> Sphere2D
4900  __init__(IMP::algebra::SphereD<(2)> self, Vector2D center, double radius) -> Sphere2D
4901  """
4902  this = _IMP_algebra.new_Sphere2D(*args)
4903  try:
4904  self.this.append(this)
4905  except:
4906  self.this = this
4907 
4908  def get_radius(self):
4909  """get_radius(Sphere2D self) -> double"""
4910  return _IMP_algebra.Sphere2D_get_radius(self)
4911 
4912 
4913  def get_center(self):
4914  """get_center(Sphere2D self) -> Vector2D"""
4915  return _IMP_algebra.Sphere2D_get_center(self)
4916 
4917 
4918  def get_contains(self, *args):
4919  """
4920  get_contains(Sphere2D self, Sphere2D o) -> bool
4921  get_contains(Sphere2D self, Vector2D p) -> bool
4922  """
4923  return _IMP_algebra.Sphere2D_get_contains(self, *args)
4924 
4925 
4926  def show(self, *args):
4927  """
4928  show(Sphere2D self, _ostream out)
4929  show(Sphere2D self)
4930  """
4931  return _IMP_algebra.Sphere2D_show(self, *args)
4932 
4933 
4934  def get_dimension(self):
4935  """get_dimension(Sphere2D self) -> unsigned int"""
4936  return _IMP_algebra.Sphere2D_get_dimension(self)
4937 
4938 
4939  def __str__(self):
4940  """__str__(Sphere2D self) -> std::string"""
4941  return _IMP_algebra.Sphere2D___str__(self)
4942 
4943 
4944  def __repr__(self):
4945  """__repr__(Sphere2D self) -> std::string"""
4946  return _IMP_algebra.Sphere2D___repr__(self)
4947 
4948 
4949  def __cmp__(self, arg2):
4950  """__cmp__(Sphere2D self, Sphere2D arg2) -> int"""
4951  return _IMP_algebra.Sphere2D___cmp__(self, arg2)
4952 
4953 
4954  def __eq__(self, arg2):
4955  """__eq__(Sphere2D self, Sphere2D arg2) -> bool"""
4956  return _IMP_algebra.Sphere2D___eq__(self, arg2)
4957 
4958 
4959  def _get_as_binary(self):
4960  """_get_as_binary(Sphere2D self) -> PyObject *"""
4961  return _IMP_algebra.Sphere2D__get_as_binary(self)
4962 
4963 
4964  def _set_from_binary(self, p):
4965  """_set_from_binary(Sphere2D self, PyObject * p)"""
4966  return _IMP_algebra.Sphere2D__set_from_binary(self, p)
4967 
4968 
4969  def __getstate__(self):
4970  p = self._get_as_binary()
4971  if len(self.__dict__) > 1:
4972  d = self.__dict__.copy()
4973  del d['this']
4974  p = (d, p)
4975  return p
4976 
4977  def __setstate__(self, p):
4978  if not hasattr(self, 'this'):
4979  self.__init__()
4980  if isinstance(p, tuple):
4981  d, p = p
4982  self.__dict__.update(d)
4983  return self._set_from_binary(p)
4984 
4985  __swig_destroy__ = _IMP_algebra.delete_Sphere2D
4986  __del__ = lambda self: None
4987 Sphere2D_swigregister = _IMP_algebra.Sphere2D_swigregister
4988 Sphere2D_swigregister(Sphere2D)
4989 
4990 class Sphere3D(_GeometricPrimitive3D):
4991  """Proxy of C++ IMP::algebra::SphereD<(3)> class"""
4992  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4993 
4994  def __init__(self, *args):
4995  """
4996  __init__(IMP::algebra::SphereD<(3)> self) -> Sphere3D
4997  __init__(IMP::algebra::SphereD<(3)> self, Vector3D center, double radius) -> Sphere3D
4998  """
4999  this = _IMP_algebra.new_Sphere3D(*args)
5000  try:
5001  self.this.append(this)
5002  except:
5003  self.this = this
5004 
5005  def get_radius(self):
5006  """get_radius(Sphere3D self) -> double"""
5007  return _IMP_algebra.Sphere3D_get_radius(self)
5008 
5009 
5010  def get_center(self):
5011  """get_center(Sphere3D self) -> Vector3D"""
5012  return _IMP_algebra.Sphere3D_get_center(self)
5013 
5014 
5015  def get_contains(self, *args):
5016  """
5017  get_contains(Sphere3D self, Sphere3D o) -> bool
5018  get_contains(Sphere3D self, Vector3D p) -> bool
5019  """
5020  return _IMP_algebra.Sphere3D_get_contains(self, *args)
5021 
5022 
5023  def show(self, *args):
5024  """
5025  show(Sphere3D self, _ostream out)
5026  show(Sphere3D self)
5027  """
5028  return _IMP_algebra.Sphere3D_show(self, *args)
5029 
5030 
5031  def get_dimension(self):
5032  """get_dimension(Sphere3D self) -> unsigned int"""
5033  return _IMP_algebra.Sphere3D_get_dimension(self)
5034 
5035 
5036  def __str__(self):
5037  """__str__(Sphere3D self) -> std::string"""
5038  return _IMP_algebra.Sphere3D___str__(self)
5039 
5040 
5041  def __repr__(self):
5042  """__repr__(Sphere3D self) -> std::string"""
5043  return _IMP_algebra.Sphere3D___repr__(self)
5044 
5045 
5046  def __cmp__(self, arg2):
5047  """__cmp__(Sphere3D self, Sphere3D arg2) -> int"""
5048  return _IMP_algebra.Sphere3D___cmp__(self, arg2)
5049 
5050 
5051  def __eq__(self, arg2):
5052  """__eq__(Sphere3D self, Sphere3D arg2) -> bool"""
5053  return _IMP_algebra.Sphere3D___eq__(self, arg2)
5054 
5055 
5056  def _get_as_binary(self):
5057  """_get_as_binary(Sphere3D self) -> PyObject *"""
5058  return _IMP_algebra.Sphere3D__get_as_binary(self)
5059 
5060 
5061  def _set_from_binary(self, p):
5062  """_set_from_binary(Sphere3D self, PyObject * p)"""
5063  return _IMP_algebra.Sphere3D__set_from_binary(self, p)
5064 
5065 
5066  def __getstate__(self):
5067  p = self._get_as_binary()
5068  if len(self.__dict__) > 1:
5069  d = self.__dict__.copy()
5070  del d['this']
5071  p = (d, p)
5072  return p
5073 
5074  def __setstate__(self, p):
5075  if not hasattr(self, 'this'):
5076  self.__init__()
5077  if isinstance(p, tuple):
5078  d, p = p
5079  self.__dict__.update(d)
5080  return self._set_from_binary(p)
5081 
5082  __swig_destroy__ = _IMP_algebra.delete_Sphere3D
5083  __del__ = lambda self: None
5084 Sphere3D_swigregister = _IMP_algebra.Sphere3D_swigregister
5085 Sphere3D_swigregister(Sphere3D)
5086 
5087 class Sphere4D(_GeometricPrimitive4D):
5088  """Proxy of C++ IMP::algebra::SphereD<(4)> class"""
5089  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5090 
5091  def __init__(self, *args):
5092  """
5093  __init__(IMP::algebra::SphereD<(4)> self) -> Sphere4D
5094  __init__(IMP::algebra::SphereD<(4)> self, Vector4D center, double radius) -> Sphere4D
5095  """
5096  this = _IMP_algebra.new_Sphere4D(*args)
5097  try:
5098  self.this.append(this)
5099  except:
5100  self.this = this
5101 
5102  def get_radius(self):
5103  """get_radius(Sphere4D self) -> double"""
5104  return _IMP_algebra.Sphere4D_get_radius(self)
5105 
5106 
5107  def get_center(self):
5108  """get_center(Sphere4D self) -> Vector4D"""
5109  return _IMP_algebra.Sphere4D_get_center(self)
5110 
5111 
5112  def get_contains(self, *args):
5113  """
5114  get_contains(Sphere4D self, Sphere4D o) -> bool
5115  get_contains(Sphere4D self, Vector4D p) -> bool
5116  """
5117  return _IMP_algebra.Sphere4D_get_contains(self, *args)
5118 
5119 
5120  def show(self, *args):
5121  """
5122  show(Sphere4D self, _ostream out)
5123  show(Sphere4D self)
5124  """
5125  return _IMP_algebra.Sphere4D_show(self, *args)
5126 
5127 
5128  def get_dimension(self):
5129  """get_dimension(Sphere4D self) -> unsigned int"""
5130  return _IMP_algebra.Sphere4D_get_dimension(self)
5131 
5132 
5133  def __str__(self):
5134  """__str__(Sphere4D self) -> std::string"""
5135  return _IMP_algebra.Sphere4D___str__(self)
5136 
5137 
5138  def __repr__(self):
5139  """__repr__(Sphere4D self) -> std::string"""
5140  return _IMP_algebra.Sphere4D___repr__(self)
5141 
5142 
5143  def __cmp__(self, arg2):
5144  """__cmp__(Sphere4D self, Sphere4D arg2) -> int"""
5145  return _IMP_algebra.Sphere4D___cmp__(self, arg2)
5146 
5147 
5148  def __eq__(self, arg2):
5149  """__eq__(Sphere4D self, Sphere4D arg2) -> bool"""
5150  return _IMP_algebra.Sphere4D___eq__(self, arg2)
5151 
5152 
5153  def _get_as_binary(self):
5154  """_get_as_binary(Sphere4D self) -> PyObject *"""
5155  return _IMP_algebra.Sphere4D__get_as_binary(self)
5156 
5157 
5158  def _set_from_binary(self, p):
5159  """_set_from_binary(Sphere4D self, PyObject * p)"""
5160  return _IMP_algebra.Sphere4D__set_from_binary(self, p)
5161 
5162 
5163  def __getstate__(self):
5164  p = self._get_as_binary()
5165  if len(self.__dict__) > 1:
5166  d = self.__dict__.copy()
5167  del d['this']
5168  p = (d, p)
5169  return p
5170 
5171  def __setstate__(self, p):
5172  if not hasattr(self, 'this'):
5173  self.__init__()
5174  if isinstance(p, tuple):
5175  d, p = p
5176  self.__dict__.update(d)
5177  return self._set_from_binary(p)
5178 
5179  __swig_destroy__ = _IMP_algebra.delete_Sphere4D
5180  __del__ = lambda self: None
5181 Sphere4D_swigregister = _IMP_algebra.Sphere4D_swigregister
5182 Sphere4D_swigregister(Sphere4D)
5183 
5184 class Sphere5D(_GeometricPrimitive5D):
5185  """Proxy of C++ IMP::algebra::SphereD<(5)> class"""
5186  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5187 
5188  def __init__(self, *args):
5189  """
5190  __init__(IMP::algebra::SphereD<(5)> self) -> Sphere5D
5191  __init__(IMP::algebra::SphereD<(5)> self, Vector5D center, double radius) -> Sphere5D
5192  """
5193  this = _IMP_algebra.new_Sphere5D(*args)
5194  try:
5195  self.this.append(this)
5196  except:
5197  self.this = this
5198 
5199  def get_radius(self):
5200  """get_radius(Sphere5D self) -> double"""
5201  return _IMP_algebra.Sphere5D_get_radius(self)
5202 
5203 
5204  def get_center(self):
5205  """get_center(Sphere5D self) -> Vector5D"""
5206  return _IMP_algebra.Sphere5D_get_center(self)
5207 
5208 
5209  def get_contains(self, *args):
5210  """
5211  get_contains(Sphere5D self, Sphere5D o) -> bool
5212  get_contains(Sphere5D self, Vector5D p) -> bool
5213  """
5214  return _IMP_algebra.Sphere5D_get_contains(self, *args)
5215 
5216 
5217  def show(self, *args):
5218  """
5219  show(Sphere5D self, _ostream out)
5220  show(Sphere5D self)
5221  """
5222  return _IMP_algebra.Sphere5D_show(self, *args)
5223 
5224 
5225  def get_dimension(self):
5226  """get_dimension(Sphere5D self) -> unsigned int"""
5227  return _IMP_algebra.Sphere5D_get_dimension(self)
5228 
5229 
5230  def __str__(self):
5231  """__str__(Sphere5D self) -> std::string"""
5232  return _IMP_algebra.Sphere5D___str__(self)
5233 
5234 
5235  def __repr__(self):
5236  """__repr__(Sphere5D self) -> std::string"""
5237  return _IMP_algebra.Sphere5D___repr__(self)
5238 
5239 
5240  def __cmp__(self, arg2):
5241  """__cmp__(Sphere5D self, Sphere5D arg2) -> int"""
5242  return _IMP_algebra.Sphere5D___cmp__(self, arg2)
5243 
5244 
5245  def __eq__(self, arg2):
5246  """__eq__(Sphere5D self, Sphere5D arg2) -> bool"""
5247  return _IMP_algebra.Sphere5D___eq__(self, arg2)
5248 
5249 
5250  def _get_as_binary(self):
5251  """_get_as_binary(Sphere5D self) -> PyObject *"""
5252  return _IMP_algebra.Sphere5D__get_as_binary(self)
5253 
5254 
5255  def _set_from_binary(self, p):
5256  """_set_from_binary(Sphere5D self, PyObject * p)"""
5257  return _IMP_algebra.Sphere5D__set_from_binary(self, p)
5258 
5259 
5260  def __getstate__(self):
5261  p = self._get_as_binary()
5262  if len(self.__dict__) > 1:
5263  d = self.__dict__.copy()
5264  del d['this']
5265  p = (d, p)
5266  return p
5267 
5268  def __setstate__(self, p):
5269  if not hasattr(self, 'this'):
5270  self.__init__()
5271  if isinstance(p, tuple):
5272  d, p = p
5273  self.__dict__.update(d)
5274  return self._set_from_binary(p)
5275 
5276  __swig_destroy__ = _IMP_algebra.delete_Sphere5D
5277  __del__ = lambda self: None
5278 Sphere5D_swigregister = _IMP_algebra.Sphere5D_swigregister
5279 Sphere5D_swigregister(Sphere5D)
5280 
5281 class Sphere6D(_GeometricPrimitive6D):
5282  """Proxy of C++ IMP::algebra::SphereD<(6)> class"""
5283  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5284 
5285  def __init__(self, *args):
5286  """
5287  __init__(IMP::algebra::SphereD<(6)> self) -> Sphere6D
5288  __init__(IMP::algebra::SphereD<(6)> self, Vector6D center, double radius) -> Sphere6D
5289  """
5290  this = _IMP_algebra.new_Sphere6D(*args)
5291  try:
5292  self.this.append(this)
5293  except:
5294  self.this = this
5295 
5296  def get_radius(self):
5297  """get_radius(Sphere6D self) -> double"""
5298  return _IMP_algebra.Sphere6D_get_radius(self)
5299 
5300 
5301  def get_center(self):
5302  """get_center(Sphere6D self) -> Vector6D"""
5303  return _IMP_algebra.Sphere6D_get_center(self)
5304 
5305 
5306  def get_contains(self, *args):
5307  """
5308  get_contains(Sphere6D self, Sphere6D o) -> bool
5309  get_contains(Sphere6D self, Vector6D p) -> bool
5310  """
5311  return _IMP_algebra.Sphere6D_get_contains(self, *args)
5312 
5313 
5314  def show(self, *args):
5315  """
5316  show(Sphere6D self, _ostream out)
5317  show(Sphere6D self)
5318  """
5319  return _IMP_algebra.Sphere6D_show(self, *args)
5320 
5321 
5322  def get_dimension(self):
5323  """get_dimension(Sphere6D self) -> unsigned int"""
5324  return _IMP_algebra.Sphere6D_get_dimension(self)
5325 
5326 
5327  def __str__(self):
5328  """__str__(Sphere6D self) -> std::string"""
5329  return _IMP_algebra.Sphere6D___str__(self)
5330 
5331 
5332  def __repr__(self):
5333  """__repr__(Sphere6D self) -> std::string"""
5334  return _IMP_algebra.Sphere6D___repr__(self)
5335 
5336 
5337  def __cmp__(self, arg2):
5338  """__cmp__(Sphere6D self, Sphere6D arg2) -> int"""
5339  return _IMP_algebra.Sphere6D___cmp__(self, arg2)
5340 
5341 
5342  def __eq__(self, arg2):
5343  """__eq__(Sphere6D self, Sphere6D arg2) -> bool"""
5344  return _IMP_algebra.Sphere6D___eq__(self, arg2)
5345 
5346 
5347  def _get_as_binary(self):
5348  """_get_as_binary(Sphere6D self) -> PyObject *"""
5349  return _IMP_algebra.Sphere6D__get_as_binary(self)
5350 
5351 
5352  def _set_from_binary(self, p):
5353  """_set_from_binary(Sphere6D self, PyObject * p)"""
5354  return _IMP_algebra.Sphere6D__set_from_binary(self, p)
5355 
5356 
5357  def __getstate__(self):
5358  p = self._get_as_binary()
5359  if len(self.__dict__) > 1:
5360  d = self.__dict__.copy()
5361  del d['this']
5362  p = (d, p)
5363  return p
5364 
5365  def __setstate__(self, p):
5366  if not hasattr(self, 'this'):
5367  self.__init__()
5368  if isinstance(p, tuple):
5369  d, p = p
5370  self.__dict__.update(d)
5371  return self._set_from_binary(p)
5372 
5373  __swig_destroy__ = _IMP_algebra.delete_Sphere6D
5374  __del__ = lambda self: None
5375 Sphere6D_swigregister = _IMP_algebra.Sphere6D_swigregister
5376 Sphere6D_swigregister(Sphere6D)
5377 
5378 class SphereKD(_GeometricPrimitiveKD):
5379  """Proxy of C++ IMP::algebra::SphereD<(-1)> class"""
5380  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5381 
5382  def __init__(self, *args):
5383  """
5384  __init__(IMP::algebra::SphereD<(-1)> self) -> SphereKD
5385  __init__(IMP::algebra::SphereD<(-1)> self, VectorKD center, double radius) -> SphereKD
5386  """
5387  this = _IMP_algebra.new_SphereKD(*args)
5388  try:
5389  self.this.append(this)
5390  except:
5391  self.this = this
5392 
5393  def get_radius(self):
5394  """get_radius(SphereKD self) -> double"""
5395  return _IMP_algebra.SphereKD_get_radius(self)
5396 
5397 
5398  def get_center(self):
5399  """get_center(SphereKD self) -> VectorKD"""
5400  return _IMP_algebra.SphereKD_get_center(self)
5401 
5402 
5403  def get_contains(self, *args):
5404  """
5405  get_contains(SphereKD self, SphereKD o) -> bool
5406  get_contains(SphereKD self, VectorKD p) -> bool
5407  """
5408  return _IMP_algebra.SphereKD_get_contains(self, *args)
5409 
5410 
5411  def show(self, *args):
5412  """
5413  show(SphereKD self, _ostream out)
5414  show(SphereKD self)
5415  """
5416  return _IMP_algebra.SphereKD_show(self, *args)
5417 
5418 
5419  def get_dimension(self):
5420  """get_dimension(SphereKD self) -> unsigned int"""
5421  return _IMP_algebra.SphereKD_get_dimension(self)
5422 
5423 
5424  def __str__(self):
5425  """__str__(SphereKD self) -> std::string"""
5426  return _IMP_algebra.SphereKD___str__(self)
5427 
5428 
5429  def __repr__(self):
5430  """__repr__(SphereKD self) -> std::string"""
5431  return _IMP_algebra.SphereKD___repr__(self)
5432 
5433 
5434  def __cmp__(self, arg2):
5435  """__cmp__(SphereKD self, SphereKD arg2) -> int"""
5436  return _IMP_algebra.SphereKD___cmp__(self, arg2)
5437 
5438 
5439  def __eq__(self, arg2):
5440  """__eq__(SphereKD self, SphereKD arg2) -> bool"""
5441  return _IMP_algebra.SphereKD___eq__(self, arg2)
5442 
5443 
5444  def _get_as_binary(self):
5445  """_get_as_binary(SphereKD self) -> PyObject *"""
5446  return _IMP_algebra.SphereKD__get_as_binary(self)
5447 
5448 
5449  def _set_from_binary(self, p):
5450  """_set_from_binary(SphereKD self, PyObject * p)"""
5451  return _IMP_algebra.SphereKD__set_from_binary(self, p)
5452 
5453 
5454  def __getstate__(self):
5455  p = self._get_as_binary()
5456  if len(self.__dict__) > 1:
5457  d = self.__dict__.copy()
5458  del d['this']
5459  p = (d, p)
5460  return p
5461 
5462  def __setstate__(self, p):
5463  if not hasattr(self, 'this'):
5464  self.__init__()
5465  if isinstance(p, tuple):
5466  d, p = p
5467  self.__dict__.update(d)
5468  return self._set_from_binary(p)
5469 
5470  __swig_destroy__ = _IMP_algebra.delete_SphereKD
5471  __del__ = lambda self: None
5472 SphereKD_swigregister = _IMP_algebra.SphereKD_swigregister
5473 SphereKD_swigregister(SphereKD)
5474 
5475 class UnitSimplex1D(_UnitSimplexBase1D):
5476  """Proxy of C++ IMP::algebra::UnitSimplexD<(1)> class"""
5477  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5478 
5479  def __init__(self):
5480  """__init__(IMP::algebra::UnitSimplexD<(1)> self) -> UnitSimplex1D"""
5481  this = _IMP_algebra.new_UnitSimplex1D()
5482  try:
5483  self.this.append(this)
5484  except:
5485  self.this = this
5486 
5487  def show(self, *args):
5488  """
5489  show(UnitSimplex1D self, _ostream out)
5490  show(UnitSimplex1D self)
5491  """
5492  return _IMP_algebra.UnitSimplex1D_show(self, *args)
5493 
5494 
5495  def __str__(self):
5496  """__str__(UnitSimplex1D self) -> std::string"""
5497  return _IMP_algebra.UnitSimplex1D___str__(self)
5498 
5499 
5500  def __repr__(self):
5501  """__repr__(UnitSimplex1D self) -> std::string"""
5502  return _IMP_algebra.UnitSimplex1D___repr__(self)
5503 
5504 
5505  def __cmp__(self, arg2):
5506  """__cmp__(UnitSimplex1D self, UnitSimplex1D arg2) -> int"""
5507  return _IMP_algebra.UnitSimplex1D___cmp__(self, arg2)
5508 
5509 
5510  def __eq__(self, arg2):
5511  """__eq__(UnitSimplex1D self, UnitSimplex1D arg2) -> bool"""
5512  return _IMP_algebra.UnitSimplex1D___eq__(self, arg2)
5513 
5514 
5515  def _get_as_binary(self):
5516  """_get_as_binary(UnitSimplex1D self) -> PyObject *"""
5517  return _IMP_algebra.UnitSimplex1D__get_as_binary(self)
5518 
5519 
5520  def _set_from_binary(self, p):
5521  """_set_from_binary(UnitSimplex1D self, PyObject * p)"""
5522  return _IMP_algebra.UnitSimplex1D__set_from_binary(self, p)
5523 
5524 
5525  def __getstate__(self):
5526  p = self._get_as_binary()
5527  if len(self.__dict__) > 1:
5528  d = self.__dict__.copy()
5529  del d['this']
5530  p = (d, p)
5531  return p
5532 
5533  def __setstate__(self, p):
5534  if not hasattr(self, 'this'):
5535  self.__init__()
5536  if isinstance(p, tuple):
5537  d, p = p
5538  self.__dict__.update(d)
5539  return self._set_from_binary(p)
5540 
5541  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex1D
5542  __del__ = lambda self: None
5543 UnitSimplex1D_swigregister = _IMP_algebra.UnitSimplex1D_swigregister
5544 UnitSimplex1D_swigregister(UnitSimplex1D)
5545 
5546 class UnitSimplex2D(_UnitSimplexBase2D):
5547  """Proxy of C++ IMP::algebra::UnitSimplexD<(2)> class"""
5548  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5549 
5550  def __init__(self):
5551  """__init__(IMP::algebra::UnitSimplexD<(2)> self) -> UnitSimplex2D"""
5552  this = _IMP_algebra.new_UnitSimplex2D()
5553  try:
5554  self.this.append(this)
5555  except:
5556  self.this = this
5557 
5558  def show(self, *args):
5559  """
5560  show(UnitSimplex2D self, _ostream out)
5561  show(UnitSimplex2D self)
5562  """
5563  return _IMP_algebra.UnitSimplex2D_show(self, *args)
5564 
5565 
5566  def __str__(self):
5567  """__str__(UnitSimplex2D self) -> std::string"""
5568  return _IMP_algebra.UnitSimplex2D___str__(self)
5569 
5570 
5571  def __repr__(self):
5572  """__repr__(UnitSimplex2D self) -> std::string"""
5573  return _IMP_algebra.UnitSimplex2D___repr__(self)
5574 
5575 
5576  def __cmp__(self, arg2):
5577  """__cmp__(UnitSimplex2D self, UnitSimplex2D arg2) -> int"""
5578  return _IMP_algebra.UnitSimplex2D___cmp__(self, arg2)
5579 
5580 
5581  def __eq__(self, arg2):
5582  """__eq__(UnitSimplex2D self, UnitSimplex2D arg2) -> bool"""
5583  return _IMP_algebra.UnitSimplex2D___eq__(self, arg2)
5584 
5585 
5586  def _get_as_binary(self):
5587  """_get_as_binary(UnitSimplex2D self) -> PyObject *"""
5588  return _IMP_algebra.UnitSimplex2D__get_as_binary(self)
5589 
5590 
5591  def _set_from_binary(self, p):
5592  """_set_from_binary(UnitSimplex2D self, PyObject * p)"""
5593  return _IMP_algebra.UnitSimplex2D__set_from_binary(self, p)
5594 
5595 
5596  def __getstate__(self):
5597  p = self._get_as_binary()
5598  if len(self.__dict__) > 1:
5599  d = self.__dict__.copy()
5600  del d['this']
5601  p = (d, p)
5602  return p
5603 
5604  def __setstate__(self, p):
5605  if not hasattr(self, 'this'):
5606  self.__init__()
5607  if isinstance(p, tuple):
5608  d, p = p
5609  self.__dict__.update(d)
5610  return self._set_from_binary(p)
5611 
5612  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex2D
5613  __del__ = lambda self: None
5614 UnitSimplex2D_swigregister = _IMP_algebra.UnitSimplex2D_swigregister
5615 UnitSimplex2D_swigregister(UnitSimplex2D)
5616 
5617 class UnitSimplex3D(_UnitSimplexBase3D):
5618  """Proxy of C++ IMP::algebra::UnitSimplexD<(3)> class"""
5619  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5620 
5621  def __init__(self):
5622  """__init__(IMP::algebra::UnitSimplexD<(3)> self) -> UnitSimplex3D"""
5623  this = _IMP_algebra.new_UnitSimplex3D()
5624  try:
5625  self.this.append(this)
5626  except:
5627  self.this = this
5628 
5629  def show(self, *args):
5630  """
5631  show(UnitSimplex3D self, _ostream out)
5632  show(UnitSimplex3D self)
5633  """
5634  return _IMP_algebra.UnitSimplex3D_show(self, *args)
5635 
5636 
5637  def __str__(self):
5638  """__str__(UnitSimplex3D self) -> std::string"""
5639  return _IMP_algebra.UnitSimplex3D___str__(self)
5640 
5641 
5642  def __repr__(self):
5643  """__repr__(UnitSimplex3D self) -> std::string"""
5644  return _IMP_algebra.UnitSimplex3D___repr__(self)
5645 
5646 
5647  def __cmp__(self, arg2):
5648  """__cmp__(UnitSimplex3D self, UnitSimplex3D arg2) -> int"""
5649  return _IMP_algebra.UnitSimplex3D___cmp__(self, arg2)
5650 
5651 
5652  def __eq__(self, arg2):
5653  """__eq__(UnitSimplex3D self, UnitSimplex3D arg2) -> bool"""
5654  return _IMP_algebra.UnitSimplex3D___eq__(self, arg2)
5655 
5656 
5657  def _get_as_binary(self):
5658  """_get_as_binary(UnitSimplex3D self) -> PyObject *"""
5659  return _IMP_algebra.UnitSimplex3D__get_as_binary(self)
5660 
5661 
5662  def _set_from_binary(self, p):
5663  """_set_from_binary(UnitSimplex3D self, PyObject * p)"""
5664  return _IMP_algebra.UnitSimplex3D__set_from_binary(self, p)
5665 
5666 
5667  def __getstate__(self):
5668  p = self._get_as_binary()
5669  if len(self.__dict__) > 1:
5670  d = self.__dict__.copy()
5671  del d['this']
5672  p = (d, p)
5673  return p
5674 
5675  def __setstate__(self, p):
5676  if not hasattr(self, 'this'):
5677  self.__init__()
5678  if isinstance(p, tuple):
5679  d, p = p
5680  self.__dict__.update(d)
5681  return self._set_from_binary(p)
5682 
5683  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex3D
5684  __del__ = lambda self: None
5685 UnitSimplex3D_swigregister = _IMP_algebra.UnitSimplex3D_swigregister
5686 UnitSimplex3D_swigregister(UnitSimplex3D)
5687 
5688 class UnitSimplex4D(_UnitSimplexBase4D):
5689  """Proxy of C++ IMP::algebra::UnitSimplexD<(4)> class"""
5690  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5691 
5692  def __init__(self):
5693  """__init__(IMP::algebra::UnitSimplexD<(4)> self) -> UnitSimplex4D"""
5694  this = _IMP_algebra.new_UnitSimplex4D()
5695  try:
5696  self.this.append(this)
5697  except:
5698  self.this = this
5699 
5700  def show(self, *args):
5701  """
5702  show(UnitSimplex4D self, _ostream out)
5703  show(UnitSimplex4D self)
5704  """
5705  return _IMP_algebra.UnitSimplex4D_show(self, *args)
5706 
5707 
5708  def __str__(self):
5709  """__str__(UnitSimplex4D self) -> std::string"""
5710  return _IMP_algebra.UnitSimplex4D___str__(self)
5711 
5712 
5713  def __repr__(self):
5714  """__repr__(UnitSimplex4D self) -> std::string"""
5715  return _IMP_algebra.UnitSimplex4D___repr__(self)
5716 
5717 
5718  def __cmp__(self, arg2):
5719  """__cmp__(UnitSimplex4D self, UnitSimplex4D arg2) -> int"""
5720  return _IMP_algebra.UnitSimplex4D___cmp__(self, arg2)
5721 
5722 
5723  def __eq__(self, arg2):
5724  """__eq__(UnitSimplex4D self, UnitSimplex4D arg2) -> bool"""
5725  return _IMP_algebra.UnitSimplex4D___eq__(self, arg2)
5726 
5727 
5728  def _get_as_binary(self):
5729  """_get_as_binary(UnitSimplex4D self) -> PyObject *"""
5730  return _IMP_algebra.UnitSimplex4D__get_as_binary(self)
5731 
5732 
5733  def _set_from_binary(self, p):
5734  """_set_from_binary(UnitSimplex4D self, PyObject * p)"""
5735  return _IMP_algebra.UnitSimplex4D__set_from_binary(self, p)
5736 
5737 
5738  def __getstate__(self):
5739  p = self._get_as_binary()
5740  if len(self.__dict__) > 1:
5741  d = self.__dict__.copy()
5742  del d['this']
5743  p = (d, p)
5744  return p
5745 
5746  def __setstate__(self, p):
5747  if not hasattr(self, 'this'):
5748  self.__init__()
5749  if isinstance(p, tuple):
5750  d, p = p
5751  self.__dict__.update(d)
5752  return self._set_from_binary(p)
5753 
5754  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex4D
5755  __del__ = lambda self: None
5756 UnitSimplex4D_swigregister = _IMP_algebra.UnitSimplex4D_swigregister
5757 UnitSimplex4D_swigregister(UnitSimplex4D)
5758 
5759 class UnitSimplex5D(_UnitSimplexBase5D):
5760  """Proxy of C++ IMP::algebra::UnitSimplexD<(5)> class"""
5761  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5762 
5763  def __init__(self):
5764  """__init__(IMP::algebra::UnitSimplexD<(5)> self) -> UnitSimplex5D"""
5765  this = _IMP_algebra.new_UnitSimplex5D()
5766  try:
5767  self.this.append(this)
5768  except:
5769  self.this = this
5770 
5771  def show(self, *args):
5772  """
5773  show(UnitSimplex5D self, _ostream out)
5774  show(UnitSimplex5D self)
5775  """
5776  return _IMP_algebra.UnitSimplex5D_show(self, *args)
5777 
5778 
5779  def __str__(self):
5780  """__str__(UnitSimplex5D self) -> std::string"""
5781  return _IMP_algebra.UnitSimplex5D___str__(self)
5782 
5783 
5784  def __repr__(self):
5785  """__repr__(UnitSimplex5D self) -> std::string"""
5786  return _IMP_algebra.UnitSimplex5D___repr__(self)
5787 
5788 
5789  def __cmp__(self, arg2):
5790  """__cmp__(UnitSimplex5D self, UnitSimplex5D arg2) -> int"""
5791  return _IMP_algebra.UnitSimplex5D___cmp__(self, arg2)
5792 
5793 
5794  def __eq__(self, arg2):
5795  """__eq__(UnitSimplex5D self, UnitSimplex5D arg2) -> bool"""
5796  return _IMP_algebra.UnitSimplex5D___eq__(self, arg2)
5797 
5798 
5799  def _get_as_binary(self):
5800  """_get_as_binary(UnitSimplex5D self) -> PyObject *"""
5801  return _IMP_algebra.UnitSimplex5D__get_as_binary(self)
5802 
5803 
5804  def _set_from_binary(self, p):
5805  """_set_from_binary(UnitSimplex5D self, PyObject * p)"""
5806  return _IMP_algebra.UnitSimplex5D__set_from_binary(self, p)
5807 
5808 
5809  def __getstate__(self):
5810  p = self._get_as_binary()
5811  if len(self.__dict__) > 1:
5812  d = self.__dict__.copy()
5813  del d['this']
5814  p = (d, p)
5815  return p
5816 
5817  def __setstate__(self, p):
5818  if not hasattr(self, 'this'):
5819  self.__init__()
5820  if isinstance(p, tuple):
5821  d, p = p
5822  self.__dict__.update(d)
5823  return self._set_from_binary(p)
5824 
5825  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex5D
5826  __del__ = lambda self: None
5827 UnitSimplex5D_swigregister = _IMP_algebra.UnitSimplex5D_swigregister
5828 UnitSimplex5D_swigregister(UnitSimplex5D)
5829 
5830 class UnitSimplex6D(_UnitSimplexBase6D):
5831  """Proxy of C++ IMP::algebra::UnitSimplexD<(6)> class"""
5832  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5833 
5834  def __init__(self):
5835  """__init__(IMP::algebra::UnitSimplexD<(6)> self) -> UnitSimplex6D"""
5836  this = _IMP_algebra.new_UnitSimplex6D()
5837  try:
5838  self.this.append(this)
5839  except:
5840  self.this = this
5841 
5842  def show(self, *args):
5843  """
5844  show(UnitSimplex6D self, _ostream out)
5845  show(UnitSimplex6D self)
5846  """
5847  return _IMP_algebra.UnitSimplex6D_show(self, *args)
5848 
5849 
5850  def __str__(self):
5851  """__str__(UnitSimplex6D self) -> std::string"""
5852  return _IMP_algebra.UnitSimplex6D___str__(self)
5853 
5854 
5855  def __repr__(self):
5856  """__repr__(UnitSimplex6D self) -> std::string"""
5857  return _IMP_algebra.UnitSimplex6D___repr__(self)
5858 
5859 
5860  def __cmp__(self, arg2):
5861  """__cmp__(UnitSimplex6D self, UnitSimplex6D arg2) -> int"""
5862  return _IMP_algebra.UnitSimplex6D___cmp__(self, arg2)
5863 
5864 
5865  def __eq__(self, arg2):
5866  """__eq__(UnitSimplex6D self, UnitSimplex6D arg2) -> bool"""
5867  return _IMP_algebra.UnitSimplex6D___eq__(self, arg2)
5868 
5869 
5870  def _get_as_binary(self):
5871  """_get_as_binary(UnitSimplex6D self) -> PyObject *"""
5872  return _IMP_algebra.UnitSimplex6D__get_as_binary(self)
5873 
5874 
5875  def _set_from_binary(self, p):
5876  """_set_from_binary(UnitSimplex6D self, PyObject * p)"""
5877  return _IMP_algebra.UnitSimplex6D__set_from_binary(self, p)
5878 
5879 
5880  def __getstate__(self):
5881  p = self._get_as_binary()
5882  if len(self.__dict__) > 1:
5883  d = self.__dict__.copy()
5884  del d['this']
5885  p = (d, p)
5886  return p
5887 
5888  def __setstate__(self, p):
5889  if not hasattr(self, 'this'):
5890  self.__init__()
5891  if isinstance(p, tuple):
5892  d, p = p
5893  self.__dict__.update(d)
5894  return self._set_from_binary(p)
5895 
5896  __swig_destroy__ = _IMP_algebra.delete_UnitSimplex6D
5897  __del__ = lambda self: None
5898 UnitSimplex6D_swigregister = _IMP_algebra.UnitSimplex6D_swigregister
5899 UnitSimplex6D_swigregister(UnitSimplex6D)
5900 
5901 class UnitSimplexKD(_UnitSimplexBaseKD):
5902  """Proxy of C++ IMP::algebra::UnitSimplexD<(-1)> class"""
5903  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5904  __repr__ = _swig_repr
5905 
5906  def __init__(self, d=1):
5907  """
5908  __init__(IMP::algebra::UnitSimplexD<(-1)> self, int d=1) -> UnitSimplexKD
5909  __init__(IMP::algebra::UnitSimplexD<(-1)> self) -> UnitSimplexKD
5910  """
5911  this = _IMP_algebra.new_UnitSimplexKD(d)
5912  try:
5913  self.this.append(this)
5914  except:
5915  self.this = this
5916 
5917  def show(self, *args):
5918  """
5919  show(UnitSimplexKD self, _ostream out)
5920  show(UnitSimplexKD self)
5921  """
5922  return _IMP_algebra.UnitSimplexKD_show(self, *args)
5923 
5924 
5925  def _get_as_binary(self):
5926  """_get_as_binary(UnitSimplexKD self) -> PyObject *"""
5927  return _IMP_algebra.UnitSimplexKD__get_as_binary(self)
5928 
5929 
5930  def _set_from_binary(self, p):
5931  """_set_from_binary(UnitSimplexKD self, PyObject * p)"""
5932  return _IMP_algebra.UnitSimplexKD__set_from_binary(self, p)
5933 
5934 
5935  def __getstate__(self):
5936  p = self._get_as_binary()
5937  if len(self.__dict__) > 1:
5938  d = self.__dict__.copy()
5939  del d['this']
5940  p = (d, p)
5941  return p
5942 
5943  def __setstate__(self, p):
5944  if not hasattr(self, 'this'):
5945  self.__init__()
5946  if isinstance(p, tuple):
5947  d, p = p
5948  self.__dict__.update(d)
5949  return self._set_from_binary(p)
5950 
5951  __swig_destroy__ = _IMP_algebra.delete_UnitSimplexKD
5952  __del__ = lambda self: None
5953 UnitSimplexKD_swigregister = _IMP_algebra.UnitSimplexKD_swigregister
5954 UnitSimplexKD_swigregister(UnitSimplexKD)
5955 
5956 class ReferenceFrame3D(object):
5957  """Proxy of C++ IMP::algebra::ReferenceFrame3D class"""
5958  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5959 
5960  def __init__(self, *args):
5961  """
5962  __init__(IMP::algebra::ReferenceFrame3D self) -> ReferenceFrame3D
5963  __init__(IMP::algebra::ReferenceFrame3D self, Transformation3D tr) -> ReferenceFrame3D
5964  """
5965  this = _IMP_algebra.new_ReferenceFrame3D(*args)
5966  try:
5967  self.this.append(this)
5968  except:
5969  self.this = this
5970  __swig_destroy__ = _IMP_algebra.delete_ReferenceFrame3D
5971  __del__ = lambda self: None
5972 
5973  def get_transformation_to(self):
5974  """get_transformation_to(ReferenceFrame3D self) -> Transformation3D"""
5975  return _IMP_algebra.ReferenceFrame3D_get_transformation_to(self)
5976 
5977 
5978  def get_transformation_from(self):
5979  """get_transformation_from(ReferenceFrame3D self) -> Transformation3D"""
5980  return _IMP_algebra.ReferenceFrame3D_get_transformation_from(self)
5981 
5982 
5983  def get_global_coordinates(self, v):
5984  """get_global_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5985  return _IMP_algebra.ReferenceFrame3D_get_global_coordinates(self, v)
5986 
5987 
5988  def get_local_coordinates(self, v):
5989  """get_local_coordinates(ReferenceFrame3D self, Vector3D v) -> Vector3D"""
5990  return _IMP_algebra.ReferenceFrame3D_get_local_coordinates(self, v)
5991 
5992 
5993  def get_global_reference_frame(self, v):
5994  """get_global_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
5995  return _IMP_algebra.ReferenceFrame3D_get_global_reference_frame(self, v)
5996 
5997 
5998  def get_local_reference_frame(self, v):
5999  """get_local_reference_frame(ReferenceFrame3D self, ReferenceFrame3D v) -> ReferenceFrame3D"""
6000  return _IMP_algebra.ReferenceFrame3D_get_local_reference_frame(self, v)
6001 
6002 
6003  def show(self, *args):
6004  """
6005  show(ReferenceFrame3D self, _ostream out)
6006  show(ReferenceFrame3D self)
6007  """
6008  return _IMP_algebra.ReferenceFrame3D_show(self, *args)
6009 
6010 
6011  def __str__(self):
6012  """__str__(ReferenceFrame3D self) -> std::string"""
6013  return _IMP_algebra.ReferenceFrame3D___str__(self)
6014 
6015 
6016  def __repr__(self):
6017  """__repr__(ReferenceFrame3D self) -> std::string"""
6018  return _IMP_algebra.ReferenceFrame3D___repr__(self)
6019 
6020 
6021  def _get_as_binary(self):
6022  """_get_as_binary(ReferenceFrame3D self) -> PyObject *"""
6023  return _IMP_algebra.ReferenceFrame3D__get_as_binary(self)
6024 
6025 
6026  def _set_from_binary(self, p):
6027  """_set_from_binary(ReferenceFrame3D self, PyObject * p)"""
6028  return _IMP_algebra.ReferenceFrame3D__set_from_binary(self, p)
6029 
6030 
6031  def __getstate__(self):
6032  p = self._get_as_binary()
6033  if len(self.__dict__) > 1:
6034  d = self.__dict__.copy()
6035  del d['this']
6036  p = (d, p)
6037  return p
6038 
6039  def __setstate__(self, p):
6040  if not hasattr(self, 'this'):
6041  self.__init__()
6042  if isinstance(p, tuple):
6043  d, p = p
6044  self.__dict__.update(d)
6045  return self._set_from_binary(p)
6046 
6047 ReferenceFrame3D_swigregister = _IMP_algebra.ReferenceFrame3D_swigregister
6048 ReferenceFrame3D_swigregister(ReferenceFrame3D)
6049 
6050 
6051 def get_transformed(*args):
6052  """
6053  get_transformed(BoundingBox3D bb, Transformation3D tr) -> BoundingBox3D
6054  get_transformed(Line3D l, Transformation3D tr) -> Line3D
6055  get_transformed(ReferenceFrame3D rf, Transformation3D tr) -> ReferenceFrame3D
6056  """
6057  return _IMP_algebra.get_transformed(*args)
6058 
6059 def get_transformation_from_first_to_second(a, b):
6060  """get_transformation_from_first_to_second(ReferenceFrame3D a, ReferenceFrame3D b) -> Transformation3D"""
6061  return _IMP_algebra.get_transformation_from_first_to_second(a, b)
6062 class SphericalVector3D(_GeometricPrimitive3D):
6063  """Proxy of C++ IMP::algebra::SphericalVector3D class"""
6064  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6065 
6066  def __init__(self, *args):
6067  """
6068  __init__(IMP::algebra::SphericalVector3D self) -> SphericalVector3D
6069  __init__(IMP::algebra::SphericalVector3D self, Vector3D v) -> SphericalVector3D
6070  __init__(IMP::algebra::SphericalVector3D self, double r, double theta, double psi, bool apply_check=True) -> SphericalVector3D
6071  __init__(IMP::algebra::SphericalVector3D self, double r, double theta, double psi) -> SphericalVector3D
6072  """
6073  this = _IMP_algebra.new_SphericalVector3D(*args)
6074  try:
6075  self.this.append(this)
6076  except:
6077  self.this = this
6078 
6079  def get_cartesian_coordinates(self):
6080  """get_cartesian_coordinates(SphericalVector3D self) -> Vector3D"""
6081  return _IMP_algebra.SphericalVector3D_get_cartesian_coordinates(self)
6082 
6083 
6084  def show(self, *args):
6085  """
6086  show(SphericalVector3D self, _ostream out)
6087  show(SphericalVector3D self)
6088  """
6089  return _IMP_algebra.SphericalVector3D_show(self, *args)
6090 
6091 
6092  def __str__(self):
6093  """__str__(SphericalVector3D self) -> std::string"""
6094  return _IMP_algebra.SphericalVector3D___str__(self)
6095 
6096 
6097  def __repr__(self):
6098  """__repr__(SphericalVector3D self) -> std::string"""
6099  return _IMP_algebra.SphericalVector3D___repr__(self)
6100 
6101 
6102  def _get_as_binary(self):
6103  """_get_as_binary(SphericalVector3D self) -> PyObject *"""
6104  return _IMP_algebra.SphericalVector3D__get_as_binary(self)
6105 
6106 
6107  def _set_from_binary(self, p):
6108  """_set_from_binary(SphericalVector3D self, PyObject * p)"""
6109  return _IMP_algebra.SphericalVector3D__set_from_binary(self, p)
6110 
6111 
6112  def __getstate__(self):
6113  p = self._get_as_binary()
6114  if len(self.__dict__) > 1:
6115  d = self.__dict__.copy()
6116  del d['this']
6117  p = (d, p)
6118  return p
6119 
6120  def __setstate__(self, p):
6121  if not hasattr(self, 'this'):
6122  self.__init__()
6123  if isinstance(p, tuple):
6124  d, p = p
6125  self.__dict__.update(d)
6126  return self._set_from_binary(p)
6127 
6128 
6129  def __getitem__(self, index):
6130  """__getitem__(SphericalVector3D self, unsigned int index) -> double"""
6131  return _IMP_algebra.SphericalVector3D___getitem__(self, index)
6132 
6133 
6134  def __setitem__(self, index, val):
6135  """__setitem__(SphericalVector3D self, unsigned int index, double val)"""
6136  return _IMP_algebra.SphericalVector3D___setitem__(self, index, val)
6137 
6138  __swig_destroy__ = _IMP_algebra.delete_SphericalVector3D
6139  __del__ = lambda self: None
6140 SphericalVector3D_swigregister = _IMP_algebra.SphericalVector3D_swigregister
6141 SphericalVector3D_swigregister(SphericalVector3D)
6142 
6143 
6144 def get_alignments_from_first_to_second(pca1, pca2):
6145  """get_alignments_from_first_to_second(PrincipalComponentAnalysis3D pca1, PrincipalComponentAnalysis3D pca2) -> IMP::algebra::Transformation3Ds"""
6146  return _IMP_algebra.get_alignments_from_first_to_second(pca1, pca2)
6147 class Line3D(_GeometricPrimitive3D):
6148  """Proxy of C++ IMP::algebra::Line3D class"""
6149  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6150 
6151  def __init__(self, *args):
6152  """
6153  __init__(IMP::algebra::Line3D self) -> Line3D
6154  __init__(IMP::algebra::Line3D self, Vector3D direction, Vector3D point_on_line) -> Line3D
6155  __init__(IMP::algebra::Line3D self, Segment3D s) -> Line3D
6156  """
6157  this = _IMP_algebra.new_Line3D(*args)
6158  try:
6159  self.this.append(this)
6160  except:
6161  self.this = this
6162 
6163  def get_direction(self):
6164  """get_direction(Line3D self) -> Vector3D"""
6165  return _IMP_algebra.Line3D_get_direction(self)
6166 
6167 
6168  def get_point_on_line(self):
6169  """get_point_on_line(Line3D self) -> Vector3D"""
6170  return _IMP_algebra.Line3D_get_point_on_line(self)
6171 
6172 
6173  def get_moment(self, *args):
6174  """
6175  get_moment(Line3D self) -> Vector3D
6176  get_moment(Line3D self, Vector3D v) -> Vector3D
6177  """
6178  return _IMP_algebra.Line3D_get_moment(self, *args)
6179 
6180 
6181  def get_reciprocal_product(self, l):
6182  """get_reciprocal_product(Line3D self, Line3D l) -> double"""
6183  return _IMP_algebra.Line3D_get_reciprocal_product(self, l)
6184 
6185 
6186  def get_opposite(self):
6187  """get_opposite(Line3D self) -> Line3D"""
6188  return _IMP_algebra.Line3D_get_opposite(self)
6189 
6190 
6191  def get_segment_starting_at(self, v, d):
6192  """get_segment_starting_at(Line3D self, Vector3D v, double d) -> Segment3D"""
6193  return _IMP_algebra.Line3D_get_segment_starting_at(self, v, d)
6194 
6195 
6196  def show(self, *args):
6197  """
6198  show(Line3D self, _ostream out)
6199  show(Line3D self)
6200  """
6201  return _IMP_algebra.Line3D_show(self, *args)
6202 
6203 
6204  def __str__(self):
6205  """__str__(Line3D self) -> std::string"""
6206  return _IMP_algebra.Line3D___str__(self)
6207 
6208 
6209  def __repr__(self):
6210  """__repr__(Line3D self) -> std::string"""
6211  return _IMP_algebra.Line3D___repr__(self)
6212 
6213 
6214  def _get_as_binary(self):
6215  """_get_as_binary(Line3D self) -> PyObject *"""
6216  return _IMP_algebra.Line3D__get_as_binary(self)
6217 
6218 
6219  def _set_from_binary(self, p):
6220  """_set_from_binary(Line3D self, PyObject * p)"""
6221  return _IMP_algebra.Line3D__set_from_binary(self, p)
6222 
6223 
6224  def __getstate__(self):
6225  p = self._get_as_binary()
6226  if len(self.__dict__) > 1:
6227  d = self.__dict__.copy()
6228  del d['this']
6229  p = (d, p)
6230  return p
6231 
6232  def __setstate__(self, p):
6233  if not hasattr(self, 'this'):
6234  self.__init__()
6235  if isinstance(p, tuple):
6236  d, p = p
6237  self.__dict__.update(d)
6238  return self._set_from_binary(p)
6239 
6240  __swig_destroy__ = _IMP_algebra.delete_Line3D
6241  __del__ = lambda self: None
6242 Line3D_swigregister = _IMP_algebra.Line3D_swigregister
6243 Line3D_swigregister(Line3D)
6244 
6245 
6246 def get_line_3d_geometry(g):
6247  """get_line_3d_geometry(Line3D g) -> Line3D"""
6248  return _IMP_algebra.get_line_3d_geometry(g)
6249 
6250 def get_angle(a, b):
6251  """get_angle(Line3D a, Line3D b) -> double"""
6252  return _IMP_algebra.get_angle(a, b)
6253 
6254 def get_segment_connecting_first_to_second(a, b):
6255  """get_segment_connecting_first_to_second(Line3D a, Line3D b) -> Segment3D"""
6256  return _IMP_algebra.get_segment_connecting_first_to_second(a, b)
6257 class Segment3D(_GeometricPrimitive3D):
6258  """Proxy of C++ IMP::algebra::Segment3D class"""
6259  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6260 
6261  def __init__(self, *args):
6262  """
6263  __init__(IMP::algebra::Segment3D self) -> Segment3D
6264  __init__(IMP::algebra::Segment3D self, Vector3D start, Vector3D end) -> Segment3D
6265  """
6266  this = _IMP_algebra.new_Segment3D(*args)
6267  try:
6268  self.this.append(this)
6269  except:
6270  self.this = this
6271 
6272  def get_point(self, i):
6273  if i < 0 or i >= 2:
6274  raise IMP.UsageException("Invalid point index")
6275  return _IMP_algebra.Segment3D_get_point(self, i)
6276 
6277 
6278 
6279  def get_middle_point(self):
6280  """get_middle_point(Segment3D self) -> Vector3D"""
6281  return _IMP_algebra.Segment3D_get_middle_point(self)
6282 
6283 
6284  def get_direction(self):
6285  """get_direction(Segment3D self) -> Vector3D"""
6286  return _IMP_algebra.Segment3D_get_direction(self)
6287 
6288 
6289  def get_length(self):
6290  """get_length(Segment3D self) -> double"""
6291  return _IMP_algebra.Segment3D_get_length(self)
6292 
6293 
6294  def show(self, *args):
6295  """
6296  show(Segment3D self, _ostream out)
6297  show(Segment3D self)
6298  """
6299  return _IMP_algebra.Segment3D_show(self, *args)
6300 
6301 
6302  def __str__(self):
6303  """__str__(Segment3D self) -> std::string"""
6304  return _IMP_algebra.Segment3D___str__(self)
6305 
6306 
6307  def __repr__(self):
6308  """__repr__(Segment3D self) -> std::string"""
6309  return _IMP_algebra.Segment3D___repr__(self)
6310 
6311 
6312  def _get_as_binary(self):
6313  """_get_as_binary(Segment3D self) -> PyObject *"""
6314  return _IMP_algebra.Segment3D__get_as_binary(self)
6315 
6316 
6317  def _set_from_binary(self, p):
6318  """_set_from_binary(Segment3D self, PyObject * p)"""
6319  return _IMP_algebra.Segment3D__set_from_binary(self, p)
6320 
6321 
6322  def __getstate__(self):
6323  p = self._get_as_binary()
6324  if len(self.__dict__) > 1:
6325  d = self.__dict__.copy()
6326  del d['this']
6327  p = (d, p)
6328  return p
6329 
6330  def __setstate__(self, p):
6331  if not hasattr(self, 'this'):
6332  self.__init__()
6333  if isinstance(p, tuple):
6334  d, p = p
6335  self.__dict__.update(d)
6336  return self._set_from_binary(p)
6337 
6338  __swig_destroy__ = _IMP_algebra.delete_Segment3D
6339  __del__ = lambda self: None
6340 Segment3D_swigregister = _IMP_algebra.Segment3D_swigregister
6341 Segment3D_swigregister(Segment3D)
6342 
6343 
6344 def get_segment_3d_geometry(g):
6345  """get_segment_3d_geometry(Segment3D g) -> Segment3D"""
6346  return _IMP_algebra.get_segment_3d_geometry(g)
6347 
6348 def get_relative_projection_on_segment(s, p):
6349  """get_relative_projection_on_segment(Segment3D s, Vector3D p) -> double"""
6350  return _IMP_algebra.get_relative_projection_on_segment(s, p)
6351 class Triangle3D(_GeometricPrimitive3D):
6352  """Proxy of C++ IMP::algebra::Triangle3D class"""
6353  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6354 
6355  def __init__(self, *args):
6356  """
6357  __init__(IMP::algebra::Triangle3D self) -> Triangle3D
6358  __init__(IMP::algebra::Triangle3D self, Vector3D p1, Vector3D p2, Vector3D p3) -> Triangle3D
6359  """
6360  this = _IMP_algebra.new_Triangle3D(*args)
6361  try:
6362  self.this.append(this)
6363  except:
6364  self.this = this
6365 
6366  def get_point(self, i):
6367  """get_point(Triangle3D self, unsigned int i) -> Vector3D"""
6368  return _IMP_algebra.Triangle3D_get_point(self, i)
6369 
6370 
6371  def show(self, *args):
6372  """
6373  show(Triangle3D self, _ostream out)
6374  show(Triangle3D self)
6375  """
6376  return _IMP_algebra.Triangle3D_show(self, *args)
6377 
6378 
6379  def get_edge_lengths(self):
6380  """get_edge_lengths(Triangle3D self) -> IMP::Floats"""
6381  return _IMP_algebra.Triangle3D_get_edge_lengths(self)
6382 
6383 
6384  def __str__(self):
6385  """__str__(Triangle3D self) -> std::string"""
6386  return _IMP_algebra.Triangle3D___str__(self)
6387 
6388 
6389  def __repr__(self):
6390  """__repr__(Triangle3D self) -> std::string"""
6391  return _IMP_algebra.Triangle3D___repr__(self)
6392 
6393 
6394  def _get_as_binary(self):
6395  """_get_as_binary(Triangle3D self) -> PyObject *"""
6396  return _IMP_algebra.Triangle3D__get_as_binary(self)
6397 
6398 
6399  def _set_from_binary(self, p):
6400  """_set_from_binary(Triangle3D self, PyObject * p)"""
6401  return _IMP_algebra.Triangle3D__set_from_binary(self, p)
6402 
6403 
6404  def __getstate__(self):
6405  p = self._get_as_binary()
6406  if len(self.__dict__) > 1:
6407  d = self.__dict__.copy()
6408  del d['this']
6409  p = (d, p)
6410  return p
6411 
6412  def __setstate__(self, p):
6413  if not hasattr(self, 'this'):
6414  self.__init__()
6415  if isinstance(p, tuple):
6416  d, p = p
6417  self.__dict__.update(d)
6418  return self._set_from_binary(p)
6419 
6420  __swig_destroy__ = _IMP_algebra.delete_Triangle3D
6421  __del__ = lambda self: None
6422 Triangle3D_swigregister = _IMP_algebra.Triangle3D_swigregister
6423 Triangle3D_swigregister(Triangle3D)
6424 
6425 
6426 def get_largest_triangle(points):
6427  """get_largest_triangle(IMP::algebra::Vector3Ds const & points) -> Triangle3D"""
6428  return _IMP_algebra.get_largest_triangle(points)
6429 
6430 def get_transformation_from_first_triangle_to_second(first_tri, second_tri):
6431  """get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri) -> Transformation3D"""
6432  return _IMP_algebra.get_transformation_from_first_triangle_to_second(first_tri, second_tri)
6433 
6434 def get_are_colinear(p1, p2, p3):
6435  """get_are_colinear(Vector3D p1, Vector3D p2, Vector3D p3) -> bool"""
6436  return _IMP_algebra.get_are_colinear(p1, p2, p3)
6437 class LinearFit2D(_GeometricPrimitive2D):
6438  """Proxy of C++ IMP::algebra::LinearFit2D class"""
6439  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6440 
6441  def __init__(self, *args):
6442  """
6443  __init__(IMP::algebra::LinearFit2D self) -> LinearFit2D
6444  __init__(IMP::algebra::LinearFit2D self, IMP::algebra::Vector2Ds const & data, IMP::Floats const & error_bars) -> LinearFit2D
6445  __init__(IMP::algebra::LinearFit2D self, IMP::algebra::Vector2Ds const & data) -> LinearFit2D
6446  """
6447  this = _IMP_algebra.new_LinearFit2D(*args)
6448  try:
6449  self.this.append(this)
6450  except:
6451  self.this = this
6452 
6453  def get_fit_error(self):
6454  """get_fit_error(LinearFit2D self) -> double"""
6455  return _IMP_algebra.LinearFit2D_get_fit_error(self)
6456 
6457 
6458  def get_a(self):
6459  """get_a(LinearFit2D self) -> double"""
6460  return _IMP_algebra.LinearFit2D_get_a(self)
6461 
6462 
6463  def get_b(self):
6464  """get_b(LinearFit2D self) -> double"""
6465  return _IMP_algebra.LinearFit2D_get_b(self)
6466 
6467 
6468  def show(self, *args):
6469  """
6470  show(LinearFit2D self, _ostream out)
6471  show(LinearFit2D self)
6472  """
6473  return _IMP_algebra.LinearFit2D_show(self, *args)
6474 
6475 
6476  def __str__(self):
6477  """__str__(LinearFit2D self) -> std::string"""
6478  return _IMP_algebra.LinearFit2D___str__(self)
6479 
6480 
6481  def __repr__(self):
6482  """__repr__(LinearFit2D self) -> std::string"""
6483  return _IMP_algebra.LinearFit2D___repr__(self)
6484 
6485 
6486  def _get_as_binary(self):
6487  """_get_as_binary(LinearFit2D self) -> PyObject *"""
6488  return _IMP_algebra.LinearFit2D__get_as_binary(self)
6489 
6490 
6491  def _set_from_binary(self, p):
6492  """_set_from_binary(LinearFit2D self, PyObject * p)"""
6493  return _IMP_algebra.LinearFit2D__set_from_binary(self, p)
6494 
6495 
6496  def __getstate__(self):
6497  p = self._get_as_binary()
6498  if len(self.__dict__) > 1:
6499  d = self.__dict__.copy()
6500  del d['this']
6501  p = (d, p)
6502  return p
6503 
6504  def __setstate__(self, p):
6505  if not hasattr(self, 'this'):
6506  self.__init__()
6507  if isinstance(p, tuple):
6508  d, p = p
6509  self.__dict__.update(d)
6510  return self._set_from_binary(p)
6511 
6512  __swig_destroy__ = _IMP_algebra.delete_LinearFit2D
6513  __del__ = lambda self: None
6514 LinearFit2D_swigregister = _IMP_algebra.LinearFit2D_swigregister
6515 LinearFit2D_swigregister(LinearFit2D)
6516 
6517 class ParabolicFit2D(_GeometricPrimitive2D):
6518  """Proxy of C++ IMP::algebra::ParabolicFit2D class"""
6519  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6520 
6521  def __init__(self, *args):
6522  """
6523  __init__(IMP::algebra::ParabolicFit2D self) -> ParabolicFit2D
6524  __init__(IMP::algebra::ParabolicFit2D self, IMP::algebra::Vector2Ds const & data) -> ParabolicFit2D
6525  """
6526  this = _IMP_algebra.new_ParabolicFit2D(*args)
6527  try:
6528  self.this.append(this)
6529  except:
6530  self.this = this
6531 
6532  def get_fit_error(self):
6533  """get_fit_error(ParabolicFit2D self) -> double"""
6534  return _IMP_algebra.ParabolicFit2D_get_fit_error(self)
6535 
6536 
6537  def get_a(self):
6538  """get_a(ParabolicFit2D self) -> double"""
6539  return _IMP_algebra.ParabolicFit2D_get_a(self)
6540 
6541 
6542  def get_b(self):
6543  """get_b(ParabolicFit2D self) -> double"""
6544  return _IMP_algebra.ParabolicFit2D_get_b(self)
6545 
6546 
6547  def get_c(self):
6548  """get_c(ParabolicFit2D self) -> double"""
6549  return _IMP_algebra.ParabolicFit2D_get_c(self)
6550 
6551 
6552  def show(self, *args):
6553  """
6554  show(ParabolicFit2D self, _ostream out)
6555  show(ParabolicFit2D self)
6556  """
6557  return _IMP_algebra.ParabolicFit2D_show(self, *args)
6558 
6559 
6560  def __str__(self):
6561  """__str__(ParabolicFit2D self) -> std::string"""
6562  return _IMP_algebra.ParabolicFit2D___str__(self)
6563 
6564 
6565  def __repr__(self):
6566  """__repr__(ParabolicFit2D self) -> std::string"""
6567  return _IMP_algebra.ParabolicFit2D___repr__(self)
6568 
6569 
6570  def _get_as_binary(self):
6571  """_get_as_binary(ParabolicFit2D self) -> PyObject *"""
6572  return _IMP_algebra.ParabolicFit2D__get_as_binary(self)
6573 
6574 
6575  def _set_from_binary(self, p):
6576  """_set_from_binary(ParabolicFit2D self, PyObject * p)"""
6577  return _IMP_algebra.ParabolicFit2D__set_from_binary(self, p)
6578 
6579 
6580  def __getstate__(self):
6581  p = self._get_as_binary()
6582  if len(self.__dict__) > 1:
6583  d = self.__dict__.copy()
6584  del d['this']
6585  p = (d, p)
6586  return p
6587 
6588  def __setstate__(self, p):
6589  if not hasattr(self, 'this'):
6590  self.__init__()
6591  if isinstance(p, tuple):
6592  d, p = p
6593  self.__dict__.update(d)
6594  return self._set_from_binary(p)
6595 
6596  __swig_destroy__ = _IMP_algebra.delete_ParabolicFit2D
6597  __del__ = lambda self: None
6598 ParabolicFit2D_swigregister = _IMP_algebra.ParabolicFit2D_swigregister
6599 ParabolicFit2D_swigregister(ParabolicFit2D)
6600 
6601 class Plane3D(_GeometricPrimitive3D):
6602  """Proxy of C++ IMP::algebra::Plane3D class"""
6603  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6604 
6605  def __init__(self, *args):
6606  """
6607  __init__(IMP::algebra::Plane3D self) -> Plane3D
6608  __init__(IMP::algebra::Plane3D self, Vector3D point_on_plane, Vector3D normal_to_plane) -> Plane3D
6609  __init__(IMP::algebra::Plane3D self, double distance_to_plane, Vector3D normal_to_plane) -> Plane3D
6610  """
6611  this = _IMP_algebra.new_Plane3D(*args)
6612  try:
6613  self.this.append(this)
6614  except:
6615  self.this = this
6616 
6617  def get_point_on_plane(self):
6618  """get_point_on_plane(Plane3D self) -> Vector3D"""
6619  return _IMP_algebra.Plane3D_get_point_on_plane(self)
6620 
6621 
6622  def get_normal(self):
6623  """get_normal(Plane3D self) -> Vector3D"""
6624  return _IMP_algebra.Plane3D_get_normal(self)
6625 
6626 
6627  def get_projected(self, p):
6628  """get_projected(Plane3D self, Vector3D p) -> Vector3D"""
6629  return _IMP_algebra.Plane3D_get_projected(self, p)
6630 
6631 
6632  def get_is_above(self, p):
6633  """get_is_above(Plane3D self, Vector3D p) -> bool"""
6634  return _IMP_algebra.Plane3D_get_is_above(self, p)
6635 
6636 
6637  def get_is_below(self, p):
6638  """get_is_below(Plane3D self, Vector3D p) -> bool"""
6639  return _IMP_algebra.Plane3D_get_is_below(self, p)
6640 
6641 
6642  def get_height(self, p):
6643  """get_height(Plane3D self, Vector3D p) -> double"""
6644  return _IMP_algebra.Plane3D_get_height(self, p)
6645 
6646 
6647  def show(self, *args):
6648  """
6649  show(Plane3D self, _ostream out)
6650  show(Plane3D self)
6651  """
6652  return _IMP_algebra.Plane3D_show(self, *args)
6653 
6654 
6655  def get_opposite(self):
6656  """get_opposite(Plane3D self) -> Plane3D"""
6657  return _IMP_algebra.Plane3D_get_opposite(self)
6658 
6659 
6660  def get_distance_from_origin(self):
6661  """get_distance_from_origin(Plane3D self) -> double"""
6662  return _IMP_algebra.Plane3D_get_distance_from_origin(self)
6663 
6664 
6665  def __str__(self):
6666  """__str__(Plane3D self) -> std::string"""
6667  return _IMP_algebra.Plane3D___str__(self)
6668 
6669 
6670  def __repr__(self):
6671  """__repr__(Plane3D self) -> std::string"""
6672  return _IMP_algebra.Plane3D___repr__(self)
6673 
6674 
6675  def _get_as_binary(self):
6676  """_get_as_binary(Plane3D self) -> PyObject *"""
6677  return _IMP_algebra.Plane3D__get_as_binary(self)
6678 
6679 
6680  def _set_from_binary(self, p):
6681  """_set_from_binary(Plane3D self, PyObject * p)"""
6682  return _IMP_algebra.Plane3D__set_from_binary(self, p)
6683 
6684 
6685  def __getstate__(self):
6686  p = self._get_as_binary()
6687  if len(self.__dict__) > 1:
6688  d = self.__dict__.copy()
6689  del d['this']
6690  p = (d, p)
6691  return p
6692 
6693  def __setstate__(self, p):
6694  if not hasattr(self, 'this'):
6695  self.__init__()
6696  if isinstance(p, tuple):
6697  d, p = p
6698  self.__dict__.update(d)
6699  return self._set_from_binary(p)
6700 
6701  __swig_destroy__ = _IMP_algebra.delete_Plane3D
6702  __del__ = lambda self: None
6703 Plane3D_swigregister = _IMP_algebra.Plane3D_swigregister
6704 Plane3D_swigregister(Plane3D)
6705 
6706 
6707 def get_reflected(pln, p):
6708  """get_reflected(Plane3D pln, Vector3D p) -> Vector3D"""
6709  return _IMP_algebra.get_reflected(pln, p)
6710 
6711 def get_plane_3d_geometry(g):
6712  """get_plane_3d_geometry(Plane3D g) -> Plane3D"""
6713  return _IMP_algebra.get_plane_3d_geometry(g)
6714 class Reflection3D(_GeometricPrimitive3D):
6715  """Proxy of C++ IMP::algebra::Reflection3D class"""
6716  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6717 
6718  def __init__(self, *args):
6719  """
6720  __init__(IMP::algebra::Reflection3D self) -> Reflection3D
6721  __init__(IMP::algebra::Reflection3D self, Plane3D pl) -> Reflection3D
6722  """
6723  this = _IMP_algebra.new_Reflection3D(*args)
6724  try:
6725  self.this.append(this)
6726  except:
6727  self.this = this
6728 
6729  def get_reflected(self, v):
6730  """get_reflected(Reflection3D self, Vector3D v) -> Vector3D"""
6731  return _IMP_algebra.Reflection3D_get_reflected(self, v)
6732 
6733 
6734  def show(self, *args):
6735  """
6736  show(Reflection3D self, _ostream out)
6737  show(Reflection3D self)
6738  """
6739  return _IMP_algebra.Reflection3D_show(self, *args)
6740 
6741 
6742  def __str__(self):
6743  """__str__(Reflection3D self) -> std::string"""
6744  return _IMP_algebra.Reflection3D___str__(self)
6745 
6746 
6747  def __repr__(self):
6748  """__repr__(Reflection3D self) -> std::string"""
6749  return _IMP_algebra.Reflection3D___repr__(self)
6750 
6751 
6752  def _get_as_binary(self):
6753  """_get_as_binary(Reflection3D self) -> PyObject *"""
6754  return _IMP_algebra.Reflection3D__get_as_binary(self)
6755 
6756 
6757  def _set_from_binary(self, p):
6758  """_set_from_binary(Reflection3D self, PyObject * p)"""
6759  return _IMP_algebra.Reflection3D__set_from_binary(self, p)
6760 
6761 
6762  def __getstate__(self):
6763  p = self._get_as_binary()
6764  if len(self.__dict__) > 1:
6765  d = self.__dict__.copy()
6766  del d['this']
6767  p = (d, p)
6768  return p
6769 
6770  def __setstate__(self, p):
6771  if not hasattr(self, 'this'):
6772  self.__init__()
6773  if isinstance(p, tuple):
6774  d, p = p
6775  self.__dict__.update(d)
6776  return self._set_from_binary(p)
6777 
6778  __swig_destroy__ = _IMP_algebra.delete_Reflection3D
6779  __del__ = lambda self: None
6780 Reflection3D_swigregister = _IMP_algebra.Reflection3D_swigregister
6781 Reflection3D_swigregister(Reflection3D)
6782 
6783 class Cylinder3D(_GeometricPrimitive3D):
6784  """Proxy of C++ IMP::algebra::Cylinder3D class"""
6785  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6786 
6787  def __init__(self, *args):
6788  """
6789  __init__(IMP::algebra::Cylinder3D self) -> Cylinder3D
6790  __init__(IMP::algebra::Cylinder3D self, Segment3D s, double radius) -> Cylinder3D
6791  """
6792  this = _IMP_algebra.new_Cylinder3D(*args)
6793  try:
6794  self.this.append(this)
6795  except:
6796  self.this = this
6797 
6798  def get_radius(self):
6799  """get_radius(Cylinder3D self) -> double"""
6800  return _IMP_algebra.Cylinder3D_get_radius(self)
6801 
6802 
6803  def get_segment(self):
6804  """get_segment(Cylinder3D self) -> Segment3D"""
6805  return _IMP_algebra.Cylinder3D_get_segment(self)
6806 
6807 
6808  def get_surface_point_at(self, relative_height, angle):
6809  """get_surface_point_at(Cylinder3D self, double relative_height, double angle) -> Vector3D"""
6810  return _IMP_algebra.Cylinder3D_get_surface_point_at(self, relative_height, angle)
6811 
6812 
6813  def get_inner_point_at(self, relative_height, relative_radius, angle):
6814  """get_inner_point_at(Cylinder3D self, double relative_height, double relative_radius, double angle) -> Vector3D"""
6815  return _IMP_algebra.Cylinder3D_get_inner_point_at(self, relative_height, relative_radius, angle)
6816 
6817 
6818  def show(self, *args):
6819  """
6820  show(Cylinder3D self, _ostream out)
6821  show(Cylinder3D self)
6822  """
6823  return _IMP_algebra.Cylinder3D_show(self, *args)
6824 
6825 
6826  def __str__(self):
6827  """__str__(Cylinder3D self) -> std::string"""
6828  return _IMP_algebra.Cylinder3D___str__(self)
6829 
6830 
6831  def __repr__(self):
6832  """__repr__(Cylinder3D self) -> std::string"""
6833  return _IMP_algebra.Cylinder3D___repr__(self)
6834 
6835 
6836  def _get_as_binary(self):
6837  """_get_as_binary(Cylinder3D self) -> PyObject *"""
6838  return _IMP_algebra.Cylinder3D__get_as_binary(self)
6839 
6840 
6841  def _set_from_binary(self, p):
6842  """_set_from_binary(Cylinder3D self, PyObject * p)"""
6843  return _IMP_algebra.Cylinder3D__set_from_binary(self, p)
6844 
6845 
6846  def __getstate__(self):
6847  p = self._get_as_binary()
6848  if len(self.__dict__) > 1:
6849  d = self.__dict__.copy()
6850  del d['this']
6851  p = (d, p)
6852  return p
6853 
6854  def __setstate__(self, p):
6855  if not hasattr(self, 'this'):
6856  self.__init__()
6857  if isinstance(p, tuple):
6858  d, p = p
6859  self.__dict__.update(d)
6860  return self._set_from_binary(p)
6861 
6862  __swig_destroy__ = _IMP_algebra.delete_Cylinder3D
6863  __del__ = lambda self: None
6864 Cylinder3D_swigregister = _IMP_algebra.Cylinder3D_swigregister
6865 Cylinder3D_swigregister(Cylinder3D)
6866 
6867 
6868 def get_cylinder_3d_geometry(g):
6869  """get_cylinder_3d_geometry(Cylinder3D g) -> Cylinder3D"""
6870  return _IMP_algebra.get_cylinder_3d_geometry(g)
6871 class Ellipsoid3D(_GeometricPrimitive3D):
6872  """Proxy of C++ IMP::algebra::Ellipsoid3D class"""
6873  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6874 
6875  def __init__(self, *args):
6876  """
6877  __init__(IMP::algebra::Ellipsoid3D self) -> Ellipsoid3D
6878  __init__(IMP::algebra::Ellipsoid3D self, ReferenceFrame3D rf, Vector3D radii) -> Ellipsoid3D
6879  __init__(IMP::algebra::Ellipsoid3D self, Vector3D center, double radius_x, double radius_y, double radius_z, Rotation3D rot) -> Ellipsoid3D
6880  """
6881  this = _IMP_algebra.new_Ellipsoid3D(*args)
6882  try:
6883  self.this.append(this)
6884  except:
6885  self.this = this
6886 
6887  def get_radii(self):
6888  """get_radii(Ellipsoid3D self) -> Vector3D"""
6889  return _IMP_algebra.Ellipsoid3D_get_radii(self)
6890 
6891 
6892  def get_reference_frame(self):
6893  """get_reference_frame(Ellipsoid3D self) -> ReferenceFrame3D"""
6894  return _IMP_algebra.Ellipsoid3D_get_reference_frame(self)
6895 
6896 
6897  def show(self, *args):
6898  """
6899  show(Ellipsoid3D self, _ostream out)
6900  show(Ellipsoid3D self)
6901  """
6902  return _IMP_algebra.Ellipsoid3D_show(self, *args)
6903 
6904 
6905  def __str__(self):
6906  """__str__(Ellipsoid3D self) -> std::string"""
6907  return _IMP_algebra.Ellipsoid3D___str__(self)
6908 
6909 
6910  def __repr__(self):
6911  """__repr__(Ellipsoid3D self) -> std::string"""
6912  return _IMP_algebra.Ellipsoid3D___repr__(self)
6913 
6914 
6915  def _get_as_binary(self):
6916  """_get_as_binary(Ellipsoid3D self) -> PyObject *"""
6917  return _IMP_algebra.Ellipsoid3D__get_as_binary(self)
6918 
6919 
6920  def _set_from_binary(self, p):
6921  """_set_from_binary(Ellipsoid3D self, PyObject * p)"""
6922  return _IMP_algebra.Ellipsoid3D__set_from_binary(self, p)
6923 
6924 
6925  def __getstate__(self):
6926  p = self._get_as_binary()
6927  if len(self.__dict__) > 1:
6928  d = self.__dict__.copy()
6929  del d['this']
6930  p = (d, p)
6931  return p
6932 
6933  def __setstate__(self, p):
6934  if not hasattr(self, 'this'):
6935  self.__init__()
6936  if isinstance(p, tuple):
6937  d, p = p
6938  self.__dict__.update(d)
6939  return self._set_from_binary(p)
6940 
6941  __swig_destroy__ = _IMP_algebra.delete_Ellipsoid3D
6942  __del__ = lambda self: None
6943 Ellipsoid3D_swigregister = _IMP_algebra.Ellipsoid3D_swigregister
6944 Ellipsoid3D_swigregister(Ellipsoid3D)
6945 
6946 
6947 def get_ellipsoid_3d_geometry(g):
6948  """get_ellipsoid_3d_geometry(Ellipsoid3D g) -> Ellipsoid3D"""
6949  return _IMP_algebra.get_ellipsoid_3d_geometry(g)
6950 class ConnollySurfacePoint(object):
6951  """Proxy of C++ IMP::algebra::ConnollySurfacePoint class"""
6952  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6953 
6954  def __init__(self, *args):
6955  """
6956  __init__(IMP::algebra::ConnollySurfacePoint self) -> ConnollySurfacePoint
6957  __init__(IMP::algebra::ConnollySurfacePoint self, int a0, int a1, int a2, Vector3D sp, float a, Vector3D n) -> ConnollySurfacePoint
6958  """
6959  this = _IMP_algebra.new_ConnollySurfacePoint(*args)
6960  try:
6961  self.this.append(this)
6962  except:
6963  self.this = this
6964 
6965  def get_atom(self, i):
6966  """get_atom(ConnollySurfacePoint self, unsigned int i) -> int"""
6967  return _IMP_algebra.ConnollySurfacePoint_get_atom(self, i)
6968 
6969 
6970  def get_surface_point(self):
6971  """get_surface_point(ConnollySurfacePoint self) -> Vector3D"""
6972  return _IMP_algebra.ConnollySurfacePoint_get_surface_point(self)
6973 
6974 
6975  def get_area(self):
6976  """get_area(ConnollySurfacePoint self) -> double"""
6977  return _IMP_algebra.ConnollySurfacePoint_get_area(self)
6978 
6979 
6980  def get_normal(self):
6981  """get_normal(ConnollySurfacePoint self) -> Vector3D"""
6982  return _IMP_algebra.ConnollySurfacePoint_get_normal(self)
6983 
6984 
6985  def show(self, *args):
6986  """
6987  show(ConnollySurfacePoint self, _ostream out)
6988  show(ConnollySurfacePoint self)
6989  """
6990  return _IMP_algebra.ConnollySurfacePoint_show(self, *args)
6991 
6992 
6993  def __str__(self):
6994  """__str__(ConnollySurfacePoint self) -> std::string"""
6995  return _IMP_algebra.ConnollySurfacePoint___str__(self)
6996 
6997 
6998  def __repr__(self):
6999  """__repr__(ConnollySurfacePoint self) -> std::string"""
7000  return _IMP_algebra.ConnollySurfacePoint___repr__(self)
7001 
7002 
7003  def _get_as_binary(self):
7004  """_get_as_binary(ConnollySurfacePoint self) -> PyObject *"""
7005  return _IMP_algebra.ConnollySurfacePoint__get_as_binary(self)
7006 
7007 
7008  def _set_from_binary(self, p):
7009  """_set_from_binary(ConnollySurfacePoint self, PyObject * p)"""
7010  return _IMP_algebra.ConnollySurfacePoint__set_from_binary(self, p)
7011 
7012 
7013  def __getstate__(self):
7014  p = self._get_as_binary()
7015  if len(self.__dict__) > 1:
7016  d = self.__dict__.copy()
7017  del d['this']
7018  p = (d, p)
7019  return p
7020 
7021  def __setstate__(self, p):
7022  if not hasattr(self, 'this'):
7023  self.__init__()
7024  if isinstance(p, tuple):
7025  d, p = p
7026  self.__dict__.update(d)
7027  return self._set_from_binary(p)
7028 
7029  __swig_destroy__ = _IMP_algebra.delete_ConnollySurfacePoint
7030  __del__ = lambda self: None
7031 ConnollySurfacePoint_swigregister = _IMP_algebra.ConnollySurfacePoint_swigregister
7032 ConnollySurfacePoint_swigregister(ConnollySurfacePoint)
7033 
7034 
7035 def get_connolly_surface(spheres, density, probe_radius):
7036  """get_connolly_surface(IMP::algebra::Sphere3Ds const & spheres, double density, double probe_radius) -> IMP::algebra::ConnollySurfacePoints"""
7037  return _IMP_algebra.get_connolly_surface(spheres, density, probe_radius)
7038 class LogEmbedding3D(object):
7039  """Proxy of C++ IMP::algebra::LogEmbeddingD<(3)> class"""
7040  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7041 
7042  def __init__(self, *args):
7043  """
7044  __init__(IMP::algebra::LogEmbeddingD<(3)> self, Vector3D origin, Vector3D cell, Vector3D base) -> LogEmbedding3D
7045  __init__(IMP::algebra::LogEmbeddingD<(3)> self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding3D
7046  __init__(IMP::algebra::LogEmbeddingD<(3)> self, BoundingBox3D bb, Vector3D bases, IMP::Ints const & counts) -> LogEmbedding3D
7047  __init__(IMP::algebra::LogEmbeddingD<(3)> self, Vector3D arg2, Vector3D arg3) -> LogEmbedding3D
7048  __init__(IMP::algebra::LogEmbeddingD<(3)> self) -> LogEmbedding3D
7049  """
7050  this = _IMP_algebra.new_LogEmbedding3D(*args)
7051  try:
7052  self.this.append(this)
7053  except:
7054  self.this = this
7055 
7056  def set_origin(self, o):
7057  """set_origin(LogEmbedding3D self, Vector3D o)"""
7058  return _IMP_algebra.LogEmbedding3D_set_origin(self, o)
7059 
7060 
7061  def get_origin(self):
7062  """get_origin(LogEmbedding3D self) -> Vector3D"""
7063  return _IMP_algebra.LogEmbedding3D_get_origin(self)
7064 
7065 
7066  def get_dimension(self):
7067  """get_dimension(LogEmbedding3D self) -> unsigned int"""
7068  return _IMP_algebra.LogEmbedding3D_get_dimension(self)
7069 
7070 
7071  def set_unit_cell(self, *args):
7072  """
7073  set_unit_cell(LogEmbedding3D self, Vector3D o, Vector3D base)
7074  set_unit_cell(LogEmbedding3D self, Vector3D o)
7075  """
7076  return _IMP_algebra.LogEmbedding3D_set_unit_cell(self, *args)
7077 
7078 
7079  def get_unit_cell(self):
7080  """get_unit_cell(LogEmbedding3D self) -> Vector3D"""
7081  return _IMP_algebra.LogEmbedding3D_get_unit_cell(self)
7082 
7083 
7084  def get_extended_index(self, o):
7085  """get_extended_index(LogEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
7086  return _IMP_algebra.LogEmbedding3D_get_extended_index(self, o)
7087 
7088 
7089  def get_index(self, o):
7090  """get_index(LogEmbedding3D self, Vector3D o) -> GridIndex3D"""
7091  return _IMP_algebra.LogEmbedding3D_get_index(self, o)
7092 
7093 
7094  def get_center(self, *args):
7095  """
7096  get_center(LogEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
7097  get_center(LogEmbedding3D self, GridIndex3D ei) -> Vector3D
7098  """
7099  return _IMP_algebra.LogEmbedding3D_get_center(self, *args)
7100 
7101 
7102  def get_bounding_box(self, *args):
7103  """
7104  get_bounding_box(LogEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
7105  get_bounding_box(LogEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
7106  """
7107  return _IMP_algebra.LogEmbedding3D_get_bounding_box(self, *args)
7108 
7109 
7110  def show(self, *args):
7111  """
7112  show(LogEmbedding3D self, _ostream out)
7113  show(LogEmbedding3D self)
7114  """
7115  return _IMP_algebra.LogEmbedding3D_show(self, *args)
7116 
7117 
7118  def __str__(self):
7119  """__str__(LogEmbedding3D self) -> std::string"""
7120  return _IMP_algebra.LogEmbedding3D___str__(self)
7121 
7122 
7123  def __repr__(self):
7124  """__repr__(LogEmbedding3D self) -> std::string"""
7125  return _IMP_algebra.LogEmbedding3D___repr__(self)
7126 
7127 
7128  def __cmp__(self, arg2):
7129  """__cmp__(LogEmbedding3D self, LogEmbedding3D arg2) -> int"""
7130  return _IMP_algebra.LogEmbedding3D___cmp__(self, arg2)
7131 
7132 
7133  def __eq__(self, arg2):
7134  """__eq__(LogEmbedding3D self, LogEmbedding3D arg2) -> bool"""
7135  return _IMP_algebra.LogEmbedding3D___eq__(self, arg2)
7136 
7137 
7138  def _get_as_binary(self):
7139  """_get_as_binary(LogEmbedding3D self) -> PyObject *"""
7140  return _IMP_algebra.LogEmbedding3D__get_as_binary(self)
7141 
7142 
7143  def _set_from_binary(self, p):
7144  """_set_from_binary(LogEmbedding3D self, PyObject * p)"""
7145  return _IMP_algebra.LogEmbedding3D__set_from_binary(self, p)
7146 
7147 
7148  def __getstate__(self):
7149  p = self._get_as_binary()
7150  if len(self.__dict__) > 1:
7151  d = self.__dict__.copy()
7152  del d['this']
7153  p = (d, p)
7154  return p
7155 
7156  def __setstate__(self, p):
7157  if not hasattr(self, 'this'):
7158  self.__init__()
7159  if isinstance(p, tuple):
7160  d, p = p
7161  self.__dict__.update(d)
7162  return self._set_from_binary(p)
7163 
7164  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding3D
7165  __del__ = lambda self: None
7166 LogEmbedding3D_swigregister = _IMP_algebra.LogEmbedding3D_swigregister
7167 LogEmbedding3D_swigregister(LogEmbedding3D)
7168 
7169 class LogEmbeddingKD(object):
7170  """Proxy of C++ IMP::algebra::LogEmbeddingD<(-1)> class"""
7171  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7172 
7173  def __init__(self, *args):
7174  """
7175  __init__(IMP::algebra::LogEmbeddingD<(-1)> self, VectorKD origin, VectorKD cell, VectorKD base) -> LogEmbeddingKD
7176  __init__(IMP::algebra::LogEmbeddingD<(-1)> self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbeddingKD
7177  __init__(IMP::algebra::LogEmbeddingD<(-1)> self, BoundingBoxKD bb, VectorKD bases, IMP::Ints const & counts) -> LogEmbeddingKD
7178  __init__(IMP::algebra::LogEmbeddingD<(-1)> self, VectorKD arg2, VectorKD arg3) -> LogEmbeddingKD
7179  __init__(IMP::algebra::LogEmbeddingD<(-1)> self) -> LogEmbeddingKD
7180  """
7181  this = _IMP_algebra.new_LogEmbeddingKD(*args)
7182  try:
7183  self.this.append(this)
7184  except:
7185  self.this = this
7186 
7187  def set_origin(self, o):
7188  """set_origin(LogEmbeddingKD self, VectorKD o)"""
7189  return _IMP_algebra.LogEmbeddingKD_set_origin(self, o)
7190 
7191 
7192  def get_origin(self):
7193  """get_origin(LogEmbeddingKD self) -> VectorKD"""
7194  return _IMP_algebra.LogEmbeddingKD_get_origin(self)
7195 
7196 
7197  def get_dimension(self):
7198  """get_dimension(LogEmbeddingKD self) -> unsigned int"""
7199  return _IMP_algebra.LogEmbeddingKD_get_dimension(self)
7200 
7201 
7202  def set_unit_cell(self, *args):
7203  """
7204  set_unit_cell(LogEmbeddingKD self, VectorKD o, VectorKD base)
7205  set_unit_cell(LogEmbeddingKD self, VectorKD o)
7206  """
7207  return _IMP_algebra.LogEmbeddingKD_set_unit_cell(self, *args)
7208 
7209 
7210  def get_unit_cell(self):
7211  """get_unit_cell(LogEmbeddingKD self) -> VectorKD"""
7212  return _IMP_algebra.LogEmbeddingKD_get_unit_cell(self)
7213 
7214 
7215  def get_extended_index(self, o):
7216  """get_extended_index(LogEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
7217  return _IMP_algebra.LogEmbeddingKD_get_extended_index(self, o)
7218 
7219 
7220  def get_index(self, o):
7221  """get_index(LogEmbeddingKD self, VectorKD o) -> GridIndexKD"""
7222  return _IMP_algebra.LogEmbeddingKD_get_index(self, o)
7223 
7224 
7225  def get_center(self, *args):
7226  """
7227  get_center(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
7228  get_center(LogEmbeddingKD self, GridIndexKD ei) -> VectorKD
7229  """
7230  return _IMP_algebra.LogEmbeddingKD_get_center(self, *args)
7231 
7232 
7233  def get_bounding_box(self, *args):
7234  """
7235  get_bounding_box(LogEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
7236  get_bounding_box(LogEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
7237  """
7238  return _IMP_algebra.LogEmbeddingKD_get_bounding_box(self, *args)
7239 
7240 
7241  def show(self, *args):
7242  """
7243  show(LogEmbeddingKD self, _ostream out)
7244  show(LogEmbeddingKD self)
7245  """
7246  return _IMP_algebra.LogEmbeddingKD_show(self, *args)
7247 
7248 
7249  def __str__(self):
7250  """__str__(LogEmbeddingKD self) -> std::string"""
7251  return _IMP_algebra.LogEmbeddingKD___str__(self)
7252 
7253 
7254  def __repr__(self):
7255  """__repr__(LogEmbeddingKD self) -> std::string"""
7256  return _IMP_algebra.LogEmbeddingKD___repr__(self)
7257 
7258 
7259  def __cmp__(self, arg2):
7260  """__cmp__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> int"""
7261  return _IMP_algebra.LogEmbeddingKD___cmp__(self, arg2)
7262 
7263 
7264  def __eq__(self, arg2):
7265  """__eq__(LogEmbeddingKD self, LogEmbeddingKD arg2) -> bool"""
7266  return _IMP_algebra.LogEmbeddingKD___eq__(self, arg2)
7267 
7268 
7269  def _get_as_binary(self):
7270  """_get_as_binary(LogEmbeddingKD self) -> PyObject *"""
7271  return _IMP_algebra.LogEmbeddingKD__get_as_binary(self)
7272 
7273 
7274  def _set_from_binary(self, p):
7275  """_set_from_binary(LogEmbeddingKD self, PyObject * p)"""
7276  return _IMP_algebra.LogEmbeddingKD__set_from_binary(self, p)
7277 
7278 
7279  def __getstate__(self):
7280  p = self._get_as_binary()
7281  if len(self.__dict__) > 1:
7282  d = self.__dict__.copy()
7283  del d['this']
7284  p = (d, p)
7285  return p
7286 
7287  def __setstate__(self, p):
7288  if not hasattr(self, 'this'):
7289  self.__init__()
7290  if isinstance(p, tuple):
7291  d, p = p
7292  self.__dict__.update(d)
7293  return self._set_from_binary(p)
7294 
7295  __swig_destroy__ = _IMP_algebra.delete_LogEmbeddingKD
7296  __del__ = lambda self: None
7297 LogEmbeddingKD_swigregister = _IMP_algebra.LogEmbeddingKD_swigregister
7298 LogEmbeddingKD_swigregister(LogEmbeddingKD)
7299 
7300 class DenseFloatLogGridKD(object):
7301  """Proxy of C++ IMP::algebra::DenseFloatLogGridKD class"""
7302  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7303 
7304  def __init__(self, sz, le):
7305  """__init__(IMP::algebra::DenseFloatLogGridKD self, IMP::Ints const & sz, LogEmbeddingKD le) -> DenseFloatLogGridKD"""
7306  this = _IMP_algebra.new_DenseFloatLogGridKD(sz, le)
7307  try:
7308  self.this.append(this)
7309  except:
7310  self.this = this
7311 
7312  def add_voxel(self, i, q):
7313  """add_voxel(DenseFloatLogGridKD self, ExtendedGridIndexKD i, float const & q) -> GridIndexKD"""
7314  return _IMP_algebra.DenseFloatLogGridKD_add_voxel(self, i, q)
7315 
7316 
7317  def __getitem__(self, *args):
7318  """
7319  __getitem__(DenseFloatLogGridKD self, GridIndexKD i) -> float
7320  __getitem__(DenseFloatLogGridKD self, VectorKD i) -> float
7321  """
7322  return _IMP_algebra.DenseFloatLogGridKD___getitem__(self, *args)
7323 
7324 
7325  def __setitem__(self, *args):
7326  """
7327  __setitem__(DenseFloatLogGridKD self, GridIndexKD i, float const & q)
7328  __setitem__(DenseFloatLogGridKD self, VectorKD i, float const & q)
7329  """
7330  return _IMP_algebra.DenseFloatLogGridKD___setitem__(self, *args)
7331 
7332 
7333  def get_bounding_box(self, *args):
7334  """
7335  get_bounding_box(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
7336  get_bounding_box(DenseFloatLogGridKD self) -> BoundingBoxKD
7337  """
7338  return _IMP_algebra.DenseFloatLogGridKD_get_bounding_box(self, *args)
7339 
7340 
7341  def get_indexes(self, *args):
7342  """
7343  get_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
7344  get_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
7345  """
7346  return _IMP_algebra.DenseFloatLogGridKD_get_indexes(self, *args)
7347 
7348 
7349  def get_all_indexes(self):
7350  """get_all_indexes(DenseFloatLogGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
7351  return _IMP_algebra.DenseFloatLogGridKD_get_all_indexes(self)
7352 
7353 
7354  def get_extended_indexes(self, *args):
7355  """
7356  get_extended_indexes(DenseFloatLogGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
7357  get_extended_indexes(DenseFloatLogGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
7358  """
7359  return _IMP_algebra.DenseFloatLogGridKD_get_extended_indexes(self, *args)
7360 
7361 
7362  def get_center(self, *args):
7363  """
7364  get_center(DenseFloatLogGridKD self, ExtendedGridIndexKD ei) -> VectorKD
7365  get_center(DenseFloatLogGridKD self, GridIndexKD ei) -> VectorKD
7366  """
7367  return _IMP_algebra.DenseFloatLogGridKD_get_center(self, *args)
7368 
7369 
7370  def get_extended_index(self, v):
7371  """get_extended_index(DenseFloatLogGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
7372  return _IMP_algebra.DenseFloatLogGridKD_get_extended_index(self, v)
7373 
7374 
7375  def get_index(self, v):
7376  """get_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
7377  return _IMP_algebra.DenseFloatLogGridKD_get_index(self, v)
7378 
7379 
7380  def get_origin(self):
7381  """get_origin(DenseFloatLogGridKD self) -> VectorKD"""
7382  return _IMP_algebra.DenseFloatLogGridKD_get_origin(self)
7383 
7384 
7385  def get_dimension(self):
7386  """get_dimension(DenseFloatLogGridKD self) -> unsigned int"""
7387  return _IMP_algebra.DenseFloatLogGridKD_get_dimension(self)
7388 
7389 
7390  def get_unit_cell(self):
7391  """get_unit_cell(DenseFloatLogGridKD self) -> VectorKD"""
7392  return _IMP_algebra.DenseFloatLogGridKD_get_unit_cell(self)
7393 
7394 
7395  def get_has_index(self, v):
7396  """get_has_index(DenseFloatLogGridKD self, ExtendedGridIndexKD v) -> bool"""
7397  return _IMP_algebra.DenseFloatLogGridKD_get_has_index(self, v)
7398 
7399 
7400  def __str__(self):
7401  """__str__(DenseFloatLogGridKD self) -> std::string"""
7402  return _IMP_algebra.DenseFloatLogGridKD___str__(self)
7403 
7404 
7405  def __repr__(self):
7406  """__repr__(DenseFloatLogGridKD self) -> std::string"""
7407  return _IMP_algebra.DenseFloatLogGridKD___repr__(self)
7408 
7409 
7410  def show(self, *args):
7411  """
7412  show(DenseFloatLogGridKD self, _ostream out)
7413  show(DenseFloatLogGridKD self)
7414  """
7415  return _IMP_algebra.DenseFloatLogGridKD_show(self, *args)
7416 
7417  __swig_destroy__ = _IMP_algebra.delete_DenseFloatLogGridKD
7418  __del__ = lambda self: None
7419 DenseFloatLogGridKD_swigregister = _IMP_algebra.DenseFloatLogGridKD_swigregister
7420 DenseFloatLogGridKD_swigregister(DenseFloatLogGridKD)
7421 
7422 class DenseIntLogGrid3D(object):
7423  """Proxy of C++ IMP::algebra::DenseIntLogGrid3D class"""
7424  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7425 
7426  def __init__(self, sz, le):
7427  """__init__(IMP::algebra::DenseIntLogGrid3D self, IMP::Ints const & sz, LogEmbedding3D le) -> DenseIntLogGrid3D"""
7428  this = _IMP_algebra.new_DenseIntLogGrid3D(sz, le)
7429  try:
7430  self.this.append(this)
7431  except:
7432  self.this = this
7433 
7434  def add_voxel(self, i, q):
7435  """add_voxel(DenseIntLogGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
7436  return _IMP_algebra.DenseIntLogGrid3D_add_voxel(self, i, q)
7437 
7438 
7439  def __getitem__(self, *args):
7440  """
7441  __getitem__(DenseIntLogGrid3D self, GridIndex3D i) -> int
7442  __getitem__(DenseIntLogGrid3D self, Vector3D i) -> int
7443  """
7444  return _IMP_algebra.DenseIntLogGrid3D___getitem__(self, *args)
7445 
7446 
7447  def __setitem__(self, *args):
7448  """
7449  __setitem__(DenseIntLogGrid3D self, GridIndex3D i, int const & q)
7450  __setitem__(DenseIntLogGrid3D self, Vector3D i, int const & q)
7451  """
7452  return _IMP_algebra.DenseIntLogGrid3D___setitem__(self, *args)
7453 
7454 
7455  def get_bounding_box(self, *args):
7456  """
7457  get_bounding_box(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
7458  get_bounding_box(DenseIntLogGrid3D self) -> BoundingBox3D
7459  """
7460  return _IMP_algebra.DenseIntLogGrid3D_get_bounding_box(self, *args)
7461 
7462 
7463  def get_indexes(self, *args):
7464  """
7465  get_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7466  get_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7467  """
7468  return _IMP_algebra.DenseIntLogGrid3D_get_indexes(self, *args)
7469 
7470 
7471  def get_all_indexes(self):
7472  """get_all_indexes(DenseIntLogGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
7473  return _IMP_algebra.DenseIntLogGrid3D_get_all_indexes(self)
7474 
7475 
7476  def get_extended_indexes(self, *args):
7477  """
7478  get_extended_indexes(DenseIntLogGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7479  get_extended_indexes(DenseIntLogGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7480  """
7481  return _IMP_algebra.DenseIntLogGrid3D_get_extended_indexes(self, *args)
7482 
7483 
7484  def get_center(self, *args):
7485  """
7486  get_center(DenseIntLogGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
7487  get_center(DenseIntLogGrid3D self, GridIndex3D ei) -> Vector3D
7488  """
7489  return _IMP_algebra.DenseIntLogGrid3D_get_center(self, *args)
7490 
7491 
7492  def get_extended_index(self, v):
7493  """get_extended_index(DenseIntLogGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
7494  return _IMP_algebra.DenseIntLogGrid3D_get_extended_index(self, v)
7495 
7496 
7497  def get_index(self, v):
7498  """get_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
7499  return _IMP_algebra.DenseIntLogGrid3D_get_index(self, v)
7500 
7501 
7502  def get_origin(self):
7503  """get_origin(DenseIntLogGrid3D self) -> Vector3D"""
7504  return _IMP_algebra.DenseIntLogGrid3D_get_origin(self)
7505 
7506 
7507  def get_dimension(self):
7508  """get_dimension(DenseIntLogGrid3D self) -> unsigned int"""
7509  return _IMP_algebra.DenseIntLogGrid3D_get_dimension(self)
7510 
7511 
7512  def get_unit_cell(self):
7513  """get_unit_cell(DenseIntLogGrid3D self) -> Vector3D"""
7514  return _IMP_algebra.DenseIntLogGrid3D_get_unit_cell(self)
7515 
7516 
7517  def get_has_index(self, v):
7518  """get_has_index(DenseIntLogGrid3D self, ExtendedGridIndex3D v) -> bool"""
7519  return _IMP_algebra.DenseIntLogGrid3D_get_has_index(self, v)
7520 
7521 
7522  def __str__(self):
7523  """__str__(DenseIntLogGrid3D self) -> std::string"""
7524  return _IMP_algebra.DenseIntLogGrid3D___str__(self)
7525 
7526 
7527  def __repr__(self):
7528  """__repr__(DenseIntLogGrid3D self) -> std::string"""
7529  return _IMP_algebra.DenseIntLogGrid3D___repr__(self)
7530 
7531 
7532  def show(self, *args):
7533  """
7534  show(DenseIntLogGrid3D self, _ostream out)
7535  show(DenseIntLogGrid3D self)
7536  """
7537  return _IMP_algebra.DenseIntLogGrid3D_show(self, *args)
7538 
7539  __swig_destroy__ = _IMP_algebra.delete_DenseIntLogGrid3D
7540  __del__ = lambda self: None
7541 DenseIntLogGrid3D_swigregister = _IMP_algebra.DenseIntLogGrid3D_swigregister
7542 DenseIntLogGrid3D_swigregister(DenseIntLogGrid3D)
7543 
7544 class DenseDoubleGrid3D(object):
7545  """Proxy of C++ IMP::algebra::DenseGrid3D<(double)> class"""
7546  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7547 
7548  def __init__(self, *args):
7549  """
7550  __init__(IMP::algebra::DenseGrid3D<(double)> self, double side, BoundingBox3D bb, double arg4) -> DenseDoubleGrid3D
7551  __init__(IMP::algebra::DenseGrid3D<(double)> self, double side, BoundingBox3D bb) -> DenseDoubleGrid3D
7552  __init__(IMP::algebra::DenseGrid3D<(double)> self) -> DenseDoubleGrid3D
7553  """
7554  this = _IMP_algebra.new_DenseDoubleGrid3D(*args)
7555  try:
7556  self.this.append(this)
7557  except:
7558  self.this = this
7559 
7560  def add_voxel(self, i, q):
7561  """add_voxel(DenseDoubleGrid3D self, ExtendedGridIndex3D i, double const & q) -> GridIndex3D"""
7562  return _IMP_algebra.DenseDoubleGrid3D_add_voxel(self, i, q)
7563 
7564 
7565  def __getitem__(self, *args):
7566  """
7567  __getitem__(DenseDoubleGrid3D self, GridIndex3D i) -> double
7568  __getitem__(DenseDoubleGrid3D self, Vector3D i) -> double
7569  """
7570  return _IMP_algebra.DenseDoubleGrid3D___getitem__(self, *args)
7571 
7572 
7573  def __setitem__(self, *args):
7574  """
7575  __setitem__(DenseDoubleGrid3D self, GridIndex3D i, double const & q)
7576  __setitem__(DenseDoubleGrid3D self, Vector3D i, double const & q)
7577  """
7578  return _IMP_algebra.DenseDoubleGrid3D___setitem__(self, *args)
7579 
7580 
7581  def get_bounding_box(self, *args):
7582  """
7583  get_bounding_box(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
7584  get_bounding_box(DenseDoubleGrid3D self) -> BoundingBox3D
7585  """
7586  return _IMP_algebra.DenseDoubleGrid3D_get_bounding_box(self, *args)
7587 
7588 
7589  def get_indexes(self, *args):
7590  """
7591  get_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7592  get_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7593  """
7594  return _IMP_algebra.DenseDoubleGrid3D_get_indexes(self, *args)
7595 
7596 
7597  def get_all_indexes(self):
7598  """get_all_indexes(DenseDoubleGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
7599  return _IMP_algebra.DenseDoubleGrid3D_get_all_indexes(self)
7600 
7601 
7602  def get_extended_indexes(self, *args):
7603  """
7604  get_extended_indexes(DenseDoubleGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7605  get_extended_indexes(DenseDoubleGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7606  """
7607  return _IMP_algebra.DenseDoubleGrid3D_get_extended_indexes(self, *args)
7608 
7609 
7610  def get_center(self, *args):
7611  """
7612  get_center(DenseDoubleGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
7613  get_center(DenseDoubleGrid3D self, GridIndex3D ei) -> Vector3D
7614  """
7615  return _IMP_algebra.DenseDoubleGrid3D_get_center(self, *args)
7616 
7617 
7618  def get_extended_index(self, v):
7619  """get_extended_index(DenseDoubleGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
7620  return _IMP_algebra.DenseDoubleGrid3D_get_extended_index(self, v)
7621 
7622 
7623  def get_index(self, v):
7624  """get_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
7625  return _IMP_algebra.DenseDoubleGrid3D_get_index(self, v)
7626 
7627 
7628  def get_origin(self):
7629  """get_origin(DenseDoubleGrid3D self) -> Vector3D"""
7630  return _IMP_algebra.DenseDoubleGrid3D_get_origin(self)
7631 
7632 
7633  def get_dimension(self):
7634  """get_dimension(DenseDoubleGrid3D self) -> unsigned int"""
7635  return _IMP_algebra.DenseDoubleGrid3D_get_dimension(self)
7636 
7637 
7638  def get_unit_cell(self):
7639  """get_unit_cell(DenseDoubleGrid3D self) -> Vector3D"""
7640  return _IMP_algebra.DenseDoubleGrid3D_get_unit_cell(self)
7641 
7642 
7643  def get_has_index(self, v):
7644  """get_has_index(DenseDoubleGrid3D self, ExtendedGridIndex3D v) -> bool"""
7645  return _IMP_algebra.DenseDoubleGrid3D_get_has_index(self, v)
7646 
7647 
7648  def __str__(self):
7649  """__str__(DenseDoubleGrid3D self) -> std::string"""
7650  return _IMP_algebra.DenseDoubleGrid3D___str__(self)
7651 
7652 
7653  def __repr__(self):
7654  """__repr__(DenseDoubleGrid3D self) -> std::string"""
7655  return _IMP_algebra.DenseDoubleGrid3D___repr__(self)
7656 
7657 
7658  def show(self, *args):
7659  """
7660  show(DenseDoubleGrid3D self, _ostream out)
7661  show(DenseDoubleGrid3D self)
7662  """
7663  return _IMP_algebra.DenseDoubleGrid3D_show(self, *args)
7664 
7665  __swig_destroy__ = _IMP_algebra.delete_DenseDoubleGrid3D
7666  __del__ = lambda self: None
7667 DenseDoubleGrid3D_swigregister = _IMP_algebra.DenseDoubleGrid3D_swigregister
7668 DenseDoubleGrid3D_swigregister(DenseDoubleGrid3D)
7669 
7670 class DenseFloatGrid3D(object):
7671  """Proxy of C++ IMP::algebra::DenseGrid3D<(float)> class"""
7672  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7673 
7674  def __init__(self, *args):
7675  """
7676  __init__(IMP::algebra::DenseGrid3D<(float)> self, double side, BoundingBox3D bb, float arg4) -> DenseFloatGrid3D
7677  __init__(IMP::algebra::DenseGrid3D<(float)> self, double side, BoundingBox3D bb) -> DenseFloatGrid3D
7678  __init__(IMP::algebra::DenseGrid3D<(float)> self) -> DenseFloatGrid3D
7679  """
7680  this = _IMP_algebra.new_DenseFloatGrid3D(*args)
7681  try:
7682  self.this.append(this)
7683  except:
7684  self.this = this
7685 
7686  def add_voxel(self, i, q):
7687  """add_voxel(DenseFloatGrid3D self, ExtendedGridIndex3D i, float const & q) -> GridIndex3D"""
7688  return _IMP_algebra.DenseFloatGrid3D_add_voxel(self, i, q)
7689 
7690 
7691  def __getitem__(self, *args):
7692  """
7693  __getitem__(DenseFloatGrid3D self, GridIndex3D i) -> float
7694  __getitem__(DenseFloatGrid3D self, Vector3D i) -> float
7695  """
7696  return _IMP_algebra.DenseFloatGrid3D___getitem__(self, *args)
7697 
7698 
7699  def __setitem__(self, *args):
7700  """
7701  __setitem__(DenseFloatGrid3D self, GridIndex3D i, float const & q)
7702  __setitem__(DenseFloatGrid3D self, Vector3D i, float const & q)
7703  """
7704  return _IMP_algebra.DenseFloatGrid3D___setitem__(self, *args)
7705 
7706 
7707  def get_bounding_box(self, *args):
7708  """
7709  get_bounding_box(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
7710  get_bounding_box(DenseFloatGrid3D self) -> BoundingBox3D
7711  """
7712  return _IMP_algebra.DenseFloatGrid3D_get_bounding_box(self, *args)
7713 
7714 
7715  def get_indexes(self, *args):
7716  """
7717  get_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7718  get_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7719  """
7720  return _IMP_algebra.DenseFloatGrid3D_get_indexes(self, *args)
7721 
7722 
7723  def get_all_indexes(self):
7724  """get_all_indexes(DenseFloatGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
7725  return _IMP_algebra.DenseFloatGrid3D_get_all_indexes(self)
7726 
7727 
7728  def get_extended_indexes(self, *args):
7729  """
7730  get_extended_indexes(DenseFloatGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7731  get_extended_indexes(DenseFloatGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7732  """
7733  return _IMP_algebra.DenseFloatGrid3D_get_extended_indexes(self, *args)
7734 
7735 
7736  def get_center(self, *args):
7737  """
7738  get_center(DenseFloatGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
7739  get_center(DenseFloatGrid3D self, GridIndex3D ei) -> Vector3D
7740  """
7741  return _IMP_algebra.DenseFloatGrid3D_get_center(self, *args)
7742 
7743 
7744  def get_extended_index(self, v):
7745  """get_extended_index(DenseFloatGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
7746  return _IMP_algebra.DenseFloatGrid3D_get_extended_index(self, v)
7747 
7748 
7749  def get_index(self, v):
7750  """get_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
7751  return _IMP_algebra.DenseFloatGrid3D_get_index(self, v)
7752 
7753 
7754  def get_origin(self):
7755  """get_origin(DenseFloatGrid3D self) -> Vector3D"""
7756  return _IMP_algebra.DenseFloatGrid3D_get_origin(self)
7757 
7758 
7759  def get_dimension(self):
7760  """get_dimension(DenseFloatGrid3D self) -> unsigned int"""
7761  return _IMP_algebra.DenseFloatGrid3D_get_dimension(self)
7762 
7763 
7764  def get_unit_cell(self):
7765  """get_unit_cell(DenseFloatGrid3D self) -> Vector3D"""
7766  return _IMP_algebra.DenseFloatGrid3D_get_unit_cell(self)
7767 
7768 
7769  def get_has_index(self, v):
7770  """get_has_index(DenseFloatGrid3D self, ExtendedGridIndex3D v) -> bool"""
7771  return _IMP_algebra.DenseFloatGrid3D_get_has_index(self, v)
7772 
7773 
7774  def __str__(self):
7775  """__str__(DenseFloatGrid3D self) -> std::string"""
7776  return _IMP_algebra.DenseFloatGrid3D___str__(self)
7777 
7778 
7779  def __repr__(self):
7780  """__repr__(DenseFloatGrid3D self) -> std::string"""
7781  return _IMP_algebra.DenseFloatGrid3D___repr__(self)
7782 
7783 
7784  def show(self, *args):
7785  """
7786  show(DenseFloatGrid3D self, _ostream out)
7787  show(DenseFloatGrid3D self)
7788  """
7789  return _IMP_algebra.DenseFloatGrid3D_show(self, *args)
7790 
7791  __swig_destroy__ = _IMP_algebra.delete_DenseFloatGrid3D
7792  __del__ = lambda self: None
7793 DenseFloatGrid3D_swigregister = _IMP_algebra.DenseFloatGrid3D_swigregister
7794 DenseFloatGrid3D_swigregister(DenseFloatGrid3D)
7795 
7796 class SparseUnboundedIntGrid3D(object):
7797  """Proxy of C++ IMP::algebra::SparseUnboundedGrid3D<(int)> class"""
7798  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7799 
7800  def __init__(self, *args):
7801  """
7802  __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, double side, Vector3D origin, int arg4) -> SparseUnboundedIntGrid3D
7803  __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, double side, Vector3D origin) -> SparseUnboundedIntGrid3D
7804  __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, Vector3D sides, Vector3D origin, int arg4) -> SparseUnboundedIntGrid3D
7805  __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self, Vector3D sides, Vector3D origin) -> SparseUnboundedIntGrid3D
7806  __init__(IMP::algebra::SparseUnboundedGrid3D<(int)> self) -> SparseUnboundedIntGrid3D
7807  """
7808  this = _IMP_algebra.new_SparseUnboundedIntGrid3D(*args)
7809  try:
7810  self.this.append(this)
7811  except:
7812  self.this = this
7813 
7814  def add_voxel(self, i, q):
7815  """add_voxel(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D i, int const & q) -> GridIndex3D"""
7816  return _IMP_algebra.SparseUnboundedIntGrid3D_add_voxel(self, i, q)
7817 
7818 
7819  def __getitem__(self, *args):
7820  """
7821  __getitem__(SparseUnboundedIntGrid3D self, GridIndex3D i) -> int
7822  __getitem__(SparseUnboundedIntGrid3D self, Vector3D i) -> int
7823  """
7824  return _IMP_algebra.SparseUnboundedIntGrid3D___getitem__(self, *args)
7825 
7826 
7827  def __setitem__(self, *args):
7828  """
7829  __setitem__(SparseUnboundedIntGrid3D self, GridIndex3D i, int const & q)
7830  __setitem__(SparseUnboundedIntGrid3D self, Vector3D i, int const & q)
7831  """
7832  return _IMP_algebra.SparseUnboundedIntGrid3D___setitem__(self, *args)
7833 
7834 
7835  def get_bounding_box(self, *args):
7836  """
7837  get_bounding_box(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> BoundingBox3D
7838  get_bounding_box(SparseUnboundedIntGrid3D self) -> BoundingBox3D
7839  """
7840  return _IMP_algebra.SparseUnboundedIntGrid3D_get_bounding_box(self, *args)
7841 
7842 
7843  def get_indexes(self, *args):
7844  """
7845  get_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7846  get_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >
7847  """
7848  return _IMP_algebra.SparseUnboundedIntGrid3D_get_indexes(self, *args)
7849 
7850 
7851  def get_all_indexes(self):
7852  """get_all_indexes(SparseUnboundedIntGrid3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
7853  return _IMP_algebra.SparseUnboundedIntGrid3D_get_all_indexes(self)
7854 
7855 
7856  def get_extended_indexes(self, *args):
7857  """
7858  get_extended_indexes(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7859  get_extended_indexes(SparseUnboundedIntGrid3D self, BoundingBox3D bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >
7860  """
7861  return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_indexes(self, *args)
7862 
7863 
7864  def get_center(self, *args):
7865  """
7866  get_center(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D ei) -> Vector3D
7867  get_center(SparseUnboundedIntGrid3D self, GridIndex3D ei) -> Vector3D
7868  """
7869  return _IMP_algebra.SparseUnboundedIntGrid3D_get_center(self, *args)
7870 
7871 
7872  def get_extended_index(self, v):
7873  """get_extended_index(SparseUnboundedIntGrid3D self, Vector3D v) -> ExtendedGridIndex3D"""
7874  return _IMP_algebra.SparseUnboundedIntGrid3D_get_extended_index(self, v)
7875 
7876 
7877  def get_index(self, v):
7878  """get_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
7879  return _IMP_algebra.SparseUnboundedIntGrid3D_get_index(self, v)
7880 
7881 
7882  def get_origin(self):
7883  """get_origin(SparseUnboundedIntGrid3D self) -> Vector3D"""
7884  return _IMP_algebra.SparseUnboundedIntGrid3D_get_origin(self)
7885 
7886 
7887  def get_dimension(self):
7888  """get_dimension(SparseUnboundedIntGrid3D self) -> unsigned int"""
7889  return _IMP_algebra.SparseUnboundedIntGrid3D_get_dimension(self)
7890 
7891 
7892  def get_unit_cell(self):
7893  """get_unit_cell(SparseUnboundedIntGrid3D self) -> Vector3D"""
7894  return _IMP_algebra.SparseUnboundedIntGrid3D_get_unit_cell(self)
7895 
7896 
7897  def get_has_index(self, v):
7898  """get_has_index(SparseUnboundedIntGrid3D self, ExtendedGridIndex3D v) -> bool"""
7899  return _IMP_algebra.SparseUnboundedIntGrid3D_get_has_index(self, v)
7900 
7901 
7902  def __str__(self):
7903  """__str__(SparseUnboundedIntGrid3D self) -> std::string"""
7904  return _IMP_algebra.SparseUnboundedIntGrid3D___str__(self)
7905 
7906 
7907  def __repr__(self):
7908  """__repr__(SparseUnboundedIntGrid3D self) -> std::string"""
7909  return _IMP_algebra.SparseUnboundedIntGrid3D___repr__(self)
7910 
7911 
7912  def show(self, *args):
7913  """
7914  show(SparseUnboundedIntGrid3D self, _ostream out)
7915  show(SparseUnboundedIntGrid3D self)
7916  """
7917  return _IMP_algebra.SparseUnboundedIntGrid3D_show(self, *args)
7918 
7919  __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGrid3D
7920  __del__ = lambda self: None
7921 SparseUnboundedIntGrid3D_swigregister = _IMP_algebra.SparseUnboundedIntGrid3D_swigregister
7922 SparseUnboundedIntGrid3D_swigregister(SparseUnboundedIntGrid3D)
7923 
7924 class SparseUnboundedIntGridKD(object):
7925  """Proxy of C++ IMP::algebra::SparseUnboundedGridD<(-1,int)> class"""
7926  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7927 
7928  def __init__(self, *args):
7929  """
7930  __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self, double side, VectorKD origin, int arg4) -> SparseUnboundedIntGridKD
7931  __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self, double side, VectorKD origin) -> SparseUnboundedIntGridKD
7932  __init__(IMP::algebra::SparseUnboundedGridD<(-1,int)> self) -> SparseUnboundedIntGridKD
7933  """
7934  this = _IMP_algebra.new_SparseUnboundedIntGridKD(*args)
7935  try:
7936  self.this.append(this)
7937  except:
7938  self.this = this
7939 
7940  def add_voxel(self, i, q):
7941  """add_voxel(SparseUnboundedIntGridKD self, ExtendedGridIndexKD i, int const & q) -> GridIndexKD"""
7942  return _IMP_algebra.SparseUnboundedIntGridKD_add_voxel(self, i, q)
7943 
7944 
7945  def __getitem__(self, *args):
7946  """
7947  __getitem__(SparseUnboundedIntGridKD self, GridIndexKD i) -> int
7948  __getitem__(SparseUnboundedIntGridKD self, VectorKD i) -> int
7949  """
7950  return _IMP_algebra.SparseUnboundedIntGridKD___getitem__(self, *args)
7951 
7952 
7953  def __setitem__(self, *args):
7954  """
7955  __setitem__(SparseUnboundedIntGridKD self, GridIndexKD i, int const & q)
7956  __setitem__(SparseUnboundedIntGridKD self, VectorKD i, int const & q)
7957  """
7958  return _IMP_algebra.SparseUnboundedIntGridKD___setitem__(self, *args)
7959 
7960 
7961  def get_bounding_box(self, *args):
7962  """
7963  get_bounding_box(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> BoundingBoxKD
7964  get_bounding_box(SparseUnboundedIntGridKD self) -> BoundingBoxKD
7965  """
7966  return _IMP_algebra.SparseUnboundedIntGridKD_get_bounding_box(self, *args)
7967 
7968 
7969  def get_indexes(self, *args):
7970  """
7971  get_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
7972  get_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >
7973  """
7974  return _IMP_algebra.SparseUnboundedIntGridKD_get_indexes(self, *args)
7975 
7976 
7977  def get_all_indexes(self):
7978  """get_all_indexes(SparseUnboundedIntGridKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
7979  return _IMP_algebra.SparseUnboundedIntGridKD_get_all_indexes(self)
7980 
7981 
7982  def get_extended_indexes(self, *args):
7983  """
7984  get_extended_indexes(SparseUnboundedIntGridKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
7985  get_extended_indexes(SparseUnboundedIntGridKD self, BoundingBoxKD bb) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >
7986  """
7987  return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_indexes(self, *args)
7988 
7989 
7990  def get_center(self, *args):
7991  """
7992  get_center(SparseUnboundedIntGridKD self, ExtendedGridIndexKD ei) -> VectorKD
7993  get_center(SparseUnboundedIntGridKD self, GridIndexKD ei) -> VectorKD
7994  """
7995  return _IMP_algebra.SparseUnboundedIntGridKD_get_center(self, *args)
7996 
7997 
7998  def get_extended_index(self, v):
7999  """get_extended_index(SparseUnboundedIntGridKD self, VectorKD v) -> ExtendedGridIndexKD"""
8000  return _IMP_algebra.SparseUnboundedIntGridKD_get_extended_index(self, v)
8001 
8002 
8003  def get_index(self, v):
8004  """get_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
8005  return _IMP_algebra.SparseUnboundedIntGridKD_get_index(self, v)
8006 
8007 
8008  def get_origin(self):
8009  """get_origin(SparseUnboundedIntGridKD self) -> VectorKD"""
8010  return _IMP_algebra.SparseUnboundedIntGridKD_get_origin(self)
8011 
8012 
8013  def get_dimension(self):
8014  """get_dimension(SparseUnboundedIntGridKD self) -> unsigned int"""
8015  return _IMP_algebra.SparseUnboundedIntGridKD_get_dimension(self)
8016 
8017 
8018  def get_unit_cell(self):
8019  """get_unit_cell(SparseUnboundedIntGridKD self) -> VectorKD"""
8020  return _IMP_algebra.SparseUnboundedIntGridKD_get_unit_cell(self)
8021 
8022 
8023  def get_has_index(self, v):
8024  """get_has_index(SparseUnboundedIntGridKD self, ExtendedGridIndexKD v) -> bool"""
8025  return _IMP_algebra.SparseUnboundedIntGridKD_get_has_index(self, v)
8026 
8027 
8028  def __str__(self):
8029  """__str__(SparseUnboundedIntGridKD self) -> std::string"""
8030  return _IMP_algebra.SparseUnboundedIntGridKD___str__(self)
8031 
8032 
8033  def __repr__(self):
8034  """__repr__(SparseUnboundedIntGridKD self) -> std::string"""
8035  return _IMP_algebra.SparseUnboundedIntGridKD___repr__(self)
8036 
8037 
8038  def show(self, *args):
8039  """
8040  show(SparseUnboundedIntGridKD self, _ostream out)
8041  show(SparseUnboundedIntGridKD self)
8042  """
8043  return _IMP_algebra.SparseUnboundedIntGridKD_show(self, *args)
8044 
8045  __swig_destroy__ = _IMP_algebra.delete_SparseUnboundedIntGridKD
8046  __del__ = lambda self: None
8047 SparseUnboundedIntGridKD_swigregister = _IMP_algebra.SparseUnboundedIntGridKD_swigregister
8048 SparseUnboundedIntGridKD_swigregister(SparseUnboundedIntGridKD)
8049 
8050 class GridIndex1D(IMP._Value):
8051  """Proxy of C++ IMP::algebra::GridIndexD<(1)> class"""
8052  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8053 
8054  def __init__(self, *args):
8055  """
8056  __init__(IMP::algebra::GridIndexD<(1)> self) -> GridIndex1D
8057  __init__(IMP::algebra::GridIndexD<(1)> self, int x) -> GridIndex1D
8058  __init__(IMP::algebra::GridIndexD<(1)> self, int x, int y) -> GridIndex1D
8059  __init__(IMP::algebra::GridIndexD<(1)> self, int x, int y, int z) -> GridIndex1D
8060  __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l) -> GridIndex1D
8061  __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l, int m) -> GridIndex1D
8062  __init__(IMP::algebra::GridIndexD<(1)> self, int i, int j, int k, int l, int m, int n) -> GridIndex1D
8063  """
8064  this = _IMP_algebra.new_GridIndex1D(*args)
8065  try:
8066  self.this.append(this)
8067  except:
8068  self.this = this
8069 
8070  def get_dimension(self):
8071  """get_dimension(GridIndex1D self) -> unsigned int"""
8072  return _IMP_algebra.GridIndex1D_get_dimension(self)
8073 
8074 
8075  def __getitem__(self, i):
8076  """__getitem__(GridIndex1D self, unsigned int i) -> int const &"""
8077  return _IMP_algebra.GridIndex1D___getitem__(self, i)
8078 
8079 
8080  def show(self, *args):
8081  """
8082  show(GridIndex1D self, _ostream out)
8083  show(GridIndex1D self)
8084  """
8085  return _IMP_algebra.GridIndex1D_show(self, *args)
8086 
8087 
8088  def __len__(self):
8089  """__len__(GridIndex1D self) -> unsigned int"""
8090  return _IMP_algebra.GridIndex1D___len__(self)
8091 
8092 
8093  def __cmp__(self, o):
8094  """__cmp__(GridIndex1D self, GridIndex1D o) -> int"""
8095  return _IMP_algebra.GridIndex1D___cmp__(self, o)
8096 
8097 
8098  def __eq__(self, o):
8099  """__eq__(GridIndex1D self, GridIndex1D o) -> bool"""
8100  return _IMP_algebra.GridIndex1D___eq__(self, o)
8101 
8102 
8103  def __ne__(self, o):
8104  """__ne__(GridIndex1D self, GridIndex1D o) -> bool"""
8105  return _IMP_algebra.GridIndex1D___ne__(self, o)
8106 
8107 
8108  def __lt__(self, o):
8109  """__lt__(GridIndex1D self, GridIndex1D o) -> bool"""
8110  return _IMP_algebra.GridIndex1D___lt__(self, o)
8111 
8112 
8113  def __gt__(self, o):
8114  """__gt__(GridIndex1D self, GridIndex1D o) -> bool"""
8115  return _IMP_algebra.GridIndex1D___gt__(self, o)
8116 
8117 
8118  def __ge__(self, o):
8119  """__ge__(GridIndex1D self, GridIndex1D o) -> bool"""
8120  return _IMP_algebra.GridIndex1D___ge__(self, o)
8121 
8122 
8123  def __le__(self, o):
8124  """__le__(GridIndex1D self, GridIndex1D o) -> bool"""
8125  return _IMP_algebra.GridIndex1D___le__(self, o)
8126 
8127 
8128  def __hash__(self):
8129  """__hash__(GridIndex1D self) -> std::size_t"""
8130  return _IMP_algebra.GridIndex1D___hash__(self)
8131 
8132 
8133  def __str__(self):
8134  """__str__(GridIndex1D self) -> std::string"""
8135  return _IMP_algebra.GridIndex1D___str__(self)
8136 
8137 
8138  def __repr__(self):
8139  """__repr__(GridIndex1D self) -> std::string"""
8140  return _IMP_algebra.GridIndex1D___repr__(self)
8141 
8142 
8143  def _get_as_binary(self):
8144  """_get_as_binary(GridIndex1D self) -> PyObject *"""
8145  return _IMP_algebra.GridIndex1D__get_as_binary(self)
8146 
8147 
8148  def _set_from_binary(self, p):
8149  """_set_from_binary(GridIndex1D self, PyObject * p)"""
8150  return _IMP_algebra.GridIndex1D__set_from_binary(self, p)
8151 
8152 
8153  def __getstate__(self):
8154  p = self._get_as_binary()
8155  if len(self.__dict__) > 1:
8156  d = self.__dict__.copy()
8157  del d['this']
8158  p = (d, p)
8159  return p
8160 
8161  def __setstate__(self, p):
8162  if not hasattr(self, 'this'):
8163  self.__init__()
8164  if isinstance(p, tuple):
8165  d, p = p
8166  self.__dict__.update(d)
8167  return self._set_from_binary(p)
8168 
8169  __swig_destroy__ = _IMP_algebra.delete_GridIndex1D
8170  __del__ = lambda self: None
8171 GridIndex1D_swigregister = _IMP_algebra.GridIndex1D_swigregister
8172 GridIndex1D_swigregister(GridIndex1D)
8173 
8174 class GridIndex2D(IMP._Value):
8175  """Proxy of C++ IMP::algebra::GridIndexD<(2)> class"""
8176  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8177 
8178  def __init__(self, *args):
8179  """
8180  __init__(IMP::algebra::GridIndexD<(2)> self) -> GridIndex2D
8181  __init__(IMP::algebra::GridIndexD<(2)> self, int x) -> GridIndex2D
8182  __init__(IMP::algebra::GridIndexD<(2)> self, int x, int y) -> GridIndex2D
8183  __init__(IMP::algebra::GridIndexD<(2)> self, int x, int y, int z) -> GridIndex2D
8184  __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l) -> GridIndex2D
8185  __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l, int m) -> GridIndex2D
8186  __init__(IMP::algebra::GridIndexD<(2)> self, int i, int j, int k, int l, int m, int n) -> GridIndex2D
8187  """
8188  this = _IMP_algebra.new_GridIndex2D(*args)
8189  try:
8190  self.this.append(this)
8191  except:
8192  self.this = this
8193 
8194  def get_dimension(self):
8195  """get_dimension(GridIndex2D self) -> unsigned int"""
8196  return _IMP_algebra.GridIndex2D_get_dimension(self)
8197 
8198 
8199  def __getitem__(self, i):
8200  """__getitem__(GridIndex2D self, unsigned int i) -> int const &"""
8201  return _IMP_algebra.GridIndex2D___getitem__(self, i)
8202 
8203 
8204  def show(self, *args):
8205  """
8206  show(GridIndex2D self, _ostream out)
8207  show(GridIndex2D self)
8208  """
8209  return _IMP_algebra.GridIndex2D_show(self, *args)
8210 
8211 
8212  def __len__(self):
8213  """__len__(GridIndex2D self) -> unsigned int"""
8214  return _IMP_algebra.GridIndex2D___len__(self)
8215 
8216 
8217  def __cmp__(self, o):
8218  """__cmp__(GridIndex2D self, GridIndex2D o) -> int"""
8219  return _IMP_algebra.GridIndex2D___cmp__(self, o)
8220 
8221 
8222  def __eq__(self, o):
8223  """__eq__(GridIndex2D self, GridIndex2D o) -> bool"""
8224  return _IMP_algebra.GridIndex2D___eq__(self, o)
8225 
8226 
8227  def __ne__(self, o):
8228  """__ne__(GridIndex2D self, GridIndex2D o) -> bool"""
8229  return _IMP_algebra.GridIndex2D___ne__(self, o)
8230 
8231 
8232  def __lt__(self, o):
8233  """__lt__(GridIndex2D self, GridIndex2D o) -> bool"""
8234  return _IMP_algebra.GridIndex2D___lt__(self, o)
8235 
8236 
8237  def __gt__(self, o):
8238  """__gt__(GridIndex2D self, GridIndex2D o) -> bool"""
8239  return _IMP_algebra.GridIndex2D___gt__(self, o)
8240 
8241 
8242  def __ge__(self, o):
8243  """__ge__(GridIndex2D self, GridIndex2D o) -> bool"""
8244  return _IMP_algebra.GridIndex2D___ge__(self, o)
8245 
8246 
8247  def __le__(self, o):
8248  """__le__(GridIndex2D self, GridIndex2D o) -> bool"""
8249  return _IMP_algebra.GridIndex2D___le__(self, o)
8250 
8251 
8252  def __hash__(self):
8253  """__hash__(GridIndex2D self) -> std::size_t"""
8254  return _IMP_algebra.GridIndex2D___hash__(self)
8255 
8256 
8257  def __str__(self):
8258  """__str__(GridIndex2D self) -> std::string"""
8259  return _IMP_algebra.GridIndex2D___str__(self)
8260 
8261 
8262  def __repr__(self):
8263  """__repr__(GridIndex2D self) -> std::string"""
8264  return _IMP_algebra.GridIndex2D___repr__(self)
8265 
8266 
8267  def _get_as_binary(self):
8268  """_get_as_binary(GridIndex2D self) -> PyObject *"""
8269  return _IMP_algebra.GridIndex2D__get_as_binary(self)
8270 
8271 
8272  def _set_from_binary(self, p):
8273  """_set_from_binary(GridIndex2D self, PyObject * p)"""
8274  return _IMP_algebra.GridIndex2D__set_from_binary(self, p)
8275 
8276 
8277  def __getstate__(self):
8278  p = self._get_as_binary()
8279  if len(self.__dict__) > 1:
8280  d = self.__dict__.copy()
8281  del d['this']
8282  p = (d, p)
8283  return p
8284 
8285  def __setstate__(self, p):
8286  if not hasattr(self, 'this'):
8287  self.__init__()
8288  if isinstance(p, tuple):
8289  d, p = p
8290  self.__dict__.update(d)
8291  return self._set_from_binary(p)
8292 
8293  __swig_destroy__ = _IMP_algebra.delete_GridIndex2D
8294  __del__ = lambda self: None
8295 GridIndex2D_swigregister = _IMP_algebra.GridIndex2D_swigregister
8296 GridIndex2D_swigregister(GridIndex2D)
8297 
8298 class GridIndex3D(IMP._Value):
8299  """Proxy of C++ IMP::algebra::GridIndexD<(3)> class"""
8300  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8301 
8302  def __init__(self, *args):
8303  """
8304  __init__(IMP::algebra::GridIndexD<(3)> self) -> GridIndex3D
8305  __init__(IMP::algebra::GridIndexD<(3)> self, int x) -> GridIndex3D
8306  __init__(IMP::algebra::GridIndexD<(3)> self, int x, int y) -> GridIndex3D
8307  __init__(IMP::algebra::GridIndexD<(3)> self, int x, int y, int z) -> GridIndex3D
8308  __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l) -> GridIndex3D
8309  __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l, int m) -> GridIndex3D
8310  __init__(IMP::algebra::GridIndexD<(3)> self, int i, int j, int k, int l, int m, int n) -> GridIndex3D
8311  """
8312  this = _IMP_algebra.new_GridIndex3D(*args)
8313  try:
8314  self.this.append(this)
8315  except:
8316  self.this = this
8317 
8318  def get_dimension(self):
8319  """get_dimension(GridIndex3D self) -> unsigned int"""
8320  return _IMP_algebra.GridIndex3D_get_dimension(self)
8321 
8322 
8323  def __getitem__(self, i):
8324  """__getitem__(GridIndex3D self, unsigned int i) -> int const &"""
8325  return _IMP_algebra.GridIndex3D___getitem__(self, i)
8326 
8327 
8328  def show(self, *args):
8329  """
8330  show(GridIndex3D self, _ostream out)
8331  show(GridIndex3D self)
8332  """
8333  return _IMP_algebra.GridIndex3D_show(self, *args)
8334 
8335 
8336  def __len__(self):
8337  """__len__(GridIndex3D self) -> unsigned int"""
8338  return _IMP_algebra.GridIndex3D___len__(self)
8339 
8340 
8341  def __cmp__(self, o):
8342  """__cmp__(GridIndex3D self, GridIndex3D o) -> int"""
8343  return _IMP_algebra.GridIndex3D___cmp__(self, o)
8344 
8345 
8346  def __eq__(self, o):
8347  """__eq__(GridIndex3D self, GridIndex3D o) -> bool"""
8348  return _IMP_algebra.GridIndex3D___eq__(self, o)
8349 
8350 
8351  def __ne__(self, o):
8352  """__ne__(GridIndex3D self, GridIndex3D o) -> bool"""
8353  return _IMP_algebra.GridIndex3D___ne__(self, o)
8354 
8355 
8356  def __lt__(self, o):
8357  """__lt__(GridIndex3D self, GridIndex3D o) -> bool"""
8358  return _IMP_algebra.GridIndex3D___lt__(self, o)
8359 
8360 
8361  def __gt__(self, o):
8362  """__gt__(GridIndex3D self, GridIndex3D o) -> bool"""
8363  return _IMP_algebra.GridIndex3D___gt__(self, o)
8364 
8365 
8366  def __ge__(self, o):
8367  """__ge__(GridIndex3D self, GridIndex3D o) -> bool"""
8368  return _IMP_algebra.GridIndex3D___ge__(self, o)
8369 
8370 
8371  def __le__(self, o):
8372  """__le__(GridIndex3D self, GridIndex3D o) -> bool"""
8373  return _IMP_algebra.GridIndex3D___le__(self, o)
8374 
8375 
8376  def __hash__(self):
8377  """__hash__(GridIndex3D self) -> std::size_t"""
8378  return _IMP_algebra.GridIndex3D___hash__(self)
8379 
8380 
8381  def __str__(self):
8382  """__str__(GridIndex3D self) -> std::string"""
8383  return _IMP_algebra.GridIndex3D___str__(self)
8384 
8385 
8386  def __repr__(self):
8387  """__repr__(GridIndex3D self) -> std::string"""
8388  return _IMP_algebra.GridIndex3D___repr__(self)
8389 
8390 
8391  def _get_as_binary(self):
8392  """_get_as_binary(GridIndex3D self) -> PyObject *"""
8393  return _IMP_algebra.GridIndex3D__get_as_binary(self)
8394 
8395 
8396  def _set_from_binary(self, p):
8397  """_set_from_binary(GridIndex3D self, PyObject * p)"""
8398  return _IMP_algebra.GridIndex3D__set_from_binary(self, p)
8399 
8400 
8401  def __getstate__(self):
8402  p = self._get_as_binary()
8403  if len(self.__dict__) > 1:
8404  d = self.__dict__.copy()
8405  del d['this']
8406  p = (d, p)
8407  return p
8408 
8409  def __setstate__(self, p):
8410  if not hasattr(self, 'this'):
8411  self.__init__()
8412  if isinstance(p, tuple):
8413  d, p = p
8414  self.__dict__.update(d)
8415  return self._set_from_binary(p)
8416 
8417  __swig_destroy__ = _IMP_algebra.delete_GridIndex3D
8418  __del__ = lambda self: None
8419 GridIndex3D_swigregister = _IMP_algebra.GridIndex3D_swigregister
8420 GridIndex3D_swigregister(GridIndex3D)
8421 
8422 class GridIndex4D(IMP._Value):
8423  """Proxy of C++ IMP::algebra::GridIndexD<(4)> class"""
8424  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8425 
8426  def __init__(self, *args):
8427  """
8428  __init__(IMP::algebra::GridIndexD<(4)> self) -> GridIndex4D
8429  __init__(IMP::algebra::GridIndexD<(4)> self, int x) -> GridIndex4D
8430  __init__(IMP::algebra::GridIndexD<(4)> self, int x, int y) -> GridIndex4D
8431  __init__(IMP::algebra::GridIndexD<(4)> self, int x, int y, int z) -> GridIndex4D
8432  __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l) -> GridIndex4D
8433  __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l, int m) -> GridIndex4D
8434  __init__(IMP::algebra::GridIndexD<(4)> self, int i, int j, int k, int l, int m, int n) -> GridIndex4D
8435  """
8436  this = _IMP_algebra.new_GridIndex4D(*args)
8437  try:
8438  self.this.append(this)
8439  except:
8440  self.this = this
8441 
8442  def get_dimension(self):
8443  """get_dimension(GridIndex4D self) -> unsigned int"""
8444  return _IMP_algebra.GridIndex4D_get_dimension(self)
8445 
8446 
8447  def __getitem__(self, i):
8448  """__getitem__(GridIndex4D self, unsigned int i) -> int const &"""
8449  return _IMP_algebra.GridIndex4D___getitem__(self, i)
8450 
8451 
8452  def show(self, *args):
8453  """
8454  show(GridIndex4D self, _ostream out)
8455  show(GridIndex4D self)
8456  """
8457  return _IMP_algebra.GridIndex4D_show(self, *args)
8458 
8459 
8460  def __len__(self):
8461  """__len__(GridIndex4D self) -> unsigned int"""
8462  return _IMP_algebra.GridIndex4D___len__(self)
8463 
8464 
8465  def __cmp__(self, o):
8466  """__cmp__(GridIndex4D self, GridIndex4D o) -> int"""
8467  return _IMP_algebra.GridIndex4D___cmp__(self, o)
8468 
8469 
8470  def __eq__(self, o):
8471  """__eq__(GridIndex4D self, GridIndex4D o) -> bool"""
8472  return _IMP_algebra.GridIndex4D___eq__(self, o)
8473 
8474 
8475  def __ne__(self, o):
8476  """__ne__(GridIndex4D self, GridIndex4D o) -> bool"""
8477  return _IMP_algebra.GridIndex4D___ne__(self, o)
8478 
8479 
8480  def __lt__(self, o):
8481  """__lt__(GridIndex4D self, GridIndex4D o) -> bool"""
8482  return _IMP_algebra.GridIndex4D___lt__(self, o)
8483 
8484 
8485  def __gt__(self, o):
8486  """__gt__(GridIndex4D self, GridIndex4D o) -> bool"""
8487  return _IMP_algebra.GridIndex4D___gt__(self, o)
8488 
8489 
8490  def __ge__(self, o):
8491  """__ge__(GridIndex4D self, GridIndex4D o) -> bool"""
8492  return _IMP_algebra.GridIndex4D___ge__(self, o)
8493 
8494 
8495  def __le__(self, o):
8496  """__le__(GridIndex4D self, GridIndex4D o) -> bool"""
8497  return _IMP_algebra.GridIndex4D___le__(self, o)
8498 
8499 
8500  def __hash__(self):
8501  """__hash__(GridIndex4D self) -> std::size_t"""
8502  return _IMP_algebra.GridIndex4D___hash__(self)
8503 
8504 
8505  def __str__(self):
8506  """__str__(GridIndex4D self) -> std::string"""
8507  return _IMP_algebra.GridIndex4D___str__(self)
8508 
8509 
8510  def __repr__(self):
8511  """__repr__(GridIndex4D self) -> std::string"""
8512  return _IMP_algebra.GridIndex4D___repr__(self)
8513 
8514 
8515  def _get_as_binary(self):
8516  """_get_as_binary(GridIndex4D self) -> PyObject *"""
8517  return _IMP_algebra.GridIndex4D__get_as_binary(self)
8518 
8519 
8520  def _set_from_binary(self, p):
8521  """_set_from_binary(GridIndex4D self, PyObject * p)"""
8522  return _IMP_algebra.GridIndex4D__set_from_binary(self, p)
8523 
8524 
8525  def __getstate__(self):
8526  p = self._get_as_binary()
8527  if len(self.__dict__) > 1:
8528  d = self.__dict__.copy()
8529  del d['this']
8530  p = (d, p)
8531  return p
8532 
8533  def __setstate__(self, p):
8534  if not hasattr(self, 'this'):
8535  self.__init__()
8536  if isinstance(p, tuple):
8537  d, p = p
8538  self.__dict__.update(d)
8539  return self._set_from_binary(p)
8540 
8541  __swig_destroy__ = _IMP_algebra.delete_GridIndex4D
8542  __del__ = lambda self: None
8543 GridIndex4D_swigregister = _IMP_algebra.GridIndex4D_swigregister
8544 GridIndex4D_swigregister(GridIndex4D)
8545 
8546 class GridIndex5D(IMP._Value):
8547  """Proxy of C++ IMP::algebra::GridIndexD<(5)> class"""
8548  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8549 
8550  def __init__(self, *args):
8551  """
8552  __init__(IMP::algebra::GridIndexD<(5)> self) -> GridIndex5D
8553  __init__(IMP::algebra::GridIndexD<(5)> self, int x) -> GridIndex5D
8554  __init__(IMP::algebra::GridIndexD<(5)> self, int x, int y) -> GridIndex5D
8555  __init__(IMP::algebra::GridIndexD<(5)> self, int x, int y, int z) -> GridIndex5D
8556  __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l) -> GridIndex5D
8557  __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l, int m) -> GridIndex5D
8558  __init__(IMP::algebra::GridIndexD<(5)> self, int i, int j, int k, int l, int m, int n) -> GridIndex5D
8559  """
8560  this = _IMP_algebra.new_GridIndex5D(*args)
8561  try:
8562  self.this.append(this)
8563  except:
8564  self.this = this
8565 
8566  def get_dimension(self):
8567  """get_dimension(GridIndex5D self) -> unsigned int"""
8568  return _IMP_algebra.GridIndex5D_get_dimension(self)
8569 
8570 
8571  def __getitem__(self, i):
8572  """__getitem__(GridIndex5D self, unsigned int i) -> int const &"""
8573  return _IMP_algebra.GridIndex5D___getitem__(self, i)
8574 
8575 
8576  def show(self, *args):
8577  """
8578  show(GridIndex5D self, _ostream out)
8579  show(GridIndex5D self)
8580  """
8581  return _IMP_algebra.GridIndex5D_show(self, *args)
8582 
8583 
8584  def __len__(self):
8585  """__len__(GridIndex5D self) -> unsigned int"""
8586  return _IMP_algebra.GridIndex5D___len__(self)
8587 
8588 
8589  def __cmp__(self, o):
8590  """__cmp__(GridIndex5D self, GridIndex5D o) -> int"""
8591  return _IMP_algebra.GridIndex5D___cmp__(self, o)
8592 
8593 
8594  def __eq__(self, o):
8595  """__eq__(GridIndex5D self, GridIndex5D o) -> bool"""
8596  return _IMP_algebra.GridIndex5D___eq__(self, o)
8597 
8598 
8599  def __ne__(self, o):
8600  """__ne__(GridIndex5D self, GridIndex5D o) -> bool"""
8601  return _IMP_algebra.GridIndex5D___ne__(self, o)
8602 
8603 
8604  def __lt__(self, o):
8605  """__lt__(GridIndex5D self, GridIndex5D o) -> bool"""
8606  return _IMP_algebra.GridIndex5D___lt__(self, o)
8607 
8608 
8609  def __gt__(self, o):
8610  """__gt__(GridIndex5D self, GridIndex5D o) -> bool"""
8611  return _IMP_algebra.GridIndex5D___gt__(self, o)
8612 
8613 
8614  def __ge__(self, o):
8615  """__ge__(GridIndex5D self, GridIndex5D o) -> bool"""
8616  return _IMP_algebra.GridIndex5D___ge__(self, o)
8617 
8618 
8619  def __le__(self, o):
8620  """__le__(GridIndex5D self, GridIndex5D o) -> bool"""
8621  return _IMP_algebra.GridIndex5D___le__(self, o)
8622 
8623 
8624  def __hash__(self):
8625  """__hash__(GridIndex5D self) -> std::size_t"""
8626  return _IMP_algebra.GridIndex5D___hash__(self)
8627 
8628 
8629  def __str__(self):
8630  """__str__(GridIndex5D self) -> std::string"""
8631  return _IMP_algebra.GridIndex5D___str__(self)
8632 
8633 
8634  def __repr__(self):
8635  """__repr__(GridIndex5D self) -> std::string"""
8636  return _IMP_algebra.GridIndex5D___repr__(self)
8637 
8638 
8639  def _get_as_binary(self):
8640  """_get_as_binary(GridIndex5D self) -> PyObject *"""
8641  return _IMP_algebra.GridIndex5D__get_as_binary(self)
8642 
8643 
8644  def _set_from_binary(self, p):
8645  """_set_from_binary(GridIndex5D self, PyObject * p)"""
8646  return _IMP_algebra.GridIndex5D__set_from_binary(self, p)
8647 
8648 
8649  def __getstate__(self):
8650  p = self._get_as_binary()
8651  if len(self.__dict__) > 1:
8652  d = self.__dict__.copy()
8653  del d['this']
8654  p = (d, p)
8655  return p
8656 
8657  def __setstate__(self, p):
8658  if not hasattr(self, 'this'):
8659  self.__init__()
8660  if isinstance(p, tuple):
8661  d, p = p
8662  self.__dict__.update(d)
8663  return self._set_from_binary(p)
8664 
8665  __swig_destroy__ = _IMP_algebra.delete_GridIndex5D
8666  __del__ = lambda self: None
8667 GridIndex5D_swigregister = _IMP_algebra.GridIndex5D_swigregister
8668 GridIndex5D_swigregister(GridIndex5D)
8669 
8670 class GridIndex6D(IMP._Value):
8671  """Proxy of C++ IMP::algebra::GridIndexD<(6)> class"""
8672  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8673 
8674  def __init__(self, *args):
8675  """
8676  __init__(IMP::algebra::GridIndexD<(6)> self) -> GridIndex6D
8677  __init__(IMP::algebra::GridIndexD<(6)> self, int x) -> GridIndex6D
8678  __init__(IMP::algebra::GridIndexD<(6)> self, int x, int y) -> GridIndex6D
8679  __init__(IMP::algebra::GridIndexD<(6)> self, int x, int y, int z) -> GridIndex6D
8680  __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l) -> GridIndex6D
8681  __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l, int m) -> GridIndex6D
8682  __init__(IMP::algebra::GridIndexD<(6)> self, int i, int j, int k, int l, int m, int n) -> GridIndex6D
8683  """
8684  this = _IMP_algebra.new_GridIndex6D(*args)
8685  try:
8686  self.this.append(this)
8687  except:
8688  self.this = this
8689 
8690  def get_dimension(self):
8691  """get_dimension(GridIndex6D self) -> unsigned int"""
8692  return _IMP_algebra.GridIndex6D_get_dimension(self)
8693 
8694 
8695  def __getitem__(self, i):
8696  """__getitem__(GridIndex6D self, unsigned int i) -> int const &"""
8697  return _IMP_algebra.GridIndex6D___getitem__(self, i)
8698 
8699 
8700  def show(self, *args):
8701  """
8702  show(GridIndex6D self, _ostream out)
8703  show(GridIndex6D self)
8704  """
8705  return _IMP_algebra.GridIndex6D_show(self, *args)
8706 
8707 
8708  def __len__(self):
8709  """__len__(GridIndex6D self) -> unsigned int"""
8710  return _IMP_algebra.GridIndex6D___len__(self)
8711 
8712 
8713  def __cmp__(self, o):
8714  """__cmp__(GridIndex6D self, GridIndex6D o) -> int"""
8715  return _IMP_algebra.GridIndex6D___cmp__(self, o)
8716 
8717 
8718  def __eq__(self, o):
8719  """__eq__(GridIndex6D self, GridIndex6D o) -> bool"""
8720  return _IMP_algebra.GridIndex6D___eq__(self, o)
8721 
8722 
8723  def __ne__(self, o):
8724  """__ne__(GridIndex6D self, GridIndex6D o) -> bool"""
8725  return _IMP_algebra.GridIndex6D___ne__(self, o)
8726 
8727 
8728  def __lt__(self, o):
8729  """__lt__(GridIndex6D self, GridIndex6D o) -> bool"""
8730  return _IMP_algebra.GridIndex6D___lt__(self, o)
8731 
8732 
8733  def __gt__(self, o):
8734  """__gt__(GridIndex6D self, GridIndex6D o) -> bool"""
8735  return _IMP_algebra.GridIndex6D___gt__(self, o)
8736 
8737 
8738  def __ge__(self, o):
8739  """__ge__(GridIndex6D self, GridIndex6D o) -> bool"""
8740  return _IMP_algebra.GridIndex6D___ge__(self, o)
8741 
8742 
8743  def __le__(self, o):
8744  """__le__(GridIndex6D self, GridIndex6D o) -> bool"""
8745  return _IMP_algebra.GridIndex6D___le__(self, o)
8746 
8747 
8748  def __hash__(self):
8749  """__hash__(GridIndex6D self) -> std::size_t"""
8750  return _IMP_algebra.GridIndex6D___hash__(self)
8751 
8752 
8753  def __str__(self):
8754  """__str__(GridIndex6D self) -> std::string"""
8755  return _IMP_algebra.GridIndex6D___str__(self)
8756 
8757 
8758  def __repr__(self):
8759  """__repr__(GridIndex6D self) -> std::string"""
8760  return _IMP_algebra.GridIndex6D___repr__(self)
8761 
8762 
8763  def _get_as_binary(self):
8764  """_get_as_binary(GridIndex6D self) -> PyObject *"""
8765  return _IMP_algebra.GridIndex6D__get_as_binary(self)
8766 
8767 
8768  def _set_from_binary(self, p):
8769  """_set_from_binary(GridIndex6D self, PyObject * p)"""
8770  return _IMP_algebra.GridIndex6D__set_from_binary(self, p)
8771 
8772 
8773  def __getstate__(self):
8774  p = self._get_as_binary()
8775  if len(self.__dict__) > 1:
8776  d = self.__dict__.copy()
8777  del d['this']
8778  p = (d, p)
8779  return p
8780 
8781  def __setstate__(self, p):
8782  if not hasattr(self, 'this'):
8783  self.__init__()
8784  if isinstance(p, tuple):
8785  d, p = p
8786  self.__dict__.update(d)
8787  return self._set_from_binary(p)
8788 
8789  __swig_destroy__ = _IMP_algebra.delete_GridIndex6D
8790  __del__ = lambda self: None
8791 GridIndex6D_swigregister = _IMP_algebra.GridIndex6D_swigregister
8792 GridIndex6D_swigregister(GridIndex6D)
8793 
8794 class GridIndexKD(IMP._Value):
8795  """Proxy of C++ IMP::algebra::GridIndexD<(-1)> class"""
8796  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8797 
8798  def __init__(self, *args):
8799  """
8800  __init__(IMP::algebra::GridIndexD<(-1)> self) -> GridIndexKD
8801  __init__(IMP::algebra::GridIndexD<(-1)> self, int x) -> GridIndexKD
8802  __init__(IMP::algebra::GridIndexD<(-1)> self, int x, int y) -> GridIndexKD
8803  __init__(IMP::algebra::GridIndexD<(-1)> self, int x, int y, int z) -> GridIndexKD
8804  __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l) -> GridIndexKD
8805  __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l, int m) -> GridIndexKD
8806  __init__(IMP::algebra::GridIndexD<(-1)> self, int i, int j, int k, int l, int m, int n) -> GridIndexKD
8807  """
8808  this = _IMP_algebra.new_GridIndexKD(*args)
8809  try:
8810  self.this.append(this)
8811  except:
8812  self.this = this
8813 
8814  def get_dimension(self):
8815  """get_dimension(GridIndexKD self) -> unsigned int"""
8816  return _IMP_algebra.GridIndexKD_get_dimension(self)
8817 
8818 
8819  def __getitem__(self, i):
8820  """__getitem__(GridIndexKD self, unsigned int i) -> int const &"""
8821  return _IMP_algebra.GridIndexKD___getitem__(self, i)
8822 
8823 
8824  def show(self, *args):
8825  """
8826  show(GridIndexKD self, _ostream out)
8827  show(GridIndexKD self)
8828  """
8829  return _IMP_algebra.GridIndexKD_show(self, *args)
8830 
8831 
8832  def __len__(self):
8833  """__len__(GridIndexKD self) -> unsigned int"""
8834  return _IMP_algebra.GridIndexKD___len__(self)
8835 
8836 
8837  def __cmp__(self, o):
8838  """__cmp__(GridIndexKD self, GridIndexKD o) -> int"""
8839  return _IMP_algebra.GridIndexKD___cmp__(self, o)
8840 
8841 
8842  def __eq__(self, o):
8843  """__eq__(GridIndexKD self, GridIndexKD o) -> bool"""
8844  return _IMP_algebra.GridIndexKD___eq__(self, o)
8845 
8846 
8847  def __ne__(self, o):
8848  """__ne__(GridIndexKD self, GridIndexKD o) -> bool"""
8849  return _IMP_algebra.GridIndexKD___ne__(self, o)
8850 
8851 
8852  def __lt__(self, o):
8853  """__lt__(GridIndexKD self, GridIndexKD o) -> bool"""
8854  return _IMP_algebra.GridIndexKD___lt__(self, o)
8855 
8856 
8857  def __gt__(self, o):
8858  """__gt__(GridIndexKD self, GridIndexKD o) -> bool"""
8859  return _IMP_algebra.GridIndexKD___gt__(self, o)
8860 
8861 
8862  def __ge__(self, o):
8863  """__ge__(GridIndexKD self, GridIndexKD o) -> bool"""
8864  return _IMP_algebra.GridIndexKD___ge__(self, o)
8865 
8866 
8867  def __le__(self, o):
8868  """__le__(GridIndexKD self, GridIndexKD o) -> bool"""
8869  return _IMP_algebra.GridIndexKD___le__(self, o)
8870 
8871 
8872  def __hash__(self):
8873  """__hash__(GridIndexKD self) -> std::size_t"""
8874  return _IMP_algebra.GridIndexKD___hash__(self)
8875 
8876 
8877  def __str__(self):
8878  """__str__(GridIndexKD self) -> std::string"""
8879  return _IMP_algebra.GridIndexKD___str__(self)
8880 
8881 
8882  def __repr__(self):
8883  """__repr__(GridIndexKD self) -> std::string"""
8884  return _IMP_algebra.GridIndexKD___repr__(self)
8885 
8886 
8887  def _get_as_binary(self):
8888  """_get_as_binary(GridIndexKD self) -> PyObject *"""
8889  return _IMP_algebra.GridIndexKD__get_as_binary(self)
8890 
8891 
8892  def _set_from_binary(self, p):
8893  """_set_from_binary(GridIndexKD self, PyObject * p)"""
8894  return _IMP_algebra.GridIndexKD__set_from_binary(self, p)
8895 
8896 
8897  def __getstate__(self):
8898  p = self._get_as_binary()
8899  if len(self.__dict__) > 1:
8900  d = self.__dict__.copy()
8901  del d['this']
8902  p = (d, p)
8903  return p
8904 
8905  def __setstate__(self, p):
8906  if not hasattr(self, 'this'):
8907  self.__init__()
8908  if isinstance(p, tuple):
8909  d, p = p
8910  self.__dict__.update(d)
8911  return self._set_from_binary(p)
8912 
8913  __swig_destroy__ = _IMP_algebra.delete_GridIndexKD
8914  __del__ = lambda self: None
8915 GridIndexKD_swigregister = _IMP_algebra.GridIndexKD_swigregister
8916 GridIndexKD_swigregister(GridIndexKD)
8917 
8918 class ExtendedGridIndex1D(IMP._Value):
8919  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(1)> class"""
8920  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
8921 
8922  def __init__(self, *args):
8923  """
8924  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, IMP::Ints vals) -> ExtendedGridIndex1D
8925  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x) -> ExtendedGridIndex1D
8926  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x, int y) -> ExtendedGridIndex1D
8927  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int x, int y, int z) -> ExtendedGridIndex1D
8928  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l) -> ExtendedGridIndex1D
8929  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex1D
8930  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex1D
8931  __init__(IMP::algebra::ExtendedGridIndexD<(1)> self) -> ExtendedGridIndex1D
8932  """
8933  this = _IMP_algebra.new_ExtendedGridIndex1D(*args)
8934  try:
8935  self.this.append(this)
8936  except:
8937  self.this = this
8938 
8939  def get_dimension(self):
8940  """get_dimension(ExtendedGridIndex1D self) -> unsigned int"""
8941  return _IMP_algebra.ExtendedGridIndex1D_get_dimension(self)
8942 
8943 
8944  def __cmp__(self, o):
8945  """__cmp__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> int"""
8946  return _IMP_algebra.ExtendedGridIndex1D___cmp__(self, o)
8947 
8948 
8949  def __eq__(self, o):
8950  """__eq__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8951  return _IMP_algebra.ExtendedGridIndex1D___eq__(self, o)
8952 
8953 
8954  def __ne__(self, o):
8955  """__ne__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8956  return _IMP_algebra.ExtendedGridIndex1D___ne__(self, o)
8957 
8958 
8959  def __lt__(self, o):
8960  """__lt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8961  return _IMP_algebra.ExtendedGridIndex1D___lt__(self, o)
8962 
8963 
8964  def __gt__(self, o):
8965  """__gt__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8966  return _IMP_algebra.ExtendedGridIndex1D___gt__(self, o)
8967 
8968 
8969  def __ge__(self, o):
8970  """__ge__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8971  return _IMP_algebra.ExtendedGridIndex1D___ge__(self, o)
8972 
8973 
8974  def __le__(self, o):
8975  """__le__(ExtendedGridIndex1D self, ExtendedGridIndex1D o) -> bool"""
8976  return _IMP_algebra.ExtendedGridIndex1D___le__(self, o)
8977 
8978 
8979  def __setitem__(self, i, v):
8980  """__setitem__(ExtendedGridIndex1D self, unsigned int i, int const & v)"""
8981  return _IMP_algebra.ExtendedGridIndex1D___setitem__(self, i, v)
8982 
8983 
8984  def __getitem__(self, i):
8985  """__getitem__(ExtendedGridIndex1D self, unsigned int i) -> int const &"""
8986  return _IMP_algebra.ExtendedGridIndex1D___getitem__(self, i)
8987 
8988 
8989  def show(self, *args):
8990  """
8991  show(ExtendedGridIndex1D self, _ostream out)
8992  show(ExtendedGridIndex1D self)
8993  """
8994  return _IMP_algebra.ExtendedGridIndex1D_show(self, *args)
8995 
8996 
8997  def __len__(self):
8998  """__len__(ExtendedGridIndex1D self) -> unsigned int"""
8999  return _IMP_algebra.ExtendedGridIndex1D___len__(self)
9000 
9001 
9002  def __hash__(self):
9003  """__hash__(ExtendedGridIndex1D self) -> std::size_t"""
9004  return _IMP_algebra.ExtendedGridIndex1D___hash__(self)
9005 
9006 
9007  def get_uniform_offset(self, ii):
9008  """get_uniform_offset(ExtendedGridIndex1D self, int ii) -> ExtendedGridIndex1D"""
9009  return _IMP_algebra.ExtendedGridIndex1D_get_uniform_offset(self, ii)
9010 
9011 
9012  def get_offset(self, i, j, k):
9013  """get_offset(ExtendedGridIndex1D self, int i, int j, int k) -> ExtendedGridIndex1D"""
9014  return _IMP_algebra.ExtendedGridIndex1D_get_offset(self, i, j, k)
9015 
9016 
9017  def __str__(self):
9018  """__str__(ExtendedGridIndex1D self) -> std::string"""
9019  return _IMP_algebra.ExtendedGridIndex1D___str__(self)
9020 
9021 
9022  def __repr__(self):
9023  """__repr__(ExtendedGridIndex1D self) -> std::string"""
9024  return _IMP_algebra.ExtendedGridIndex1D___repr__(self)
9025 
9026 
9027  def _get_as_binary(self):
9028  """_get_as_binary(ExtendedGridIndex1D self) -> PyObject *"""
9029  return _IMP_algebra.ExtendedGridIndex1D__get_as_binary(self)
9030 
9031 
9032  def _set_from_binary(self, p):
9033  """_set_from_binary(ExtendedGridIndex1D self, PyObject * p)"""
9034  return _IMP_algebra.ExtendedGridIndex1D__set_from_binary(self, p)
9035 
9036 
9037  def __getstate__(self):
9038  p = self._get_as_binary()
9039  if len(self.__dict__) > 1:
9040  d = self.__dict__.copy()
9041  del d['this']
9042  p = (d, p)
9043  return p
9044 
9045  def __setstate__(self, p):
9046  if not hasattr(self, 'this'):
9047  self.__init__()
9048  if isinstance(p, tuple):
9049  d, p = p
9050  self.__dict__.update(d)
9051  return self._set_from_binary(p)
9052 
9053  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex1D
9054  __del__ = lambda self: None
9055 ExtendedGridIndex1D_swigregister = _IMP_algebra.ExtendedGridIndex1D_swigregister
9056 ExtendedGridIndex1D_swigregister(ExtendedGridIndex1D)
9057 
9058 class ExtendedGridIndex2D(IMP._Value):
9059  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(2)> class"""
9060  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9061 
9062  def __init__(self, *args):
9063  """
9064  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, IMP::Ints vals) -> ExtendedGridIndex2D
9065  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x) -> ExtendedGridIndex2D
9066  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x, int y) -> ExtendedGridIndex2D
9067  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int x, int y, int z) -> ExtendedGridIndex2D
9068  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l) -> ExtendedGridIndex2D
9069  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex2D
9070  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex2D
9071  __init__(IMP::algebra::ExtendedGridIndexD<(2)> self) -> ExtendedGridIndex2D
9072  """
9073  this = _IMP_algebra.new_ExtendedGridIndex2D(*args)
9074  try:
9075  self.this.append(this)
9076  except:
9077  self.this = this
9078 
9079  def get_dimension(self):
9080  """get_dimension(ExtendedGridIndex2D self) -> unsigned int"""
9081  return _IMP_algebra.ExtendedGridIndex2D_get_dimension(self)
9082 
9083 
9084  def __cmp__(self, o):
9085  """__cmp__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> int"""
9086  return _IMP_algebra.ExtendedGridIndex2D___cmp__(self, o)
9087 
9088 
9089  def __eq__(self, o):
9090  """__eq__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9091  return _IMP_algebra.ExtendedGridIndex2D___eq__(self, o)
9092 
9093 
9094  def __ne__(self, o):
9095  """__ne__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9096  return _IMP_algebra.ExtendedGridIndex2D___ne__(self, o)
9097 
9098 
9099  def __lt__(self, o):
9100  """__lt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9101  return _IMP_algebra.ExtendedGridIndex2D___lt__(self, o)
9102 
9103 
9104  def __gt__(self, o):
9105  """__gt__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9106  return _IMP_algebra.ExtendedGridIndex2D___gt__(self, o)
9107 
9108 
9109  def __ge__(self, o):
9110  """__ge__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9111  return _IMP_algebra.ExtendedGridIndex2D___ge__(self, o)
9112 
9113 
9114  def __le__(self, o):
9115  """__le__(ExtendedGridIndex2D self, ExtendedGridIndex2D o) -> bool"""
9116  return _IMP_algebra.ExtendedGridIndex2D___le__(self, o)
9117 
9118 
9119  def __setitem__(self, i, v):
9120  """__setitem__(ExtendedGridIndex2D self, unsigned int i, int const & v)"""
9121  return _IMP_algebra.ExtendedGridIndex2D___setitem__(self, i, v)
9122 
9123 
9124  def __getitem__(self, i):
9125  """__getitem__(ExtendedGridIndex2D self, unsigned int i) -> int const &"""
9126  return _IMP_algebra.ExtendedGridIndex2D___getitem__(self, i)
9127 
9128 
9129  def show(self, *args):
9130  """
9131  show(ExtendedGridIndex2D self, _ostream out)
9132  show(ExtendedGridIndex2D self)
9133  """
9134  return _IMP_algebra.ExtendedGridIndex2D_show(self, *args)
9135 
9136 
9137  def __len__(self):
9138  """__len__(ExtendedGridIndex2D self) -> unsigned int"""
9139  return _IMP_algebra.ExtendedGridIndex2D___len__(self)
9140 
9141 
9142  def __hash__(self):
9143  """__hash__(ExtendedGridIndex2D self) -> std::size_t"""
9144  return _IMP_algebra.ExtendedGridIndex2D___hash__(self)
9145 
9146 
9147  def get_uniform_offset(self, ii):
9148  """get_uniform_offset(ExtendedGridIndex2D self, int ii) -> ExtendedGridIndex2D"""
9149  return _IMP_algebra.ExtendedGridIndex2D_get_uniform_offset(self, ii)
9150 
9151 
9152  def get_offset(self, i, j, k):
9153  """get_offset(ExtendedGridIndex2D self, int i, int j, int k) -> ExtendedGridIndex2D"""
9154  return _IMP_algebra.ExtendedGridIndex2D_get_offset(self, i, j, k)
9155 
9156 
9157  def __str__(self):
9158  """__str__(ExtendedGridIndex2D self) -> std::string"""
9159  return _IMP_algebra.ExtendedGridIndex2D___str__(self)
9160 
9161 
9162  def __repr__(self):
9163  """__repr__(ExtendedGridIndex2D self) -> std::string"""
9164  return _IMP_algebra.ExtendedGridIndex2D___repr__(self)
9165 
9166 
9167  def _get_as_binary(self):
9168  """_get_as_binary(ExtendedGridIndex2D self) -> PyObject *"""
9169  return _IMP_algebra.ExtendedGridIndex2D__get_as_binary(self)
9170 
9171 
9172  def _set_from_binary(self, p):
9173  """_set_from_binary(ExtendedGridIndex2D self, PyObject * p)"""
9174  return _IMP_algebra.ExtendedGridIndex2D__set_from_binary(self, p)
9175 
9176 
9177  def __getstate__(self):
9178  p = self._get_as_binary()
9179  if len(self.__dict__) > 1:
9180  d = self.__dict__.copy()
9181  del d['this']
9182  p = (d, p)
9183  return p
9184 
9185  def __setstate__(self, p):
9186  if not hasattr(self, 'this'):
9187  self.__init__()
9188  if isinstance(p, tuple):
9189  d, p = p
9190  self.__dict__.update(d)
9191  return self._set_from_binary(p)
9192 
9193  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex2D
9194  __del__ = lambda self: None
9195 ExtendedGridIndex2D_swigregister = _IMP_algebra.ExtendedGridIndex2D_swigregister
9196 ExtendedGridIndex2D_swigregister(ExtendedGridIndex2D)
9197 
9198 class ExtendedGridIndex3D(IMP._Value):
9199  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(3)> class"""
9200  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9201 
9202  def __init__(self, *args):
9203  """
9204  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, IMP::Ints vals) -> ExtendedGridIndex3D
9205  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x) -> ExtendedGridIndex3D
9206  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x, int y) -> ExtendedGridIndex3D
9207  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int x, int y, int z) -> ExtendedGridIndex3D
9208  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l) -> ExtendedGridIndex3D
9209  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex3D
9210  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex3D
9211  __init__(IMP::algebra::ExtendedGridIndexD<(3)> self) -> ExtendedGridIndex3D
9212  """
9213  this = _IMP_algebra.new_ExtendedGridIndex3D(*args)
9214  try:
9215  self.this.append(this)
9216  except:
9217  self.this = this
9218 
9219  def get_dimension(self):
9220  """get_dimension(ExtendedGridIndex3D self) -> unsigned int"""
9221  return _IMP_algebra.ExtendedGridIndex3D_get_dimension(self)
9222 
9223 
9224  def __cmp__(self, o):
9225  """__cmp__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> int"""
9226  return _IMP_algebra.ExtendedGridIndex3D___cmp__(self, o)
9227 
9228 
9229  def __eq__(self, o):
9230  """__eq__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9231  return _IMP_algebra.ExtendedGridIndex3D___eq__(self, o)
9232 
9233 
9234  def __ne__(self, o):
9235  """__ne__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9236  return _IMP_algebra.ExtendedGridIndex3D___ne__(self, o)
9237 
9238 
9239  def __lt__(self, o):
9240  """__lt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9241  return _IMP_algebra.ExtendedGridIndex3D___lt__(self, o)
9242 
9243 
9244  def __gt__(self, o):
9245  """__gt__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9246  return _IMP_algebra.ExtendedGridIndex3D___gt__(self, o)
9247 
9248 
9249  def __ge__(self, o):
9250  """__ge__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9251  return _IMP_algebra.ExtendedGridIndex3D___ge__(self, o)
9252 
9253 
9254  def __le__(self, o):
9255  """__le__(ExtendedGridIndex3D self, ExtendedGridIndex3D o) -> bool"""
9256  return _IMP_algebra.ExtendedGridIndex3D___le__(self, o)
9257 
9258 
9259  def __setitem__(self, i, v):
9260  """__setitem__(ExtendedGridIndex3D self, unsigned int i, int const & v)"""
9261  return _IMP_algebra.ExtendedGridIndex3D___setitem__(self, i, v)
9262 
9263 
9264  def __getitem__(self, i):
9265  """__getitem__(ExtendedGridIndex3D self, unsigned int i) -> int const &"""
9266  return _IMP_algebra.ExtendedGridIndex3D___getitem__(self, i)
9267 
9268 
9269  def show(self, *args):
9270  """
9271  show(ExtendedGridIndex3D self, _ostream out)
9272  show(ExtendedGridIndex3D self)
9273  """
9274  return _IMP_algebra.ExtendedGridIndex3D_show(self, *args)
9275 
9276 
9277  def __len__(self):
9278  """__len__(ExtendedGridIndex3D self) -> unsigned int"""
9279  return _IMP_algebra.ExtendedGridIndex3D___len__(self)
9280 
9281 
9282  def __hash__(self):
9283  """__hash__(ExtendedGridIndex3D self) -> std::size_t"""
9284  return _IMP_algebra.ExtendedGridIndex3D___hash__(self)
9285 
9286 
9287  def get_uniform_offset(self, ii):
9288  """get_uniform_offset(ExtendedGridIndex3D self, int ii) -> ExtendedGridIndex3D"""
9289  return _IMP_algebra.ExtendedGridIndex3D_get_uniform_offset(self, ii)
9290 
9291 
9292  def get_offset(self, i, j, k):
9293  """get_offset(ExtendedGridIndex3D self, int i, int j, int k) -> ExtendedGridIndex3D"""
9294  return _IMP_algebra.ExtendedGridIndex3D_get_offset(self, i, j, k)
9295 
9296 
9297  def __str__(self):
9298  """__str__(ExtendedGridIndex3D self) -> std::string"""
9299  return _IMP_algebra.ExtendedGridIndex3D___str__(self)
9300 
9301 
9302  def __repr__(self):
9303  """__repr__(ExtendedGridIndex3D self) -> std::string"""
9304  return _IMP_algebra.ExtendedGridIndex3D___repr__(self)
9305 
9306 
9307  def _get_as_binary(self):
9308  """_get_as_binary(ExtendedGridIndex3D self) -> PyObject *"""
9309  return _IMP_algebra.ExtendedGridIndex3D__get_as_binary(self)
9310 
9311 
9312  def _set_from_binary(self, p):
9313  """_set_from_binary(ExtendedGridIndex3D self, PyObject * p)"""
9314  return _IMP_algebra.ExtendedGridIndex3D__set_from_binary(self, p)
9315 
9316 
9317  def __getstate__(self):
9318  p = self._get_as_binary()
9319  if len(self.__dict__) > 1:
9320  d = self.__dict__.copy()
9321  del d['this']
9322  p = (d, p)
9323  return p
9324 
9325  def __setstate__(self, p):
9326  if not hasattr(self, 'this'):
9327  self.__init__()
9328  if isinstance(p, tuple):
9329  d, p = p
9330  self.__dict__.update(d)
9331  return self._set_from_binary(p)
9332 
9333  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex3D
9334  __del__ = lambda self: None
9335 ExtendedGridIndex3D_swigregister = _IMP_algebra.ExtendedGridIndex3D_swigregister
9336 ExtendedGridIndex3D_swigregister(ExtendedGridIndex3D)
9337 
9338 class ExtendedGridIndex4D(IMP._Value):
9339  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(4)> class"""
9340  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9341 
9342  def __init__(self, *args):
9343  """
9344  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, IMP::Ints vals) -> ExtendedGridIndex4D
9345  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x) -> ExtendedGridIndex4D
9346  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x, int y) -> ExtendedGridIndex4D
9347  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int x, int y, int z) -> ExtendedGridIndex4D
9348  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l) -> ExtendedGridIndex4D
9349  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex4D
9350  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex4D
9351  __init__(IMP::algebra::ExtendedGridIndexD<(4)> self) -> ExtendedGridIndex4D
9352  """
9353  this = _IMP_algebra.new_ExtendedGridIndex4D(*args)
9354  try:
9355  self.this.append(this)
9356  except:
9357  self.this = this
9358 
9359  def get_dimension(self):
9360  """get_dimension(ExtendedGridIndex4D self) -> unsigned int"""
9361  return _IMP_algebra.ExtendedGridIndex4D_get_dimension(self)
9362 
9363 
9364  def __cmp__(self, o):
9365  """__cmp__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> int"""
9366  return _IMP_algebra.ExtendedGridIndex4D___cmp__(self, o)
9367 
9368 
9369  def __eq__(self, o):
9370  """__eq__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9371  return _IMP_algebra.ExtendedGridIndex4D___eq__(self, o)
9372 
9373 
9374  def __ne__(self, o):
9375  """__ne__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9376  return _IMP_algebra.ExtendedGridIndex4D___ne__(self, o)
9377 
9378 
9379  def __lt__(self, o):
9380  """__lt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9381  return _IMP_algebra.ExtendedGridIndex4D___lt__(self, o)
9382 
9383 
9384  def __gt__(self, o):
9385  """__gt__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9386  return _IMP_algebra.ExtendedGridIndex4D___gt__(self, o)
9387 
9388 
9389  def __ge__(self, o):
9390  """__ge__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9391  return _IMP_algebra.ExtendedGridIndex4D___ge__(self, o)
9392 
9393 
9394  def __le__(self, o):
9395  """__le__(ExtendedGridIndex4D self, ExtendedGridIndex4D o) -> bool"""
9396  return _IMP_algebra.ExtendedGridIndex4D___le__(self, o)
9397 
9398 
9399  def __setitem__(self, i, v):
9400  """__setitem__(ExtendedGridIndex4D self, unsigned int i, int const & v)"""
9401  return _IMP_algebra.ExtendedGridIndex4D___setitem__(self, i, v)
9402 
9403 
9404  def __getitem__(self, i):
9405  """__getitem__(ExtendedGridIndex4D self, unsigned int i) -> int const &"""
9406  return _IMP_algebra.ExtendedGridIndex4D___getitem__(self, i)
9407 
9408 
9409  def show(self, *args):
9410  """
9411  show(ExtendedGridIndex4D self, _ostream out)
9412  show(ExtendedGridIndex4D self)
9413  """
9414  return _IMP_algebra.ExtendedGridIndex4D_show(self, *args)
9415 
9416 
9417  def __len__(self):
9418  """__len__(ExtendedGridIndex4D self) -> unsigned int"""
9419  return _IMP_algebra.ExtendedGridIndex4D___len__(self)
9420 
9421 
9422  def __hash__(self):
9423  """__hash__(ExtendedGridIndex4D self) -> std::size_t"""
9424  return _IMP_algebra.ExtendedGridIndex4D___hash__(self)
9425 
9426 
9427  def get_uniform_offset(self, ii):
9428  """get_uniform_offset(ExtendedGridIndex4D self, int ii) -> ExtendedGridIndex4D"""
9429  return _IMP_algebra.ExtendedGridIndex4D_get_uniform_offset(self, ii)
9430 
9431 
9432  def get_offset(self, i, j, k):
9433  """get_offset(ExtendedGridIndex4D self, int i, int j, int k) -> ExtendedGridIndex4D"""
9434  return _IMP_algebra.ExtendedGridIndex4D_get_offset(self, i, j, k)
9435 
9436 
9437  def __str__(self):
9438  """__str__(ExtendedGridIndex4D self) -> std::string"""
9439  return _IMP_algebra.ExtendedGridIndex4D___str__(self)
9440 
9441 
9442  def __repr__(self):
9443  """__repr__(ExtendedGridIndex4D self) -> std::string"""
9444  return _IMP_algebra.ExtendedGridIndex4D___repr__(self)
9445 
9446 
9447  def _get_as_binary(self):
9448  """_get_as_binary(ExtendedGridIndex4D self) -> PyObject *"""
9449  return _IMP_algebra.ExtendedGridIndex4D__get_as_binary(self)
9450 
9451 
9452  def _set_from_binary(self, p):
9453  """_set_from_binary(ExtendedGridIndex4D self, PyObject * p)"""
9454  return _IMP_algebra.ExtendedGridIndex4D__set_from_binary(self, p)
9455 
9456 
9457  def __getstate__(self):
9458  p = self._get_as_binary()
9459  if len(self.__dict__) > 1:
9460  d = self.__dict__.copy()
9461  del d['this']
9462  p = (d, p)
9463  return p
9464 
9465  def __setstate__(self, p):
9466  if not hasattr(self, 'this'):
9467  self.__init__()
9468  if isinstance(p, tuple):
9469  d, p = p
9470  self.__dict__.update(d)
9471  return self._set_from_binary(p)
9472 
9473  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex4D
9474  __del__ = lambda self: None
9475 ExtendedGridIndex4D_swigregister = _IMP_algebra.ExtendedGridIndex4D_swigregister
9476 ExtendedGridIndex4D_swigregister(ExtendedGridIndex4D)
9477 
9478 class ExtendedGridIndex5D(IMP._Value):
9479  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(5)> class"""
9480  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9481 
9482  def __init__(self, *args):
9483  """
9484  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, IMP::Ints vals) -> ExtendedGridIndex5D
9485  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x) -> ExtendedGridIndex5D
9486  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x, int y) -> ExtendedGridIndex5D
9487  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int x, int y, int z) -> ExtendedGridIndex5D
9488  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l) -> ExtendedGridIndex5D
9489  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex5D
9490  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex5D
9491  __init__(IMP::algebra::ExtendedGridIndexD<(5)> self) -> ExtendedGridIndex5D
9492  """
9493  this = _IMP_algebra.new_ExtendedGridIndex5D(*args)
9494  try:
9495  self.this.append(this)
9496  except:
9497  self.this = this
9498 
9499  def get_dimension(self):
9500  """get_dimension(ExtendedGridIndex5D self) -> unsigned int"""
9501  return _IMP_algebra.ExtendedGridIndex5D_get_dimension(self)
9502 
9503 
9504  def __cmp__(self, o):
9505  """__cmp__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> int"""
9506  return _IMP_algebra.ExtendedGridIndex5D___cmp__(self, o)
9507 
9508 
9509  def __eq__(self, o):
9510  """__eq__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9511  return _IMP_algebra.ExtendedGridIndex5D___eq__(self, o)
9512 
9513 
9514  def __ne__(self, o):
9515  """__ne__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9516  return _IMP_algebra.ExtendedGridIndex5D___ne__(self, o)
9517 
9518 
9519  def __lt__(self, o):
9520  """__lt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9521  return _IMP_algebra.ExtendedGridIndex5D___lt__(self, o)
9522 
9523 
9524  def __gt__(self, o):
9525  """__gt__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9526  return _IMP_algebra.ExtendedGridIndex5D___gt__(self, o)
9527 
9528 
9529  def __ge__(self, o):
9530  """__ge__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9531  return _IMP_algebra.ExtendedGridIndex5D___ge__(self, o)
9532 
9533 
9534  def __le__(self, o):
9535  """__le__(ExtendedGridIndex5D self, ExtendedGridIndex5D o) -> bool"""
9536  return _IMP_algebra.ExtendedGridIndex5D___le__(self, o)
9537 
9538 
9539  def __setitem__(self, i, v):
9540  """__setitem__(ExtendedGridIndex5D self, unsigned int i, int const & v)"""
9541  return _IMP_algebra.ExtendedGridIndex5D___setitem__(self, i, v)
9542 
9543 
9544  def __getitem__(self, i):
9545  """__getitem__(ExtendedGridIndex5D self, unsigned int i) -> int const &"""
9546  return _IMP_algebra.ExtendedGridIndex5D___getitem__(self, i)
9547 
9548 
9549  def show(self, *args):
9550  """
9551  show(ExtendedGridIndex5D self, _ostream out)
9552  show(ExtendedGridIndex5D self)
9553  """
9554  return _IMP_algebra.ExtendedGridIndex5D_show(self, *args)
9555 
9556 
9557  def __len__(self):
9558  """__len__(ExtendedGridIndex5D self) -> unsigned int"""
9559  return _IMP_algebra.ExtendedGridIndex5D___len__(self)
9560 
9561 
9562  def __hash__(self):
9563  """__hash__(ExtendedGridIndex5D self) -> std::size_t"""
9564  return _IMP_algebra.ExtendedGridIndex5D___hash__(self)
9565 
9566 
9567  def get_uniform_offset(self, ii):
9568  """get_uniform_offset(ExtendedGridIndex5D self, int ii) -> ExtendedGridIndex5D"""
9569  return _IMP_algebra.ExtendedGridIndex5D_get_uniform_offset(self, ii)
9570 
9571 
9572  def get_offset(self, i, j, k):
9573  """get_offset(ExtendedGridIndex5D self, int i, int j, int k) -> ExtendedGridIndex5D"""
9574  return _IMP_algebra.ExtendedGridIndex5D_get_offset(self, i, j, k)
9575 
9576 
9577  def __str__(self):
9578  """__str__(ExtendedGridIndex5D self) -> std::string"""
9579  return _IMP_algebra.ExtendedGridIndex5D___str__(self)
9580 
9581 
9582  def __repr__(self):
9583  """__repr__(ExtendedGridIndex5D self) -> std::string"""
9584  return _IMP_algebra.ExtendedGridIndex5D___repr__(self)
9585 
9586 
9587  def _get_as_binary(self):
9588  """_get_as_binary(ExtendedGridIndex5D self) -> PyObject *"""
9589  return _IMP_algebra.ExtendedGridIndex5D__get_as_binary(self)
9590 
9591 
9592  def _set_from_binary(self, p):
9593  """_set_from_binary(ExtendedGridIndex5D self, PyObject * p)"""
9594  return _IMP_algebra.ExtendedGridIndex5D__set_from_binary(self, p)
9595 
9596 
9597  def __getstate__(self):
9598  p = self._get_as_binary()
9599  if len(self.__dict__) > 1:
9600  d = self.__dict__.copy()
9601  del d['this']
9602  p = (d, p)
9603  return p
9604 
9605  def __setstate__(self, p):
9606  if not hasattr(self, 'this'):
9607  self.__init__()
9608  if isinstance(p, tuple):
9609  d, p = p
9610  self.__dict__.update(d)
9611  return self._set_from_binary(p)
9612 
9613  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex5D
9614  __del__ = lambda self: None
9615 ExtendedGridIndex5D_swigregister = _IMP_algebra.ExtendedGridIndex5D_swigregister
9616 ExtendedGridIndex5D_swigregister(ExtendedGridIndex5D)
9617 
9618 class ExtendedGridIndex6D(IMP._Value):
9619  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(6)> class"""
9620  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9621 
9622  def __init__(self, *args):
9623  """
9624  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, IMP::Ints vals) -> ExtendedGridIndex6D
9625  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x) -> ExtendedGridIndex6D
9626  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x, int y) -> ExtendedGridIndex6D
9627  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int x, int y, int z) -> ExtendedGridIndex6D
9628  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l) -> ExtendedGridIndex6D
9629  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndex6D
9630  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndex6D
9631  __init__(IMP::algebra::ExtendedGridIndexD<(6)> self) -> ExtendedGridIndex6D
9632  """
9633  this = _IMP_algebra.new_ExtendedGridIndex6D(*args)
9634  try:
9635  self.this.append(this)
9636  except:
9637  self.this = this
9638 
9639  def get_dimension(self):
9640  """get_dimension(ExtendedGridIndex6D self) -> unsigned int"""
9641  return _IMP_algebra.ExtendedGridIndex6D_get_dimension(self)
9642 
9643 
9644  def __cmp__(self, o):
9645  """__cmp__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> int"""
9646  return _IMP_algebra.ExtendedGridIndex6D___cmp__(self, o)
9647 
9648 
9649  def __eq__(self, o):
9650  """__eq__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9651  return _IMP_algebra.ExtendedGridIndex6D___eq__(self, o)
9652 
9653 
9654  def __ne__(self, o):
9655  """__ne__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9656  return _IMP_algebra.ExtendedGridIndex6D___ne__(self, o)
9657 
9658 
9659  def __lt__(self, o):
9660  """__lt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9661  return _IMP_algebra.ExtendedGridIndex6D___lt__(self, o)
9662 
9663 
9664  def __gt__(self, o):
9665  """__gt__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9666  return _IMP_algebra.ExtendedGridIndex6D___gt__(self, o)
9667 
9668 
9669  def __ge__(self, o):
9670  """__ge__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9671  return _IMP_algebra.ExtendedGridIndex6D___ge__(self, o)
9672 
9673 
9674  def __le__(self, o):
9675  """__le__(ExtendedGridIndex6D self, ExtendedGridIndex6D o) -> bool"""
9676  return _IMP_algebra.ExtendedGridIndex6D___le__(self, o)
9677 
9678 
9679  def __setitem__(self, i, v):
9680  """__setitem__(ExtendedGridIndex6D self, unsigned int i, int const & v)"""
9681  return _IMP_algebra.ExtendedGridIndex6D___setitem__(self, i, v)
9682 
9683 
9684  def __getitem__(self, i):
9685  """__getitem__(ExtendedGridIndex6D self, unsigned int i) -> int const &"""
9686  return _IMP_algebra.ExtendedGridIndex6D___getitem__(self, i)
9687 
9688 
9689  def show(self, *args):
9690  """
9691  show(ExtendedGridIndex6D self, _ostream out)
9692  show(ExtendedGridIndex6D self)
9693  """
9694  return _IMP_algebra.ExtendedGridIndex6D_show(self, *args)
9695 
9696 
9697  def __len__(self):
9698  """__len__(ExtendedGridIndex6D self) -> unsigned int"""
9699  return _IMP_algebra.ExtendedGridIndex6D___len__(self)
9700 
9701 
9702  def __hash__(self):
9703  """__hash__(ExtendedGridIndex6D self) -> std::size_t"""
9704  return _IMP_algebra.ExtendedGridIndex6D___hash__(self)
9705 
9706 
9707  def get_uniform_offset(self, ii):
9708  """get_uniform_offset(ExtendedGridIndex6D self, int ii) -> ExtendedGridIndex6D"""
9709  return _IMP_algebra.ExtendedGridIndex6D_get_uniform_offset(self, ii)
9710 
9711 
9712  def get_offset(self, i, j, k):
9713  """get_offset(ExtendedGridIndex6D self, int i, int j, int k) -> ExtendedGridIndex6D"""
9714  return _IMP_algebra.ExtendedGridIndex6D_get_offset(self, i, j, k)
9715 
9716 
9717  def __str__(self):
9718  """__str__(ExtendedGridIndex6D self) -> std::string"""
9719  return _IMP_algebra.ExtendedGridIndex6D___str__(self)
9720 
9721 
9722  def __repr__(self):
9723  """__repr__(ExtendedGridIndex6D self) -> std::string"""
9724  return _IMP_algebra.ExtendedGridIndex6D___repr__(self)
9725 
9726 
9727  def _get_as_binary(self):
9728  """_get_as_binary(ExtendedGridIndex6D self) -> PyObject *"""
9729  return _IMP_algebra.ExtendedGridIndex6D__get_as_binary(self)
9730 
9731 
9732  def _set_from_binary(self, p):
9733  """_set_from_binary(ExtendedGridIndex6D self, PyObject * p)"""
9734  return _IMP_algebra.ExtendedGridIndex6D__set_from_binary(self, p)
9735 
9736 
9737  def __getstate__(self):
9738  p = self._get_as_binary()
9739  if len(self.__dict__) > 1:
9740  d = self.__dict__.copy()
9741  del d['this']
9742  p = (d, p)
9743  return p
9744 
9745  def __setstate__(self, p):
9746  if not hasattr(self, 'this'):
9747  self.__init__()
9748  if isinstance(p, tuple):
9749  d, p = p
9750  self.__dict__.update(d)
9751  return self._set_from_binary(p)
9752 
9753  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndex6D
9754  __del__ = lambda self: None
9755 ExtendedGridIndex6D_swigregister = _IMP_algebra.ExtendedGridIndex6D_swigregister
9756 ExtendedGridIndex6D_swigregister(ExtendedGridIndex6D)
9757 
9758 class ExtendedGridIndexKD(IMP._Value):
9759  """Proxy of C++ IMP::algebra::ExtendedGridIndexD<(-1)> class"""
9760  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9761 
9762  def __init__(self, *args):
9763  """
9764  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, IMP::Ints vals) -> ExtendedGridIndexKD
9765  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x) -> ExtendedGridIndexKD
9766  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x, int y) -> ExtendedGridIndexKD
9767  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int x, int y, int z) -> ExtendedGridIndexKD
9768  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l) -> ExtendedGridIndexKD
9769  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l, int m) -> ExtendedGridIndexKD
9770  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self, int i, int j, int k, int l, int m, int n) -> ExtendedGridIndexKD
9771  __init__(IMP::algebra::ExtendedGridIndexD<(-1)> self) -> ExtendedGridIndexKD
9772  """
9773  this = _IMP_algebra.new_ExtendedGridIndexKD(*args)
9774  try:
9775  self.this.append(this)
9776  except:
9777  self.this = this
9778 
9779  def get_dimension(self):
9780  """get_dimension(ExtendedGridIndexKD self) -> unsigned int"""
9781  return _IMP_algebra.ExtendedGridIndexKD_get_dimension(self)
9782 
9783 
9784  def __cmp__(self, o):
9785  """__cmp__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> int"""
9786  return _IMP_algebra.ExtendedGridIndexKD___cmp__(self, o)
9787 
9788 
9789  def __eq__(self, o):
9790  """__eq__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9791  return _IMP_algebra.ExtendedGridIndexKD___eq__(self, o)
9792 
9793 
9794  def __ne__(self, o):
9795  """__ne__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9796  return _IMP_algebra.ExtendedGridIndexKD___ne__(self, o)
9797 
9798 
9799  def __lt__(self, o):
9800  """__lt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9801  return _IMP_algebra.ExtendedGridIndexKD___lt__(self, o)
9802 
9803 
9804  def __gt__(self, o):
9805  """__gt__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9806  return _IMP_algebra.ExtendedGridIndexKD___gt__(self, o)
9807 
9808 
9809  def __ge__(self, o):
9810  """__ge__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9811  return _IMP_algebra.ExtendedGridIndexKD___ge__(self, o)
9812 
9813 
9814  def __le__(self, o):
9815  """__le__(ExtendedGridIndexKD self, ExtendedGridIndexKD o) -> bool"""
9816  return _IMP_algebra.ExtendedGridIndexKD___le__(self, o)
9817 
9818 
9819  def __setitem__(self, i, v):
9820  """__setitem__(ExtendedGridIndexKD self, unsigned int i, int const & v)"""
9821  return _IMP_algebra.ExtendedGridIndexKD___setitem__(self, i, v)
9822 
9823 
9824  def __getitem__(self, i):
9825  """__getitem__(ExtendedGridIndexKD self, unsigned int i) -> int const &"""
9826  return _IMP_algebra.ExtendedGridIndexKD___getitem__(self, i)
9827 
9828 
9829  def show(self, *args):
9830  """
9831  show(ExtendedGridIndexKD self, _ostream out)
9832  show(ExtendedGridIndexKD self)
9833  """
9834  return _IMP_algebra.ExtendedGridIndexKD_show(self, *args)
9835 
9836 
9837  def __len__(self):
9838  """__len__(ExtendedGridIndexKD self) -> unsigned int"""
9839  return _IMP_algebra.ExtendedGridIndexKD___len__(self)
9840 
9841 
9842  def __hash__(self):
9843  """__hash__(ExtendedGridIndexKD self) -> std::size_t"""
9844  return _IMP_algebra.ExtendedGridIndexKD___hash__(self)
9845 
9846 
9847  def get_uniform_offset(self, ii):
9848  """get_uniform_offset(ExtendedGridIndexKD self, int ii) -> ExtendedGridIndexKD"""
9849  return _IMP_algebra.ExtendedGridIndexKD_get_uniform_offset(self, ii)
9850 
9851 
9852  def get_offset(self, i, j, k):
9853  """get_offset(ExtendedGridIndexKD self, int i, int j, int k) -> ExtendedGridIndexKD"""
9854  return _IMP_algebra.ExtendedGridIndexKD_get_offset(self, i, j, k)
9855 
9856 
9857  def __str__(self):
9858  """__str__(ExtendedGridIndexKD self) -> std::string"""
9859  return _IMP_algebra.ExtendedGridIndexKD___str__(self)
9860 
9861 
9862  def __repr__(self):
9863  """__repr__(ExtendedGridIndexKD self) -> std::string"""
9864  return _IMP_algebra.ExtendedGridIndexKD___repr__(self)
9865 
9866 
9867  def _get_as_binary(self):
9868  """_get_as_binary(ExtendedGridIndexKD self) -> PyObject *"""
9869  return _IMP_algebra.ExtendedGridIndexKD__get_as_binary(self)
9870 
9871 
9872  def _set_from_binary(self, p):
9873  """_set_from_binary(ExtendedGridIndexKD self, PyObject * p)"""
9874  return _IMP_algebra.ExtendedGridIndexKD__set_from_binary(self, p)
9875 
9876 
9877  def __getstate__(self):
9878  p = self._get_as_binary()
9879  if len(self.__dict__) > 1:
9880  d = self.__dict__.copy()
9881  del d['this']
9882  p = (d, p)
9883  return p
9884 
9885  def __setstate__(self, p):
9886  if not hasattr(self, 'this'):
9887  self.__init__()
9888  if isinstance(p, tuple):
9889  d, p = p
9890  self.__dict__.update(d)
9891  return self._set_from_binary(p)
9892 
9893  __swig_destroy__ = _IMP_algebra.delete_ExtendedGridIndexKD
9894  __del__ = lambda self: None
9895 ExtendedGridIndexKD_swigregister = _IMP_algebra.ExtendedGridIndexKD_swigregister
9896 ExtendedGridIndexKD_swigregister(ExtendedGridIndexKD)
9897 
9898 class BoundedGridRange1D(object):
9899  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(1)> class"""
9900  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
9901 
9902  def get_is_bounded():
9903  """get_is_bounded() -> bool"""
9904  return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
9905 
9906  get_is_bounded = staticmethod(get_is_bounded)
9907 
9908  def __init__(self, *args):
9909  """
9910  __init__(IMP::algebra::BoundedGridRangeD<(1)> self) -> BoundedGridRange1D
9911  __init__(IMP::algebra::BoundedGridRangeD<(1)> self, IMP::Ints const & counts) -> BoundedGridRange1D
9912  """
9913  this = _IMP_algebra.new_BoundedGridRange1D(*args)
9914  try:
9915  self.this.append(this)
9916  except:
9917  self.this = this
9918 
9919  def get_number_of_voxels(self, *args):
9920  """
9921  get_number_of_voxels(BoundedGridRange1D self, unsigned int i) -> unsigned int
9922  get_number_of_voxels(BoundedGridRange1D self) -> unsigned int
9923  """
9924  return _IMP_algebra.BoundedGridRange1D_get_number_of_voxels(self, *args)
9925 
9926 
9927  def get_end_index(self):
9928  """get_end_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
9929  return _IMP_algebra.BoundedGridRange1D_get_end_index(self)
9930 
9931 
9932  def show(self, *args):
9933  """
9934  show(BoundedGridRange1D self, _ostream out)
9935  show(BoundedGridRange1D self)
9936  """
9937  return _IMP_algebra.BoundedGridRange1D_show(self, *args)
9938 
9939 
9940  def get_all_indexes(self):
9941  """get_all_indexes(BoundedGridRange1D self) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
9942  return _IMP_algebra.BoundedGridRange1D_get_all_indexes(self)
9943 
9944 
9945  def get_indexes(self, lb, ub):
9946  """get_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 1 > >"""
9947  return _IMP_algebra.BoundedGridRange1D_get_indexes(self, lb, ub)
9948 
9949 
9950  def get_extended_indexes(self, lb, ub):
9951  """get_extended_indexes(BoundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
9952  return _IMP_algebra.BoundedGridRange1D_get_extended_indexes(self, lb, ub)
9953 
9954 
9955  def get_index(self, v):
9956  """get_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> GridIndex1D"""
9957  return _IMP_algebra.BoundedGridRange1D_get_index(self, v)
9958 
9959 
9960  def get_has_index(self, v):
9961  """get_has_index(BoundedGridRange1D self, ExtendedGridIndex1D v) -> bool"""
9962  return _IMP_algebra.BoundedGridRange1D_get_has_index(self, v)
9963 
9964 
9965  def get_minimum_extended_index(self):
9966  """get_minimum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
9967  return _IMP_algebra.BoundedGridRange1D_get_minimum_extended_index(self)
9968 
9969 
9970  def get_maximum_extended_index(self):
9971  """get_maximum_extended_index(BoundedGridRange1D self) -> ExtendedGridIndex1D"""
9972  return _IMP_algebra.BoundedGridRange1D_get_maximum_extended_index(self)
9973 
9974 
9975  def __str__(self):
9976  """__str__(BoundedGridRange1D self) -> std::string"""
9977  return _IMP_algebra.BoundedGridRange1D___str__(self)
9978 
9979 
9980  def __repr__(self):
9981  """__repr__(BoundedGridRange1D self) -> std::string"""
9982  return _IMP_algebra.BoundedGridRange1D___repr__(self)
9983 
9984 
9985  def __cmp__(self, arg2):
9986  """__cmp__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> int"""
9987  return _IMP_algebra.BoundedGridRange1D___cmp__(self, arg2)
9988 
9989 
9990  def __eq__(self, arg2):
9991  """__eq__(BoundedGridRange1D self, BoundedGridRange1D arg2) -> bool"""
9992  return _IMP_algebra.BoundedGridRange1D___eq__(self, arg2)
9993 
9994 
9995  def _get_as_binary(self):
9996  """_get_as_binary(BoundedGridRange1D self) -> PyObject *"""
9997  return _IMP_algebra.BoundedGridRange1D__get_as_binary(self)
9998 
9999 
10000  def _set_from_binary(self, p):
10001  """_set_from_binary(BoundedGridRange1D self, PyObject * p)"""
10002  return _IMP_algebra.BoundedGridRange1D__set_from_binary(self, p)
10003 
10004 
10005  def __getstate__(self):
10006  p = self._get_as_binary()
10007  if len(self.__dict__) > 1:
10008  d = self.__dict__.copy()
10009  del d['this']
10010  p = (d, p)
10011  return p
10012 
10013  def __setstate__(self, p):
10014  if not hasattr(self, 'this'):
10015  self.__init__()
10016  if isinstance(p, tuple):
10017  d, p = p
10018  self.__dict__.update(d)
10019  return self._set_from_binary(p)
10020 
10021  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange1D
10022  __del__ = lambda self: None
10023 BoundedGridRange1D_swigregister = _IMP_algebra.BoundedGridRange1D_swigregister
10024 BoundedGridRange1D_swigregister(BoundedGridRange1D)
10025 
10026 def BoundedGridRange1D_get_is_bounded():
10027  """BoundedGridRange1D_get_is_bounded() -> bool"""
10028  return _IMP_algebra.BoundedGridRange1D_get_is_bounded()
10029 
10030 class BoundedGridRange2D(object):
10031  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(2)> class"""
10032  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10033 
10034  def get_is_bounded():
10035  """get_is_bounded() -> bool"""
10036  return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
10037 
10038  get_is_bounded = staticmethod(get_is_bounded)
10039 
10040  def __init__(self, *args):
10041  """
10042  __init__(IMP::algebra::BoundedGridRangeD<(2)> self) -> BoundedGridRange2D
10043  __init__(IMP::algebra::BoundedGridRangeD<(2)> self, IMP::Ints const & counts) -> BoundedGridRange2D
10044  """
10045  this = _IMP_algebra.new_BoundedGridRange2D(*args)
10046  try:
10047  self.this.append(this)
10048  except:
10049  self.this = this
10050 
10051  def get_number_of_voxels(self, *args):
10052  """
10053  get_number_of_voxels(BoundedGridRange2D self, unsigned int i) -> unsigned int
10054  get_number_of_voxels(BoundedGridRange2D self) -> unsigned int
10055  """
10056  return _IMP_algebra.BoundedGridRange2D_get_number_of_voxels(self, *args)
10057 
10058 
10059  def get_end_index(self):
10060  """get_end_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
10061  return _IMP_algebra.BoundedGridRange2D_get_end_index(self)
10062 
10063 
10064  def show(self, *args):
10065  """
10066  show(BoundedGridRange2D self, _ostream out)
10067  show(BoundedGridRange2D self)
10068  """
10069  return _IMP_algebra.BoundedGridRange2D_show(self, *args)
10070 
10071 
10072  def get_all_indexes(self):
10073  """get_all_indexes(BoundedGridRange2D self) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
10074  return _IMP_algebra.BoundedGridRange2D_get_all_indexes(self)
10075 
10076 
10077  def get_indexes(self, lb, ub):
10078  """get_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 2 > >"""
10079  return _IMP_algebra.BoundedGridRange2D_get_indexes(self, lb, ub)
10080 
10081 
10082  def get_extended_indexes(self, lb, ub):
10083  """get_extended_indexes(BoundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
10084  return _IMP_algebra.BoundedGridRange2D_get_extended_indexes(self, lb, ub)
10085 
10086 
10087  def get_index(self, v):
10088  """get_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> GridIndex2D"""
10089  return _IMP_algebra.BoundedGridRange2D_get_index(self, v)
10090 
10091 
10092  def get_has_index(self, v):
10093  """get_has_index(BoundedGridRange2D self, ExtendedGridIndex2D v) -> bool"""
10094  return _IMP_algebra.BoundedGridRange2D_get_has_index(self, v)
10095 
10096 
10097  def get_minimum_extended_index(self):
10098  """get_minimum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
10099  return _IMP_algebra.BoundedGridRange2D_get_minimum_extended_index(self)
10100 
10101 
10102  def get_maximum_extended_index(self):
10103  """get_maximum_extended_index(BoundedGridRange2D self) -> ExtendedGridIndex2D"""
10104  return _IMP_algebra.BoundedGridRange2D_get_maximum_extended_index(self)
10105 
10106 
10107  def __str__(self):
10108  """__str__(BoundedGridRange2D self) -> std::string"""
10109  return _IMP_algebra.BoundedGridRange2D___str__(self)
10110 
10111 
10112  def __repr__(self):
10113  """__repr__(BoundedGridRange2D self) -> std::string"""
10114  return _IMP_algebra.BoundedGridRange2D___repr__(self)
10115 
10116 
10117  def __cmp__(self, arg2):
10118  """__cmp__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> int"""
10119  return _IMP_algebra.BoundedGridRange2D___cmp__(self, arg2)
10120 
10121 
10122  def __eq__(self, arg2):
10123  """__eq__(BoundedGridRange2D self, BoundedGridRange2D arg2) -> bool"""
10124  return _IMP_algebra.BoundedGridRange2D___eq__(self, arg2)
10125 
10126 
10127  def _get_as_binary(self):
10128  """_get_as_binary(BoundedGridRange2D self) -> PyObject *"""
10129  return _IMP_algebra.BoundedGridRange2D__get_as_binary(self)
10130 
10131 
10132  def _set_from_binary(self, p):
10133  """_set_from_binary(BoundedGridRange2D self, PyObject * p)"""
10134  return _IMP_algebra.BoundedGridRange2D__set_from_binary(self, p)
10135 
10136 
10137  def __getstate__(self):
10138  p = self._get_as_binary()
10139  if len(self.__dict__) > 1:
10140  d = self.__dict__.copy()
10141  del d['this']
10142  p = (d, p)
10143  return p
10144 
10145  def __setstate__(self, p):
10146  if not hasattr(self, 'this'):
10147  self.__init__()
10148  if isinstance(p, tuple):
10149  d, p = p
10150  self.__dict__.update(d)
10151  return self._set_from_binary(p)
10152 
10153  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange2D
10154  __del__ = lambda self: None
10155 BoundedGridRange2D_swigregister = _IMP_algebra.BoundedGridRange2D_swigregister
10156 BoundedGridRange2D_swigregister(BoundedGridRange2D)
10157 
10158 def BoundedGridRange2D_get_is_bounded():
10159  """BoundedGridRange2D_get_is_bounded() -> bool"""
10160  return _IMP_algebra.BoundedGridRange2D_get_is_bounded()
10161 
10162 class BoundedGridRange3D(object):
10163  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(3)> class"""
10164  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10165 
10166  def get_is_bounded():
10167  """get_is_bounded() -> bool"""
10168  return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
10169 
10170  get_is_bounded = staticmethod(get_is_bounded)
10171 
10172  def __init__(self, *args):
10173  """
10174  __init__(IMP::algebra::BoundedGridRangeD<(3)> self) -> BoundedGridRange3D
10175  __init__(IMP::algebra::BoundedGridRangeD<(3)> self, IMP::Ints const & counts) -> BoundedGridRange3D
10176  """
10177  this = _IMP_algebra.new_BoundedGridRange3D(*args)
10178  try:
10179  self.this.append(this)
10180  except:
10181  self.this = this
10182 
10183  def get_number_of_voxels(self, *args):
10184  """
10185  get_number_of_voxels(BoundedGridRange3D self, unsigned int i) -> unsigned int
10186  get_number_of_voxels(BoundedGridRange3D self) -> unsigned int
10187  """
10188  return _IMP_algebra.BoundedGridRange3D_get_number_of_voxels(self, *args)
10189 
10190 
10191  def get_end_index(self):
10192  """get_end_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
10193  return _IMP_algebra.BoundedGridRange3D_get_end_index(self)
10194 
10195 
10196  def show(self, *args):
10197  """
10198  show(BoundedGridRange3D self, _ostream out)
10199  show(BoundedGridRange3D self)
10200  """
10201  return _IMP_algebra.BoundedGridRange3D_show(self, *args)
10202 
10203 
10204  def get_all_indexes(self):
10205  """get_all_indexes(BoundedGridRange3D self) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
10206  return _IMP_algebra.BoundedGridRange3D_get_all_indexes(self)
10207 
10208 
10209  def get_indexes(self, lb, ub):
10210  """get_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 3 > >"""
10211  return _IMP_algebra.BoundedGridRange3D_get_indexes(self, lb, ub)
10212 
10213 
10214  def get_extended_indexes(self, lb, ub):
10215  """get_extended_indexes(BoundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
10216  return _IMP_algebra.BoundedGridRange3D_get_extended_indexes(self, lb, ub)
10217 
10218 
10219  def get_index(self, v):
10220  """get_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> GridIndex3D"""
10221  return _IMP_algebra.BoundedGridRange3D_get_index(self, v)
10222 
10223 
10224  def get_has_index(self, v):
10225  """get_has_index(BoundedGridRange3D self, ExtendedGridIndex3D v) -> bool"""
10226  return _IMP_algebra.BoundedGridRange3D_get_has_index(self, v)
10227 
10228 
10229  def get_minimum_extended_index(self):
10230  """get_minimum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
10231  return _IMP_algebra.BoundedGridRange3D_get_minimum_extended_index(self)
10232 
10233 
10234  def get_maximum_extended_index(self):
10235  """get_maximum_extended_index(BoundedGridRange3D self) -> ExtendedGridIndex3D"""
10236  return _IMP_algebra.BoundedGridRange3D_get_maximum_extended_index(self)
10237 
10238 
10239  def __str__(self):
10240  """__str__(BoundedGridRange3D self) -> std::string"""
10241  return _IMP_algebra.BoundedGridRange3D___str__(self)
10242 
10243 
10244  def __repr__(self):
10245  """__repr__(BoundedGridRange3D self) -> std::string"""
10246  return _IMP_algebra.BoundedGridRange3D___repr__(self)
10247 
10248 
10249  def __cmp__(self, arg2):
10250  """__cmp__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> int"""
10251  return _IMP_algebra.BoundedGridRange3D___cmp__(self, arg2)
10252 
10253 
10254  def __eq__(self, arg2):
10255  """__eq__(BoundedGridRange3D self, BoundedGridRange3D arg2) -> bool"""
10256  return _IMP_algebra.BoundedGridRange3D___eq__(self, arg2)
10257 
10258 
10259  def _get_as_binary(self):
10260  """_get_as_binary(BoundedGridRange3D self) -> PyObject *"""
10261  return _IMP_algebra.BoundedGridRange3D__get_as_binary(self)
10262 
10263 
10264  def _set_from_binary(self, p):
10265  """_set_from_binary(BoundedGridRange3D self, PyObject * p)"""
10266  return _IMP_algebra.BoundedGridRange3D__set_from_binary(self, p)
10267 
10268 
10269  def __getstate__(self):
10270  p = self._get_as_binary()
10271  if len(self.__dict__) > 1:
10272  d = self.__dict__.copy()
10273  del d['this']
10274  p = (d, p)
10275  return p
10276 
10277  def __setstate__(self, p):
10278  if not hasattr(self, 'this'):
10279  self.__init__()
10280  if isinstance(p, tuple):
10281  d, p = p
10282  self.__dict__.update(d)
10283  return self._set_from_binary(p)
10284 
10285  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange3D
10286  __del__ = lambda self: None
10287 BoundedGridRange3D_swigregister = _IMP_algebra.BoundedGridRange3D_swigregister
10288 BoundedGridRange3D_swigregister(BoundedGridRange3D)
10289 
10290 def BoundedGridRange3D_get_is_bounded():
10291  """BoundedGridRange3D_get_is_bounded() -> bool"""
10292  return _IMP_algebra.BoundedGridRange3D_get_is_bounded()
10293 
10294 class BoundedGridRange4D(object):
10295  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(4)> class"""
10296  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10297 
10298  def get_is_bounded():
10299  """get_is_bounded() -> bool"""
10300  return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
10301 
10302  get_is_bounded = staticmethod(get_is_bounded)
10303 
10304  def __init__(self, *args):
10305  """
10306  __init__(IMP::algebra::BoundedGridRangeD<(4)> self) -> BoundedGridRange4D
10307  __init__(IMP::algebra::BoundedGridRangeD<(4)> self, IMP::Ints const & counts) -> BoundedGridRange4D
10308  """
10309  this = _IMP_algebra.new_BoundedGridRange4D(*args)
10310  try:
10311  self.this.append(this)
10312  except:
10313  self.this = this
10314 
10315  def get_number_of_voxels(self, *args):
10316  """
10317  get_number_of_voxels(BoundedGridRange4D self, unsigned int i) -> unsigned int
10318  get_number_of_voxels(BoundedGridRange4D self) -> unsigned int
10319  """
10320  return _IMP_algebra.BoundedGridRange4D_get_number_of_voxels(self, *args)
10321 
10322 
10323  def get_end_index(self):
10324  """get_end_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
10325  return _IMP_algebra.BoundedGridRange4D_get_end_index(self)
10326 
10327 
10328  def show(self, *args):
10329  """
10330  show(BoundedGridRange4D self, _ostream out)
10331  show(BoundedGridRange4D self)
10332  """
10333  return _IMP_algebra.BoundedGridRange4D_show(self, *args)
10334 
10335 
10336  def get_all_indexes(self):
10337  """get_all_indexes(BoundedGridRange4D self) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
10338  return _IMP_algebra.BoundedGridRange4D_get_all_indexes(self)
10339 
10340 
10341  def get_indexes(self, lb, ub):
10342  """get_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 4 > >"""
10343  return _IMP_algebra.BoundedGridRange4D_get_indexes(self, lb, ub)
10344 
10345 
10346  def get_extended_indexes(self, lb, ub):
10347  """get_extended_indexes(BoundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
10348  return _IMP_algebra.BoundedGridRange4D_get_extended_indexes(self, lb, ub)
10349 
10350 
10351  def get_index(self, v):
10352  """get_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> GridIndex4D"""
10353  return _IMP_algebra.BoundedGridRange4D_get_index(self, v)
10354 
10355 
10356  def get_has_index(self, v):
10357  """get_has_index(BoundedGridRange4D self, ExtendedGridIndex4D v) -> bool"""
10358  return _IMP_algebra.BoundedGridRange4D_get_has_index(self, v)
10359 
10360 
10361  def get_minimum_extended_index(self):
10362  """get_minimum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
10363  return _IMP_algebra.BoundedGridRange4D_get_minimum_extended_index(self)
10364 
10365 
10366  def get_maximum_extended_index(self):
10367  """get_maximum_extended_index(BoundedGridRange4D self) -> ExtendedGridIndex4D"""
10368  return _IMP_algebra.BoundedGridRange4D_get_maximum_extended_index(self)
10369 
10370 
10371  def __str__(self):
10372  """__str__(BoundedGridRange4D self) -> std::string"""
10373  return _IMP_algebra.BoundedGridRange4D___str__(self)
10374 
10375 
10376  def __repr__(self):
10377  """__repr__(BoundedGridRange4D self) -> std::string"""
10378  return _IMP_algebra.BoundedGridRange4D___repr__(self)
10379 
10380 
10381  def __cmp__(self, arg2):
10382  """__cmp__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> int"""
10383  return _IMP_algebra.BoundedGridRange4D___cmp__(self, arg2)
10384 
10385 
10386  def __eq__(self, arg2):
10387  """__eq__(BoundedGridRange4D self, BoundedGridRange4D arg2) -> bool"""
10388  return _IMP_algebra.BoundedGridRange4D___eq__(self, arg2)
10389 
10390 
10391  def _get_as_binary(self):
10392  """_get_as_binary(BoundedGridRange4D self) -> PyObject *"""
10393  return _IMP_algebra.BoundedGridRange4D__get_as_binary(self)
10394 
10395 
10396  def _set_from_binary(self, p):
10397  """_set_from_binary(BoundedGridRange4D self, PyObject * p)"""
10398  return _IMP_algebra.BoundedGridRange4D__set_from_binary(self, p)
10399 
10400 
10401  def __getstate__(self):
10402  p = self._get_as_binary()
10403  if len(self.__dict__) > 1:
10404  d = self.__dict__.copy()
10405  del d['this']
10406  p = (d, p)
10407  return p
10408 
10409  def __setstate__(self, p):
10410  if not hasattr(self, 'this'):
10411  self.__init__()
10412  if isinstance(p, tuple):
10413  d, p = p
10414  self.__dict__.update(d)
10415  return self._set_from_binary(p)
10416 
10417  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange4D
10418  __del__ = lambda self: None
10419 BoundedGridRange4D_swigregister = _IMP_algebra.BoundedGridRange4D_swigregister
10420 BoundedGridRange4D_swigregister(BoundedGridRange4D)
10421 
10422 def BoundedGridRange4D_get_is_bounded():
10423  """BoundedGridRange4D_get_is_bounded() -> bool"""
10424  return _IMP_algebra.BoundedGridRange4D_get_is_bounded()
10425 
10426 class BoundedGridRange5D(object):
10427  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(5)> class"""
10428  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10429 
10430  def get_is_bounded():
10431  """get_is_bounded() -> bool"""
10432  return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
10433 
10434  get_is_bounded = staticmethod(get_is_bounded)
10435 
10436  def __init__(self, *args):
10437  """
10438  __init__(IMP::algebra::BoundedGridRangeD<(5)> self) -> BoundedGridRange5D
10439  __init__(IMP::algebra::BoundedGridRangeD<(5)> self, IMP::Ints const & counts) -> BoundedGridRange5D
10440  """
10441  this = _IMP_algebra.new_BoundedGridRange5D(*args)
10442  try:
10443  self.this.append(this)
10444  except:
10445  self.this = this
10446 
10447  def get_number_of_voxels(self, *args):
10448  """
10449  get_number_of_voxels(BoundedGridRange5D self, unsigned int i) -> unsigned int
10450  get_number_of_voxels(BoundedGridRange5D self) -> unsigned int
10451  """
10452  return _IMP_algebra.BoundedGridRange5D_get_number_of_voxels(self, *args)
10453 
10454 
10455  def get_end_index(self):
10456  """get_end_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
10457  return _IMP_algebra.BoundedGridRange5D_get_end_index(self)
10458 
10459 
10460  def show(self, *args):
10461  """
10462  show(BoundedGridRange5D self, _ostream out)
10463  show(BoundedGridRange5D self)
10464  """
10465  return _IMP_algebra.BoundedGridRange5D_show(self, *args)
10466 
10467 
10468  def get_all_indexes(self):
10469  """get_all_indexes(BoundedGridRange5D self) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
10470  return _IMP_algebra.BoundedGridRange5D_get_all_indexes(self)
10471 
10472 
10473  def get_indexes(self, lb, ub):
10474  """get_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 5 > >"""
10475  return _IMP_algebra.BoundedGridRange5D_get_indexes(self, lb, ub)
10476 
10477 
10478  def get_extended_indexes(self, lb, ub):
10479  """get_extended_indexes(BoundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
10480  return _IMP_algebra.BoundedGridRange5D_get_extended_indexes(self, lb, ub)
10481 
10482 
10483  def get_index(self, v):
10484  """get_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> GridIndex5D"""
10485  return _IMP_algebra.BoundedGridRange5D_get_index(self, v)
10486 
10487 
10488  def get_has_index(self, v):
10489  """get_has_index(BoundedGridRange5D self, ExtendedGridIndex5D v) -> bool"""
10490  return _IMP_algebra.BoundedGridRange5D_get_has_index(self, v)
10491 
10492 
10493  def get_minimum_extended_index(self):
10494  """get_minimum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
10495  return _IMP_algebra.BoundedGridRange5D_get_minimum_extended_index(self)
10496 
10497 
10498  def get_maximum_extended_index(self):
10499  """get_maximum_extended_index(BoundedGridRange5D self) -> ExtendedGridIndex5D"""
10500  return _IMP_algebra.BoundedGridRange5D_get_maximum_extended_index(self)
10501 
10502 
10503  def __str__(self):
10504  """__str__(BoundedGridRange5D self) -> std::string"""
10505  return _IMP_algebra.BoundedGridRange5D___str__(self)
10506 
10507 
10508  def __repr__(self):
10509  """__repr__(BoundedGridRange5D self) -> std::string"""
10510  return _IMP_algebra.BoundedGridRange5D___repr__(self)
10511 
10512 
10513  def __cmp__(self, arg2):
10514  """__cmp__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> int"""
10515  return _IMP_algebra.BoundedGridRange5D___cmp__(self, arg2)
10516 
10517 
10518  def __eq__(self, arg2):
10519  """__eq__(BoundedGridRange5D self, BoundedGridRange5D arg2) -> bool"""
10520  return _IMP_algebra.BoundedGridRange5D___eq__(self, arg2)
10521 
10522 
10523  def _get_as_binary(self):
10524  """_get_as_binary(BoundedGridRange5D self) -> PyObject *"""
10525  return _IMP_algebra.BoundedGridRange5D__get_as_binary(self)
10526 
10527 
10528  def _set_from_binary(self, p):
10529  """_set_from_binary(BoundedGridRange5D self, PyObject * p)"""
10530  return _IMP_algebra.BoundedGridRange5D__set_from_binary(self, p)
10531 
10532 
10533  def __getstate__(self):
10534  p = self._get_as_binary()
10535  if len(self.__dict__) > 1:
10536  d = self.__dict__.copy()
10537  del d['this']
10538  p = (d, p)
10539  return p
10540 
10541  def __setstate__(self, p):
10542  if not hasattr(self, 'this'):
10543  self.__init__()
10544  if isinstance(p, tuple):
10545  d, p = p
10546  self.__dict__.update(d)
10547  return self._set_from_binary(p)
10548 
10549  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange5D
10550  __del__ = lambda self: None
10551 BoundedGridRange5D_swigregister = _IMP_algebra.BoundedGridRange5D_swigregister
10552 BoundedGridRange5D_swigregister(BoundedGridRange5D)
10553 
10554 def BoundedGridRange5D_get_is_bounded():
10555  """BoundedGridRange5D_get_is_bounded() -> bool"""
10556  return _IMP_algebra.BoundedGridRange5D_get_is_bounded()
10557 
10558 class BoundedGridRange6D(object):
10559  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(6)> class"""
10560  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10561 
10562  def get_is_bounded():
10563  """get_is_bounded() -> bool"""
10564  return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
10565 
10566  get_is_bounded = staticmethod(get_is_bounded)
10567 
10568  def __init__(self, *args):
10569  """
10570  __init__(IMP::algebra::BoundedGridRangeD<(6)> self) -> BoundedGridRange6D
10571  __init__(IMP::algebra::BoundedGridRangeD<(6)> self, IMP::Ints const & counts) -> BoundedGridRange6D
10572  """
10573  this = _IMP_algebra.new_BoundedGridRange6D(*args)
10574  try:
10575  self.this.append(this)
10576  except:
10577  self.this = this
10578 
10579  def get_number_of_voxels(self, *args):
10580  """
10581  get_number_of_voxels(BoundedGridRange6D self, unsigned int i) -> unsigned int
10582  get_number_of_voxels(BoundedGridRange6D self) -> unsigned int
10583  """
10584  return _IMP_algebra.BoundedGridRange6D_get_number_of_voxels(self, *args)
10585 
10586 
10587  def get_end_index(self):
10588  """get_end_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
10589  return _IMP_algebra.BoundedGridRange6D_get_end_index(self)
10590 
10591 
10592  def show(self, *args):
10593  """
10594  show(BoundedGridRange6D self, _ostream out)
10595  show(BoundedGridRange6D self)
10596  """
10597  return _IMP_algebra.BoundedGridRange6D_show(self, *args)
10598 
10599 
10600  def get_all_indexes(self):
10601  """get_all_indexes(BoundedGridRange6D self) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
10602  return _IMP_algebra.BoundedGridRange6D_get_all_indexes(self)
10603 
10604 
10605  def get_indexes(self, lb, ub):
10606  """get_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::GridIndexD< 6 > >"""
10607  return _IMP_algebra.BoundedGridRange6D_get_indexes(self, lb, ub)
10608 
10609 
10610  def get_extended_indexes(self, lb, ub):
10611  """get_extended_indexes(BoundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
10612  return _IMP_algebra.BoundedGridRange6D_get_extended_indexes(self, lb, ub)
10613 
10614 
10615  def get_index(self, v):
10616  """get_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> GridIndex6D"""
10617  return _IMP_algebra.BoundedGridRange6D_get_index(self, v)
10618 
10619 
10620  def get_has_index(self, v):
10621  """get_has_index(BoundedGridRange6D self, ExtendedGridIndex6D v) -> bool"""
10622  return _IMP_algebra.BoundedGridRange6D_get_has_index(self, v)
10623 
10624 
10625  def get_minimum_extended_index(self):
10626  """get_minimum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
10627  return _IMP_algebra.BoundedGridRange6D_get_minimum_extended_index(self)
10628 
10629 
10630  def get_maximum_extended_index(self):
10631  """get_maximum_extended_index(BoundedGridRange6D self) -> ExtendedGridIndex6D"""
10632  return _IMP_algebra.BoundedGridRange6D_get_maximum_extended_index(self)
10633 
10634 
10635  def __str__(self):
10636  """__str__(BoundedGridRange6D self) -> std::string"""
10637  return _IMP_algebra.BoundedGridRange6D___str__(self)
10638 
10639 
10640  def __repr__(self):
10641  """__repr__(BoundedGridRange6D self) -> std::string"""
10642  return _IMP_algebra.BoundedGridRange6D___repr__(self)
10643 
10644 
10645  def __cmp__(self, arg2):
10646  """__cmp__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> int"""
10647  return _IMP_algebra.BoundedGridRange6D___cmp__(self, arg2)
10648 
10649 
10650  def __eq__(self, arg2):
10651  """__eq__(BoundedGridRange6D self, BoundedGridRange6D arg2) -> bool"""
10652  return _IMP_algebra.BoundedGridRange6D___eq__(self, arg2)
10653 
10654 
10655  def _get_as_binary(self):
10656  """_get_as_binary(BoundedGridRange6D self) -> PyObject *"""
10657  return _IMP_algebra.BoundedGridRange6D__get_as_binary(self)
10658 
10659 
10660  def _set_from_binary(self, p):
10661  """_set_from_binary(BoundedGridRange6D self, PyObject * p)"""
10662  return _IMP_algebra.BoundedGridRange6D__set_from_binary(self, p)
10663 
10664 
10665  def __getstate__(self):
10666  p = self._get_as_binary()
10667  if len(self.__dict__) > 1:
10668  d = self.__dict__.copy()
10669  del d['this']
10670  p = (d, p)
10671  return p
10672 
10673  def __setstate__(self, p):
10674  if not hasattr(self, 'this'):
10675  self.__init__()
10676  if isinstance(p, tuple):
10677  d, p = p
10678  self.__dict__.update(d)
10679  return self._set_from_binary(p)
10680 
10681  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRange6D
10682  __del__ = lambda self: None
10683 BoundedGridRange6D_swigregister = _IMP_algebra.BoundedGridRange6D_swigregister
10684 BoundedGridRange6D_swigregister(BoundedGridRange6D)
10685 
10686 def BoundedGridRange6D_get_is_bounded():
10687  """BoundedGridRange6D_get_is_bounded() -> bool"""
10688  return _IMP_algebra.BoundedGridRange6D_get_is_bounded()
10689 
10690 class BoundedGridRangeKD(object):
10691  """Proxy of C++ IMP::algebra::BoundedGridRangeD<(-1)> class"""
10692  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10693 
10694  def get_is_bounded():
10695  """get_is_bounded() -> bool"""
10696  return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
10697 
10698  get_is_bounded = staticmethod(get_is_bounded)
10699 
10700  def __init__(self, *args):
10701  """
10702  __init__(IMP::algebra::BoundedGridRangeD<(-1)> self) -> BoundedGridRangeKD
10703  __init__(IMP::algebra::BoundedGridRangeD<(-1)> self, IMP::Ints const & counts) -> BoundedGridRangeKD
10704  """
10705  this = _IMP_algebra.new_BoundedGridRangeKD(*args)
10706  try:
10707  self.this.append(this)
10708  except:
10709  self.this = this
10710 
10711  def get_number_of_voxels(self, *args):
10712  """
10713  get_number_of_voxels(BoundedGridRangeKD self, unsigned int i) -> unsigned int
10714  get_number_of_voxels(BoundedGridRangeKD self) -> unsigned int
10715  """
10716  return _IMP_algebra.BoundedGridRangeKD_get_number_of_voxels(self, *args)
10717 
10718 
10719  def get_end_index(self):
10720  """get_end_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
10721  return _IMP_algebra.BoundedGridRangeKD_get_end_index(self)
10722 
10723 
10724  def show(self, *args):
10725  """
10726  show(BoundedGridRangeKD self, _ostream out)
10727  show(BoundedGridRangeKD self)
10728  """
10729  return _IMP_algebra.BoundedGridRangeKD_show(self, *args)
10730 
10731 
10732  def get_all_indexes(self):
10733  """get_all_indexes(BoundedGridRangeKD self) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
10734  return _IMP_algebra.BoundedGridRangeKD_get_all_indexes(self)
10735 
10736 
10737  def get_indexes(self, lb, ub):
10738  """get_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::GridIndexD< -1 > >"""
10739  return _IMP_algebra.BoundedGridRangeKD_get_indexes(self, lb, ub)
10740 
10741 
10742  def get_extended_indexes(self, lb, ub):
10743  """get_extended_indexes(BoundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
10744  return _IMP_algebra.BoundedGridRangeKD_get_extended_indexes(self, lb, ub)
10745 
10746 
10747  def get_index(self, v):
10748  """get_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> GridIndexKD"""
10749  return _IMP_algebra.BoundedGridRangeKD_get_index(self, v)
10750 
10751 
10752  def get_has_index(self, v):
10753  """get_has_index(BoundedGridRangeKD self, ExtendedGridIndexKD v) -> bool"""
10754  return _IMP_algebra.BoundedGridRangeKD_get_has_index(self, v)
10755 
10756 
10757  def get_minimum_extended_index(self):
10758  """get_minimum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
10759  return _IMP_algebra.BoundedGridRangeKD_get_minimum_extended_index(self)
10760 
10761 
10762  def get_maximum_extended_index(self):
10763  """get_maximum_extended_index(BoundedGridRangeKD self) -> ExtendedGridIndexKD"""
10764  return _IMP_algebra.BoundedGridRangeKD_get_maximum_extended_index(self)
10765 
10766 
10767  def __str__(self):
10768  """__str__(BoundedGridRangeKD self) -> std::string"""
10769  return _IMP_algebra.BoundedGridRangeKD___str__(self)
10770 
10771 
10772  def __repr__(self):
10773  """__repr__(BoundedGridRangeKD self) -> std::string"""
10774  return _IMP_algebra.BoundedGridRangeKD___repr__(self)
10775 
10776 
10777  def __cmp__(self, arg2):
10778  """__cmp__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> int"""
10779  return _IMP_algebra.BoundedGridRangeKD___cmp__(self, arg2)
10780 
10781 
10782  def __eq__(self, arg2):
10783  """__eq__(BoundedGridRangeKD self, BoundedGridRangeKD arg2) -> bool"""
10784  return _IMP_algebra.BoundedGridRangeKD___eq__(self, arg2)
10785 
10786 
10787  def _get_as_binary(self):
10788  """_get_as_binary(BoundedGridRangeKD self) -> PyObject *"""
10789  return _IMP_algebra.BoundedGridRangeKD__get_as_binary(self)
10790 
10791 
10792  def _set_from_binary(self, p):
10793  """_set_from_binary(BoundedGridRangeKD self, PyObject * p)"""
10794  return _IMP_algebra.BoundedGridRangeKD__set_from_binary(self, p)
10795 
10796 
10797  def __getstate__(self):
10798  p = self._get_as_binary()
10799  if len(self.__dict__) > 1:
10800  d = self.__dict__.copy()
10801  del d['this']
10802  p = (d, p)
10803  return p
10804 
10805  def __setstate__(self, p):
10806  if not hasattr(self, 'this'):
10807  self.__init__()
10808  if isinstance(p, tuple):
10809  d, p = p
10810  self.__dict__.update(d)
10811  return self._set_from_binary(p)
10812 
10813  __swig_destroy__ = _IMP_algebra.delete_BoundedGridRangeKD
10814  __del__ = lambda self: None
10815 BoundedGridRangeKD_swigregister = _IMP_algebra.BoundedGridRangeKD_swigregister
10816 BoundedGridRangeKD_swigregister(BoundedGridRangeKD)
10817 
10818 def BoundedGridRangeKD_get_is_bounded():
10819  """BoundedGridRangeKD_get_is_bounded() -> bool"""
10820  return _IMP_algebra.BoundedGridRangeKD_get_is_bounded()
10821 
10822 class UnboundedGridRange1D(object):
10823  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(1)> class"""
10824  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10825 
10826  def __init__(self, *args):
10827  """
10828  __init__(IMP::algebra::UnboundedGridRangeD<(1)> self) -> UnboundedGridRange1D
10829  __init__(IMP::algebra::UnboundedGridRangeD<(1)> self, IMP::Ints const & arg2) -> UnboundedGridRange1D
10830  """
10831  this = _IMP_algebra.new_UnboundedGridRange1D(*args)
10832  try:
10833  self.this.append(this)
10834  except:
10835  self.this = this
10836 
10837  def set_number_of_voxels(self, arg2):
10838  """set_number_of_voxels(UnboundedGridRange1D self, IMP::Ints arg2)"""
10839  return _IMP_algebra.UnboundedGridRange1D_set_number_of_voxels(self, arg2)
10840 
10841 
10842  def get_number_of_voxels(self, arg2):
10843  """get_number_of_voxels(UnboundedGridRange1D self, int arg2) -> unsigned int"""
10844  return _IMP_algebra.UnboundedGridRange1D_get_number_of_voxels(self, arg2)
10845 
10846 
10847  def get_is_bounded():
10848  """get_is_bounded() -> bool"""
10849  return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
10850 
10851  get_is_bounded = staticmethod(get_is_bounded)
10852 
10853  def get_has_index(self, arg2):
10854  """get_has_index(UnboundedGridRange1D self, ExtendedGridIndex1D arg2) -> bool"""
10855  return _IMP_algebra.UnboundedGridRange1D_get_has_index(self, arg2)
10856 
10857 
10858  def show(self, *args):
10859  """
10860  show(UnboundedGridRange1D self, _ostream out)
10861  show(UnboundedGridRange1D self)
10862  """
10863  return _IMP_algebra.UnboundedGridRange1D_show(self, *args)
10864 
10865 
10866  def get_extended_indexes(self, lb, ub):
10867  """get_extended_indexes(UnboundedGridRange1D self, ExtendedGridIndex1D lb, ExtendedGridIndex1D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 1 > >"""
10868  return _IMP_algebra.UnboundedGridRange1D_get_extended_indexes(self, lb, ub)
10869 
10870 
10871  def __str__(self):
10872  """__str__(UnboundedGridRange1D self) -> std::string"""
10873  return _IMP_algebra.UnboundedGridRange1D___str__(self)
10874 
10875 
10876  def __repr__(self):
10877  """__repr__(UnboundedGridRange1D self) -> std::string"""
10878  return _IMP_algebra.UnboundedGridRange1D___repr__(self)
10879 
10880 
10881  def __cmp__(self, arg2):
10882  """__cmp__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> int"""
10883  return _IMP_algebra.UnboundedGridRange1D___cmp__(self, arg2)
10884 
10885 
10886  def __eq__(self, arg2):
10887  """__eq__(UnboundedGridRange1D self, UnboundedGridRange1D arg2) -> bool"""
10888  return _IMP_algebra.UnboundedGridRange1D___eq__(self, arg2)
10889 
10890 
10891  def _get_as_binary(self):
10892  """_get_as_binary(UnboundedGridRange1D self) -> PyObject *"""
10893  return _IMP_algebra.UnboundedGridRange1D__get_as_binary(self)
10894 
10895 
10896  def _set_from_binary(self, p):
10897  """_set_from_binary(UnboundedGridRange1D self, PyObject * p)"""
10898  return _IMP_algebra.UnboundedGridRange1D__set_from_binary(self, p)
10899 
10900 
10901  def __getstate__(self):
10902  p = self._get_as_binary()
10903  if len(self.__dict__) > 1:
10904  d = self.__dict__.copy()
10905  del d['this']
10906  p = (d, p)
10907  return p
10908 
10909  def __setstate__(self, p):
10910  if not hasattr(self, 'this'):
10911  self.__init__()
10912  if isinstance(p, tuple):
10913  d, p = p
10914  self.__dict__.update(d)
10915  return self._set_from_binary(p)
10916 
10917  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange1D
10918  __del__ = lambda self: None
10919 UnboundedGridRange1D_swigregister = _IMP_algebra.UnboundedGridRange1D_swigregister
10920 UnboundedGridRange1D_swigregister(UnboundedGridRange1D)
10921 
10922 def UnboundedGridRange1D_get_is_bounded():
10923  """UnboundedGridRange1D_get_is_bounded() -> bool"""
10924  return _IMP_algebra.UnboundedGridRange1D_get_is_bounded()
10925 
10926 class UnboundedGridRange2D(object):
10927  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(2)> class"""
10928  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
10929 
10930  def __init__(self, *args):
10931  """
10932  __init__(IMP::algebra::UnboundedGridRangeD<(2)> self) -> UnboundedGridRange2D
10933  __init__(IMP::algebra::UnboundedGridRangeD<(2)> self, IMP::Ints const & arg2) -> UnboundedGridRange2D
10934  """
10935  this = _IMP_algebra.new_UnboundedGridRange2D(*args)
10936  try:
10937  self.this.append(this)
10938  except:
10939  self.this = this
10940 
10941  def set_number_of_voxels(self, arg2):
10942  """set_number_of_voxels(UnboundedGridRange2D self, IMP::Ints arg2)"""
10943  return _IMP_algebra.UnboundedGridRange2D_set_number_of_voxels(self, arg2)
10944 
10945 
10946  def get_number_of_voxels(self, arg2):
10947  """get_number_of_voxels(UnboundedGridRange2D self, int arg2) -> unsigned int"""
10948  return _IMP_algebra.UnboundedGridRange2D_get_number_of_voxels(self, arg2)
10949 
10950 
10951  def get_is_bounded():
10952  """get_is_bounded() -> bool"""
10953  return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
10954 
10955  get_is_bounded = staticmethod(get_is_bounded)
10956 
10957  def get_has_index(self, arg2):
10958  """get_has_index(UnboundedGridRange2D self, ExtendedGridIndex2D arg2) -> bool"""
10959  return _IMP_algebra.UnboundedGridRange2D_get_has_index(self, arg2)
10960 
10961 
10962  def show(self, *args):
10963  """
10964  show(UnboundedGridRange2D self, _ostream out)
10965  show(UnboundedGridRange2D self)
10966  """
10967  return _IMP_algebra.UnboundedGridRange2D_show(self, *args)
10968 
10969 
10970  def get_extended_indexes(self, lb, ub):
10971  """get_extended_indexes(UnboundedGridRange2D self, ExtendedGridIndex2D lb, ExtendedGridIndex2D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 2 > >"""
10972  return _IMP_algebra.UnboundedGridRange2D_get_extended_indexes(self, lb, ub)
10973 
10974 
10975  def __str__(self):
10976  """__str__(UnboundedGridRange2D self) -> std::string"""
10977  return _IMP_algebra.UnboundedGridRange2D___str__(self)
10978 
10979 
10980  def __repr__(self):
10981  """__repr__(UnboundedGridRange2D self) -> std::string"""
10982  return _IMP_algebra.UnboundedGridRange2D___repr__(self)
10983 
10984 
10985  def __cmp__(self, arg2):
10986  """__cmp__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> int"""
10987  return _IMP_algebra.UnboundedGridRange2D___cmp__(self, arg2)
10988 
10989 
10990  def __eq__(self, arg2):
10991  """__eq__(UnboundedGridRange2D self, UnboundedGridRange2D arg2) -> bool"""
10992  return _IMP_algebra.UnboundedGridRange2D___eq__(self, arg2)
10993 
10994 
10995  def _get_as_binary(self):
10996  """_get_as_binary(UnboundedGridRange2D self) -> PyObject *"""
10997  return _IMP_algebra.UnboundedGridRange2D__get_as_binary(self)
10998 
10999 
11000  def _set_from_binary(self, p):
11001  """_set_from_binary(UnboundedGridRange2D self, PyObject * p)"""
11002  return _IMP_algebra.UnboundedGridRange2D__set_from_binary(self, p)
11003 
11004 
11005  def __getstate__(self):
11006  p = self._get_as_binary()
11007  if len(self.__dict__) > 1:
11008  d = self.__dict__.copy()
11009  del d['this']
11010  p = (d, p)
11011  return p
11012 
11013  def __setstate__(self, p):
11014  if not hasattr(self, 'this'):
11015  self.__init__()
11016  if isinstance(p, tuple):
11017  d, p = p
11018  self.__dict__.update(d)
11019  return self._set_from_binary(p)
11020 
11021  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange2D
11022  __del__ = lambda self: None
11023 UnboundedGridRange2D_swigregister = _IMP_algebra.UnboundedGridRange2D_swigregister
11024 UnboundedGridRange2D_swigregister(UnboundedGridRange2D)
11025 
11026 def UnboundedGridRange2D_get_is_bounded():
11027  """UnboundedGridRange2D_get_is_bounded() -> bool"""
11028  return _IMP_algebra.UnboundedGridRange2D_get_is_bounded()
11029 
11030 class UnboundedGridRange3D(object):
11031  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(3)> class"""
11032  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11033 
11034  def __init__(self, *args):
11035  """
11036  __init__(IMP::algebra::UnboundedGridRangeD<(3)> self) -> UnboundedGridRange3D
11037  __init__(IMP::algebra::UnboundedGridRangeD<(3)> self, IMP::Ints const & arg2) -> UnboundedGridRange3D
11038  """
11039  this = _IMP_algebra.new_UnboundedGridRange3D(*args)
11040  try:
11041  self.this.append(this)
11042  except:
11043  self.this = this
11044 
11045  def set_number_of_voxels(self, arg2):
11046  """set_number_of_voxels(UnboundedGridRange3D self, IMP::Ints arg2)"""
11047  return _IMP_algebra.UnboundedGridRange3D_set_number_of_voxels(self, arg2)
11048 
11049 
11050  def get_number_of_voxels(self, arg2):
11051  """get_number_of_voxels(UnboundedGridRange3D self, int arg2) -> unsigned int"""
11052  return _IMP_algebra.UnboundedGridRange3D_get_number_of_voxels(self, arg2)
11053 
11054 
11055  def get_is_bounded():
11056  """get_is_bounded() -> bool"""
11057  return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
11058 
11059  get_is_bounded = staticmethod(get_is_bounded)
11060 
11061  def get_has_index(self, arg2):
11062  """get_has_index(UnboundedGridRange3D self, ExtendedGridIndex3D arg2) -> bool"""
11063  return _IMP_algebra.UnboundedGridRange3D_get_has_index(self, arg2)
11064 
11065 
11066  def show(self, *args):
11067  """
11068  show(UnboundedGridRange3D self, _ostream out)
11069  show(UnboundedGridRange3D self)
11070  """
11071  return _IMP_algebra.UnboundedGridRange3D_show(self, *args)
11072 
11073 
11074  def get_extended_indexes(self, lb, ub):
11075  """get_extended_indexes(UnboundedGridRange3D self, ExtendedGridIndex3D lb, ExtendedGridIndex3D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 3 > >"""
11076  return _IMP_algebra.UnboundedGridRange3D_get_extended_indexes(self, lb, ub)
11077 
11078 
11079  def __str__(self):
11080  """__str__(UnboundedGridRange3D self) -> std::string"""
11081  return _IMP_algebra.UnboundedGridRange3D___str__(self)
11082 
11083 
11084  def __repr__(self):
11085  """__repr__(UnboundedGridRange3D self) -> std::string"""
11086  return _IMP_algebra.UnboundedGridRange3D___repr__(self)
11087 
11088 
11089  def __cmp__(self, arg2):
11090  """__cmp__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> int"""
11091  return _IMP_algebra.UnboundedGridRange3D___cmp__(self, arg2)
11092 
11093 
11094  def __eq__(self, arg2):
11095  """__eq__(UnboundedGridRange3D self, UnboundedGridRange3D arg2) -> bool"""
11096  return _IMP_algebra.UnboundedGridRange3D___eq__(self, arg2)
11097 
11098 
11099  def _get_as_binary(self):
11100  """_get_as_binary(UnboundedGridRange3D self) -> PyObject *"""
11101  return _IMP_algebra.UnboundedGridRange3D__get_as_binary(self)
11102 
11103 
11104  def _set_from_binary(self, p):
11105  """_set_from_binary(UnboundedGridRange3D self, PyObject * p)"""
11106  return _IMP_algebra.UnboundedGridRange3D__set_from_binary(self, p)
11107 
11108 
11109  def __getstate__(self):
11110  p = self._get_as_binary()
11111  if len(self.__dict__) > 1:
11112  d = self.__dict__.copy()
11113  del d['this']
11114  p = (d, p)
11115  return p
11116 
11117  def __setstate__(self, p):
11118  if not hasattr(self, 'this'):
11119  self.__init__()
11120  if isinstance(p, tuple):
11121  d, p = p
11122  self.__dict__.update(d)
11123  return self._set_from_binary(p)
11124 
11125  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange3D
11126  __del__ = lambda self: None
11127 UnboundedGridRange3D_swigregister = _IMP_algebra.UnboundedGridRange3D_swigregister
11128 UnboundedGridRange3D_swigregister(UnboundedGridRange3D)
11129 
11130 def UnboundedGridRange3D_get_is_bounded():
11131  """UnboundedGridRange3D_get_is_bounded() -> bool"""
11132  return _IMP_algebra.UnboundedGridRange3D_get_is_bounded()
11133 
11134 class UnboundedGridRange4D(object):
11135  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(4)> class"""
11136  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11137 
11138  def __init__(self, *args):
11139  """
11140  __init__(IMP::algebra::UnboundedGridRangeD<(4)> self) -> UnboundedGridRange4D
11141  __init__(IMP::algebra::UnboundedGridRangeD<(4)> self, IMP::Ints const & arg2) -> UnboundedGridRange4D
11142  """
11143  this = _IMP_algebra.new_UnboundedGridRange4D(*args)
11144  try:
11145  self.this.append(this)
11146  except:
11147  self.this = this
11148 
11149  def set_number_of_voxels(self, arg2):
11150  """set_number_of_voxels(UnboundedGridRange4D self, IMP::Ints arg2)"""
11151  return _IMP_algebra.UnboundedGridRange4D_set_number_of_voxels(self, arg2)
11152 
11153 
11154  def get_number_of_voxels(self, arg2):
11155  """get_number_of_voxels(UnboundedGridRange4D self, int arg2) -> unsigned int"""
11156  return _IMP_algebra.UnboundedGridRange4D_get_number_of_voxels(self, arg2)
11157 
11158 
11159  def get_is_bounded():
11160  """get_is_bounded() -> bool"""
11161  return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
11162 
11163  get_is_bounded = staticmethod(get_is_bounded)
11164 
11165  def get_has_index(self, arg2):
11166  """get_has_index(UnboundedGridRange4D self, ExtendedGridIndex4D arg2) -> bool"""
11167  return _IMP_algebra.UnboundedGridRange4D_get_has_index(self, arg2)
11168 
11169 
11170  def show(self, *args):
11171  """
11172  show(UnboundedGridRange4D self, _ostream out)
11173  show(UnboundedGridRange4D self)
11174  """
11175  return _IMP_algebra.UnboundedGridRange4D_show(self, *args)
11176 
11177 
11178  def get_extended_indexes(self, lb, ub):
11179  """get_extended_indexes(UnboundedGridRange4D self, ExtendedGridIndex4D lb, ExtendedGridIndex4D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 4 > >"""
11180  return _IMP_algebra.UnboundedGridRange4D_get_extended_indexes(self, lb, ub)
11181 
11182 
11183  def __str__(self):
11184  """__str__(UnboundedGridRange4D self) -> std::string"""
11185  return _IMP_algebra.UnboundedGridRange4D___str__(self)
11186 
11187 
11188  def __repr__(self):
11189  """__repr__(UnboundedGridRange4D self) -> std::string"""
11190  return _IMP_algebra.UnboundedGridRange4D___repr__(self)
11191 
11192 
11193  def __cmp__(self, arg2):
11194  """__cmp__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> int"""
11195  return _IMP_algebra.UnboundedGridRange4D___cmp__(self, arg2)
11196 
11197 
11198  def __eq__(self, arg2):
11199  """__eq__(UnboundedGridRange4D self, UnboundedGridRange4D arg2) -> bool"""
11200  return _IMP_algebra.UnboundedGridRange4D___eq__(self, arg2)
11201 
11202 
11203  def _get_as_binary(self):
11204  """_get_as_binary(UnboundedGridRange4D self) -> PyObject *"""
11205  return _IMP_algebra.UnboundedGridRange4D__get_as_binary(self)
11206 
11207 
11208  def _set_from_binary(self, p):
11209  """_set_from_binary(UnboundedGridRange4D self, PyObject * p)"""
11210  return _IMP_algebra.UnboundedGridRange4D__set_from_binary(self, p)
11211 
11212 
11213  def __getstate__(self):
11214  p = self._get_as_binary()
11215  if len(self.__dict__) > 1:
11216  d = self.__dict__.copy()
11217  del d['this']
11218  p = (d, p)
11219  return p
11220 
11221  def __setstate__(self, p):
11222  if not hasattr(self, 'this'):
11223  self.__init__()
11224  if isinstance(p, tuple):
11225  d, p = p
11226  self.__dict__.update(d)
11227  return self._set_from_binary(p)
11228 
11229  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange4D
11230  __del__ = lambda self: None
11231 UnboundedGridRange4D_swigregister = _IMP_algebra.UnboundedGridRange4D_swigregister
11232 UnboundedGridRange4D_swigregister(UnboundedGridRange4D)
11233 
11234 def UnboundedGridRange4D_get_is_bounded():
11235  """UnboundedGridRange4D_get_is_bounded() -> bool"""
11236  return _IMP_algebra.UnboundedGridRange4D_get_is_bounded()
11237 
11238 class UnboundedGridRange5D(object):
11239  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(5)> class"""
11240  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11241 
11242  def __init__(self, *args):
11243  """
11244  __init__(IMP::algebra::UnboundedGridRangeD<(5)> self) -> UnboundedGridRange5D
11245  __init__(IMP::algebra::UnboundedGridRangeD<(5)> self, IMP::Ints const & arg2) -> UnboundedGridRange5D
11246  """
11247  this = _IMP_algebra.new_UnboundedGridRange5D(*args)
11248  try:
11249  self.this.append(this)
11250  except:
11251  self.this = this
11252 
11253  def set_number_of_voxels(self, arg2):
11254  """set_number_of_voxels(UnboundedGridRange5D self, IMP::Ints arg2)"""
11255  return _IMP_algebra.UnboundedGridRange5D_set_number_of_voxels(self, arg2)
11256 
11257 
11258  def get_number_of_voxels(self, arg2):
11259  """get_number_of_voxels(UnboundedGridRange5D self, int arg2) -> unsigned int"""
11260  return _IMP_algebra.UnboundedGridRange5D_get_number_of_voxels(self, arg2)
11261 
11262 
11263  def get_is_bounded():
11264  """get_is_bounded() -> bool"""
11265  return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
11266 
11267  get_is_bounded = staticmethod(get_is_bounded)
11268 
11269  def get_has_index(self, arg2):
11270  """get_has_index(UnboundedGridRange5D self, ExtendedGridIndex5D arg2) -> bool"""
11271  return _IMP_algebra.UnboundedGridRange5D_get_has_index(self, arg2)
11272 
11273 
11274  def show(self, *args):
11275  """
11276  show(UnboundedGridRange5D self, _ostream out)
11277  show(UnboundedGridRange5D self)
11278  """
11279  return _IMP_algebra.UnboundedGridRange5D_show(self, *args)
11280 
11281 
11282  def get_extended_indexes(self, lb, ub):
11283  """get_extended_indexes(UnboundedGridRange5D self, ExtendedGridIndex5D lb, ExtendedGridIndex5D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 5 > >"""
11284  return _IMP_algebra.UnboundedGridRange5D_get_extended_indexes(self, lb, ub)
11285 
11286 
11287  def __str__(self):
11288  """__str__(UnboundedGridRange5D self) -> std::string"""
11289  return _IMP_algebra.UnboundedGridRange5D___str__(self)
11290 
11291 
11292  def __repr__(self):
11293  """__repr__(UnboundedGridRange5D self) -> std::string"""
11294  return _IMP_algebra.UnboundedGridRange5D___repr__(self)
11295 
11296 
11297  def __cmp__(self, arg2):
11298  """__cmp__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> int"""
11299  return _IMP_algebra.UnboundedGridRange5D___cmp__(self, arg2)
11300 
11301 
11302  def __eq__(self, arg2):
11303  """__eq__(UnboundedGridRange5D self, UnboundedGridRange5D arg2) -> bool"""
11304  return _IMP_algebra.UnboundedGridRange5D___eq__(self, arg2)
11305 
11306 
11307  def _get_as_binary(self):
11308  """_get_as_binary(UnboundedGridRange5D self) -> PyObject *"""
11309  return _IMP_algebra.UnboundedGridRange5D__get_as_binary(self)
11310 
11311 
11312  def _set_from_binary(self, p):
11313  """_set_from_binary(UnboundedGridRange5D self, PyObject * p)"""
11314  return _IMP_algebra.UnboundedGridRange5D__set_from_binary(self, p)
11315 
11316 
11317  def __getstate__(self):
11318  p = self._get_as_binary()
11319  if len(self.__dict__) > 1:
11320  d = self.__dict__.copy()
11321  del d['this']
11322  p = (d, p)
11323  return p
11324 
11325  def __setstate__(self, p):
11326  if not hasattr(self, 'this'):
11327  self.__init__()
11328  if isinstance(p, tuple):
11329  d, p = p
11330  self.__dict__.update(d)
11331  return self._set_from_binary(p)
11332 
11333  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange5D
11334  __del__ = lambda self: None
11335 UnboundedGridRange5D_swigregister = _IMP_algebra.UnboundedGridRange5D_swigregister
11336 UnboundedGridRange5D_swigregister(UnboundedGridRange5D)
11337 
11338 def UnboundedGridRange5D_get_is_bounded():
11339  """UnboundedGridRange5D_get_is_bounded() -> bool"""
11340  return _IMP_algebra.UnboundedGridRange5D_get_is_bounded()
11341 
11342 class UnboundedGridRange6D(object):
11343  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(6)> class"""
11344  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11345 
11346  def __init__(self, *args):
11347  """
11348  __init__(IMP::algebra::UnboundedGridRangeD<(6)> self) -> UnboundedGridRange6D
11349  __init__(IMP::algebra::UnboundedGridRangeD<(6)> self, IMP::Ints const & arg2) -> UnboundedGridRange6D
11350  """
11351  this = _IMP_algebra.new_UnboundedGridRange6D(*args)
11352  try:
11353  self.this.append(this)
11354  except:
11355  self.this = this
11356 
11357  def set_number_of_voxels(self, arg2):
11358  """set_number_of_voxels(UnboundedGridRange6D self, IMP::Ints arg2)"""
11359  return _IMP_algebra.UnboundedGridRange6D_set_number_of_voxels(self, arg2)
11360 
11361 
11362  def get_number_of_voxels(self, arg2):
11363  """get_number_of_voxels(UnboundedGridRange6D self, int arg2) -> unsigned int"""
11364  return _IMP_algebra.UnboundedGridRange6D_get_number_of_voxels(self, arg2)
11365 
11366 
11367  def get_is_bounded():
11368  """get_is_bounded() -> bool"""
11369  return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
11370 
11371  get_is_bounded = staticmethod(get_is_bounded)
11372 
11373  def get_has_index(self, arg2):
11374  """get_has_index(UnboundedGridRange6D self, ExtendedGridIndex6D arg2) -> bool"""
11375  return _IMP_algebra.UnboundedGridRange6D_get_has_index(self, arg2)
11376 
11377 
11378  def show(self, *args):
11379  """
11380  show(UnboundedGridRange6D self, _ostream out)
11381  show(UnboundedGridRange6D self)
11382  """
11383  return _IMP_algebra.UnboundedGridRange6D_show(self, *args)
11384 
11385 
11386  def get_extended_indexes(self, lb, ub):
11387  """get_extended_indexes(UnboundedGridRange6D self, ExtendedGridIndex6D lb, ExtendedGridIndex6D ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< 6 > >"""
11388  return _IMP_algebra.UnboundedGridRange6D_get_extended_indexes(self, lb, ub)
11389 
11390 
11391  def __str__(self):
11392  """__str__(UnboundedGridRange6D self) -> std::string"""
11393  return _IMP_algebra.UnboundedGridRange6D___str__(self)
11394 
11395 
11396  def __repr__(self):
11397  """__repr__(UnboundedGridRange6D self) -> std::string"""
11398  return _IMP_algebra.UnboundedGridRange6D___repr__(self)
11399 
11400 
11401  def __cmp__(self, arg2):
11402  """__cmp__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> int"""
11403  return _IMP_algebra.UnboundedGridRange6D___cmp__(self, arg2)
11404 
11405 
11406  def __eq__(self, arg2):
11407  """__eq__(UnboundedGridRange6D self, UnboundedGridRange6D arg2) -> bool"""
11408  return _IMP_algebra.UnboundedGridRange6D___eq__(self, arg2)
11409 
11410 
11411  def _get_as_binary(self):
11412  """_get_as_binary(UnboundedGridRange6D self) -> PyObject *"""
11413  return _IMP_algebra.UnboundedGridRange6D__get_as_binary(self)
11414 
11415 
11416  def _set_from_binary(self, p):
11417  """_set_from_binary(UnboundedGridRange6D self, PyObject * p)"""
11418  return _IMP_algebra.UnboundedGridRange6D__set_from_binary(self, p)
11419 
11420 
11421  def __getstate__(self):
11422  p = self._get_as_binary()
11423  if len(self.__dict__) > 1:
11424  d = self.__dict__.copy()
11425  del d['this']
11426  p = (d, p)
11427  return p
11428 
11429  def __setstate__(self, p):
11430  if not hasattr(self, 'this'):
11431  self.__init__()
11432  if isinstance(p, tuple):
11433  d, p = p
11434  self.__dict__.update(d)
11435  return self._set_from_binary(p)
11436 
11437  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRange6D
11438  __del__ = lambda self: None
11439 UnboundedGridRange6D_swigregister = _IMP_algebra.UnboundedGridRange6D_swigregister
11440 UnboundedGridRange6D_swigregister(UnboundedGridRange6D)
11441 
11442 def UnboundedGridRange6D_get_is_bounded():
11443  """UnboundedGridRange6D_get_is_bounded() -> bool"""
11444  return _IMP_algebra.UnboundedGridRange6D_get_is_bounded()
11445 
11446 class UnboundedGridRangeKD(object):
11447  """Proxy of C++ IMP::algebra::UnboundedGridRangeD<(-1)> class"""
11448  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11449 
11450  def __init__(self, *args):
11451  """
11452  __init__(IMP::algebra::UnboundedGridRangeD<(-1)> self) -> UnboundedGridRangeKD
11453  __init__(IMP::algebra::UnboundedGridRangeD<(-1)> self, IMP::Ints const & arg2) -> UnboundedGridRangeKD
11454  """
11455  this = _IMP_algebra.new_UnboundedGridRangeKD(*args)
11456  try:
11457  self.this.append(this)
11458  except:
11459  self.this = this
11460 
11461  def set_number_of_voxels(self, arg2):
11462  """set_number_of_voxels(UnboundedGridRangeKD self, IMP::Ints arg2)"""
11463  return _IMP_algebra.UnboundedGridRangeKD_set_number_of_voxels(self, arg2)
11464 
11465 
11466  def get_number_of_voxels(self, arg2):
11467  """get_number_of_voxels(UnboundedGridRangeKD self, int arg2) -> unsigned int"""
11468  return _IMP_algebra.UnboundedGridRangeKD_get_number_of_voxels(self, arg2)
11469 
11470 
11471  def get_is_bounded():
11472  """get_is_bounded() -> bool"""
11473  return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
11474 
11475  get_is_bounded = staticmethod(get_is_bounded)
11476 
11477  def get_has_index(self, arg2):
11478  """get_has_index(UnboundedGridRangeKD self, ExtendedGridIndexKD arg2) -> bool"""
11479  return _IMP_algebra.UnboundedGridRangeKD_get_has_index(self, arg2)
11480 
11481 
11482  def show(self, *args):
11483  """
11484  show(UnboundedGridRangeKD self, _ostream out)
11485  show(UnboundedGridRangeKD self)
11486  """
11487  return _IMP_algebra.UnboundedGridRangeKD_show(self, *args)
11488 
11489 
11490  def get_extended_indexes(self, lb, ub):
11491  """get_extended_indexes(UnboundedGridRangeKD self, ExtendedGridIndexKD lb, ExtendedGridIndexKD ub) -> IMP::Vector< IMP::algebra::ExtendedGridIndexD< -1 > >"""
11492  return _IMP_algebra.UnboundedGridRangeKD_get_extended_indexes(self, lb, ub)
11493 
11494 
11495  def __str__(self):
11496  """__str__(UnboundedGridRangeKD self) -> std::string"""
11497  return _IMP_algebra.UnboundedGridRangeKD___str__(self)
11498 
11499 
11500  def __repr__(self):
11501  """__repr__(UnboundedGridRangeKD self) -> std::string"""
11502  return _IMP_algebra.UnboundedGridRangeKD___repr__(self)
11503 
11504 
11505  def __cmp__(self, arg2):
11506  """__cmp__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> int"""
11507  return _IMP_algebra.UnboundedGridRangeKD___cmp__(self, arg2)
11508 
11509 
11510  def __eq__(self, arg2):
11511  """__eq__(UnboundedGridRangeKD self, UnboundedGridRangeKD arg2) -> bool"""
11512  return _IMP_algebra.UnboundedGridRangeKD___eq__(self, arg2)
11513 
11514 
11515  def _get_as_binary(self):
11516  """_get_as_binary(UnboundedGridRangeKD self) -> PyObject *"""
11517  return _IMP_algebra.UnboundedGridRangeKD__get_as_binary(self)
11518 
11519 
11520  def _set_from_binary(self, p):
11521  """_set_from_binary(UnboundedGridRangeKD self, PyObject * p)"""
11522  return _IMP_algebra.UnboundedGridRangeKD__set_from_binary(self, p)
11523 
11524 
11525  def __getstate__(self):
11526  p = self._get_as_binary()
11527  if len(self.__dict__) > 1:
11528  d = self.__dict__.copy()
11529  del d['this']
11530  p = (d, p)
11531  return p
11532 
11533  def __setstate__(self, p):
11534  if not hasattr(self, 'this'):
11535  self.__init__()
11536  if isinstance(p, tuple):
11537  d, p = p
11538  self.__dict__.update(d)
11539  return self._set_from_binary(p)
11540 
11541  __swig_destroy__ = _IMP_algebra.delete_UnboundedGridRangeKD
11542  __del__ = lambda self: None
11543 UnboundedGridRangeKD_swigregister = _IMP_algebra.UnboundedGridRangeKD_swigregister
11544 UnboundedGridRangeKD_swigregister(UnboundedGridRangeKD)
11545 
11546 def UnboundedGridRangeKD_get_is_bounded():
11547  """UnboundedGridRangeKD_get_is_bounded() -> bool"""
11548  return _IMP_algebra.UnboundedGridRangeKD_get_is_bounded()
11549 
11550 class DefaultEmbedding1D(object):
11551  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(1)> class"""
11552  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11553 
11554  def __init__(self, *args):
11555  """
11556  __init__(IMP::algebra::DefaultEmbeddingD<(1)> self, Vector1D origin, Vector1D cell) -> DefaultEmbedding1D
11557  __init__(IMP::algebra::DefaultEmbeddingD<(1)> self) -> DefaultEmbedding1D
11558  """
11559  this = _IMP_algebra.new_DefaultEmbedding1D(*args)
11560  try:
11561  self.this.append(this)
11562  except:
11563  self.this = this
11564 
11565  def set_origin(self, o):
11566  """set_origin(DefaultEmbedding1D self, Vector1D o)"""
11567  return _IMP_algebra.DefaultEmbedding1D_set_origin(self, o)
11568 
11569 
11570  def get_origin(self):
11571  """get_origin(DefaultEmbedding1D self) -> Vector1D"""
11572  return _IMP_algebra.DefaultEmbedding1D_get_origin(self)
11573 
11574 
11575  def get_dimension(self):
11576  """get_dimension(DefaultEmbedding1D self) -> unsigned int"""
11577  return _IMP_algebra.DefaultEmbedding1D_get_dimension(self)
11578 
11579 
11580  def set_unit_cell(self, o):
11581  """set_unit_cell(DefaultEmbedding1D self, Vector1D o)"""
11582  return _IMP_algebra.DefaultEmbedding1D_set_unit_cell(self, o)
11583 
11584 
11585  def get_inverse_unit_cell(self):
11586  """get_inverse_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
11587  return _IMP_algebra.DefaultEmbedding1D_get_inverse_unit_cell(self)
11588 
11589 
11590  def get_unit_cell(self):
11591  """get_unit_cell(DefaultEmbedding1D self) -> Vector1D"""
11592  return _IMP_algebra.DefaultEmbedding1D_get_unit_cell(self)
11593 
11594 
11595  def get_extended_index(self, o):
11596  """get_extended_index(DefaultEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
11597  return _IMP_algebra.DefaultEmbedding1D_get_extended_index(self, o)
11598 
11599 
11600  def get_index(self, o):
11601  """get_index(DefaultEmbedding1D self, Vector1D o) -> GridIndex1D"""
11602  return _IMP_algebra.DefaultEmbedding1D_get_index(self, o)
11603 
11604 
11605  def get_center(self, *args):
11606  """
11607  get_center(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
11608  get_center(DefaultEmbedding1D self, GridIndex1D ei) -> Vector1D
11609  """
11610  return _IMP_algebra.DefaultEmbedding1D_get_center(self, *args)
11611 
11612 
11613  def get_bounding_box(self, *args):
11614  """
11615  get_bounding_box(DefaultEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
11616  get_bounding_box(DefaultEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
11617  """
11618  return _IMP_algebra.DefaultEmbedding1D_get_bounding_box(self, *args)
11619 
11620 
11621  def show(self, *args):
11622  """
11623  show(DefaultEmbedding1D self, _ostream out)
11624  show(DefaultEmbedding1D self)
11625  """
11626  return _IMP_algebra.DefaultEmbedding1D_show(self, *args)
11627 
11628 
11629  def __str__(self):
11630  """__str__(DefaultEmbedding1D self) -> std::string"""
11631  return _IMP_algebra.DefaultEmbedding1D___str__(self)
11632 
11633 
11634  def __repr__(self):
11635  """__repr__(DefaultEmbedding1D self) -> std::string"""
11636  return _IMP_algebra.DefaultEmbedding1D___repr__(self)
11637 
11638 
11639  def __cmp__(self, arg2):
11640  """__cmp__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> int"""
11641  return _IMP_algebra.DefaultEmbedding1D___cmp__(self, arg2)
11642 
11643 
11644  def __eq__(self, arg2):
11645  """__eq__(DefaultEmbedding1D self, DefaultEmbedding1D arg2) -> bool"""
11646  return _IMP_algebra.DefaultEmbedding1D___eq__(self, arg2)
11647 
11648 
11649  def _get_as_binary(self):
11650  """_get_as_binary(DefaultEmbedding1D self) -> PyObject *"""
11651  return _IMP_algebra.DefaultEmbedding1D__get_as_binary(self)
11652 
11653 
11654  def _set_from_binary(self, p):
11655  """_set_from_binary(DefaultEmbedding1D self, PyObject * p)"""
11656  return _IMP_algebra.DefaultEmbedding1D__set_from_binary(self, p)
11657 
11658 
11659  def __getstate__(self):
11660  p = self._get_as_binary()
11661  if len(self.__dict__) > 1:
11662  d = self.__dict__.copy()
11663  del d['this']
11664  p = (d, p)
11665  return p
11666 
11667  def __setstate__(self, p):
11668  if not hasattr(self, 'this'):
11669  self.__init__()
11670  if isinstance(p, tuple):
11671  d, p = p
11672  self.__dict__.update(d)
11673  return self._set_from_binary(p)
11674 
11675  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding1D
11676  __del__ = lambda self: None
11677 DefaultEmbedding1D_swigregister = _IMP_algebra.DefaultEmbedding1D_swigregister
11678 DefaultEmbedding1D_swigregister(DefaultEmbedding1D)
11679 
11680 class DefaultEmbedding2D(object):
11681  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(2)> class"""
11682  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11683 
11684  def __init__(self, *args):
11685  """
11686  __init__(IMP::algebra::DefaultEmbeddingD<(2)> self, Vector2D origin, Vector2D cell) -> DefaultEmbedding2D
11687  __init__(IMP::algebra::DefaultEmbeddingD<(2)> self) -> DefaultEmbedding2D
11688  """
11689  this = _IMP_algebra.new_DefaultEmbedding2D(*args)
11690  try:
11691  self.this.append(this)
11692  except:
11693  self.this = this
11694 
11695  def set_origin(self, o):
11696  """set_origin(DefaultEmbedding2D self, Vector2D o)"""
11697  return _IMP_algebra.DefaultEmbedding2D_set_origin(self, o)
11698 
11699 
11700  def get_origin(self):
11701  """get_origin(DefaultEmbedding2D self) -> Vector2D"""
11702  return _IMP_algebra.DefaultEmbedding2D_get_origin(self)
11703 
11704 
11705  def get_dimension(self):
11706  """get_dimension(DefaultEmbedding2D self) -> unsigned int"""
11707  return _IMP_algebra.DefaultEmbedding2D_get_dimension(self)
11708 
11709 
11710  def set_unit_cell(self, o):
11711  """set_unit_cell(DefaultEmbedding2D self, Vector2D o)"""
11712  return _IMP_algebra.DefaultEmbedding2D_set_unit_cell(self, o)
11713 
11714 
11715  def get_inverse_unit_cell(self):
11716  """get_inverse_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
11717  return _IMP_algebra.DefaultEmbedding2D_get_inverse_unit_cell(self)
11718 
11719 
11720  def get_unit_cell(self):
11721  """get_unit_cell(DefaultEmbedding2D self) -> Vector2D"""
11722  return _IMP_algebra.DefaultEmbedding2D_get_unit_cell(self)
11723 
11724 
11725  def get_extended_index(self, o):
11726  """get_extended_index(DefaultEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
11727  return _IMP_algebra.DefaultEmbedding2D_get_extended_index(self, o)
11728 
11729 
11730  def get_index(self, o):
11731  """get_index(DefaultEmbedding2D self, Vector2D o) -> GridIndex2D"""
11732  return _IMP_algebra.DefaultEmbedding2D_get_index(self, o)
11733 
11734 
11735  def get_center(self, *args):
11736  """
11737  get_center(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
11738  get_center(DefaultEmbedding2D self, GridIndex2D ei) -> Vector2D
11739  """
11740  return _IMP_algebra.DefaultEmbedding2D_get_center(self, *args)
11741 
11742 
11743  def get_bounding_box(self, *args):
11744  """
11745  get_bounding_box(DefaultEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
11746  get_bounding_box(DefaultEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
11747  """
11748  return _IMP_algebra.DefaultEmbedding2D_get_bounding_box(self, *args)
11749 
11750 
11751  def show(self, *args):
11752  """
11753  show(DefaultEmbedding2D self, _ostream out)
11754  show(DefaultEmbedding2D self)
11755  """
11756  return _IMP_algebra.DefaultEmbedding2D_show(self, *args)
11757 
11758 
11759  def __str__(self):
11760  """__str__(DefaultEmbedding2D self) -> std::string"""
11761  return _IMP_algebra.DefaultEmbedding2D___str__(self)
11762 
11763 
11764  def __repr__(self):
11765  """__repr__(DefaultEmbedding2D self) -> std::string"""
11766  return _IMP_algebra.DefaultEmbedding2D___repr__(self)
11767 
11768 
11769  def __cmp__(self, arg2):
11770  """__cmp__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> int"""
11771  return _IMP_algebra.DefaultEmbedding2D___cmp__(self, arg2)
11772 
11773 
11774  def __eq__(self, arg2):
11775  """__eq__(DefaultEmbedding2D self, DefaultEmbedding2D arg2) -> bool"""
11776  return _IMP_algebra.DefaultEmbedding2D___eq__(self, arg2)
11777 
11778 
11779  def _get_as_binary(self):
11780  """_get_as_binary(DefaultEmbedding2D self) -> PyObject *"""
11781  return _IMP_algebra.DefaultEmbedding2D__get_as_binary(self)
11782 
11783 
11784  def _set_from_binary(self, p):
11785  """_set_from_binary(DefaultEmbedding2D self, PyObject * p)"""
11786  return _IMP_algebra.DefaultEmbedding2D__set_from_binary(self, p)
11787 
11788 
11789  def __getstate__(self):
11790  p = self._get_as_binary()
11791  if len(self.__dict__) > 1:
11792  d = self.__dict__.copy()
11793  del d['this']
11794  p = (d, p)
11795  return p
11796 
11797  def __setstate__(self, p):
11798  if not hasattr(self, 'this'):
11799  self.__init__()
11800  if isinstance(p, tuple):
11801  d, p = p
11802  self.__dict__.update(d)
11803  return self._set_from_binary(p)
11804 
11805  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding2D
11806  __del__ = lambda self: None
11807 DefaultEmbedding2D_swigregister = _IMP_algebra.DefaultEmbedding2D_swigregister
11808 DefaultEmbedding2D_swigregister(DefaultEmbedding2D)
11809 
11810 class DefaultEmbedding3D(object):
11811  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(3)> class"""
11812  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11813 
11814  def __init__(self, *args):
11815  """
11816  __init__(IMP::algebra::DefaultEmbeddingD<(3)> self, Vector3D origin, Vector3D cell) -> DefaultEmbedding3D
11817  __init__(IMP::algebra::DefaultEmbeddingD<(3)> self) -> DefaultEmbedding3D
11818  """
11819  this = _IMP_algebra.new_DefaultEmbedding3D(*args)
11820  try:
11821  self.this.append(this)
11822  except:
11823  self.this = this
11824 
11825  def set_origin(self, o):
11826  """set_origin(DefaultEmbedding3D self, Vector3D o)"""
11827  return _IMP_algebra.DefaultEmbedding3D_set_origin(self, o)
11828 
11829 
11830  def get_origin(self):
11831  """get_origin(DefaultEmbedding3D self) -> Vector3D"""
11832  return _IMP_algebra.DefaultEmbedding3D_get_origin(self)
11833 
11834 
11835  def get_dimension(self):
11836  """get_dimension(DefaultEmbedding3D self) -> unsigned int"""
11837  return _IMP_algebra.DefaultEmbedding3D_get_dimension(self)
11838 
11839 
11840  def set_unit_cell(self, o):
11841  """set_unit_cell(DefaultEmbedding3D self, Vector3D o)"""
11842  return _IMP_algebra.DefaultEmbedding3D_set_unit_cell(self, o)
11843 
11844 
11845  def get_inverse_unit_cell(self):
11846  """get_inverse_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
11847  return _IMP_algebra.DefaultEmbedding3D_get_inverse_unit_cell(self)
11848 
11849 
11850  def get_unit_cell(self):
11851  """get_unit_cell(DefaultEmbedding3D self) -> Vector3D"""
11852  return _IMP_algebra.DefaultEmbedding3D_get_unit_cell(self)
11853 
11854 
11855  def get_extended_index(self, o):
11856  """get_extended_index(DefaultEmbedding3D self, Vector3D o) -> ExtendedGridIndex3D"""
11857  return _IMP_algebra.DefaultEmbedding3D_get_extended_index(self, o)
11858 
11859 
11860  def get_index(self, o):
11861  """get_index(DefaultEmbedding3D self, Vector3D o) -> GridIndex3D"""
11862  return _IMP_algebra.DefaultEmbedding3D_get_index(self, o)
11863 
11864 
11865  def get_center(self, *args):
11866  """
11867  get_center(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> Vector3D
11868  get_center(DefaultEmbedding3D self, GridIndex3D ei) -> Vector3D
11869  """
11870  return _IMP_algebra.DefaultEmbedding3D_get_center(self, *args)
11871 
11872 
11873  def get_bounding_box(self, *args):
11874  """
11875  get_bounding_box(DefaultEmbedding3D self, ExtendedGridIndex3D ei) -> BoundingBox3D
11876  get_bounding_box(DefaultEmbedding3D self, GridIndex3D ei) -> BoundingBox3D
11877  """
11878  return _IMP_algebra.DefaultEmbedding3D_get_bounding_box(self, *args)
11879 
11880 
11881  def show(self, *args):
11882  """
11883  show(DefaultEmbedding3D self, _ostream out)
11884  show(DefaultEmbedding3D self)
11885  """
11886  return _IMP_algebra.DefaultEmbedding3D_show(self, *args)
11887 
11888 
11889  def __str__(self):
11890  """__str__(DefaultEmbedding3D self) -> std::string"""
11891  return _IMP_algebra.DefaultEmbedding3D___str__(self)
11892 
11893 
11894  def __repr__(self):
11895  """__repr__(DefaultEmbedding3D self) -> std::string"""
11896  return _IMP_algebra.DefaultEmbedding3D___repr__(self)
11897 
11898 
11899  def __cmp__(self, arg2):
11900  """__cmp__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> int"""
11901  return _IMP_algebra.DefaultEmbedding3D___cmp__(self, arg2)
11902 
11903 
11904  def __eq__(self, arg2):
11905  """__eq__(DefaultEmbedding3D self, DefaultEmbedding3D arg2) -> bool"""
11906  return _IMP_algebra.DefaultEmbedding3D___eq__(self, arg2)
11907 
11908 
11909  def _get_as_binary(self):
11910  """_get_as_binary(DefaultEmbedding3D self) -> PyObject *"""
11911  return _IMP_algebra.DefaultEmbedding3D__get_as_binary(self)
11912 
11913 
11914  def _set_from_binary(self, p):
11915  """_set_from_binary(DefaultEmbedding3D self, PyObject * p)"""
11916  return _IMP_algebra.DefaultEmbedding3D__set_from_binary(self, p)
11917 
11918 
11919  def __getstate__(self):
11920  p = self._get_as_binary()
11921  if len(self.__dict__) > 1:
11922  d = self.__dict__.copy()
11923  del d['this']
11924  p = (d, p)
11925  return p
11926 
11927  def __setstate__(self, p):
11928  if not hasattr(self, 'this'):
11929  self.__init__()
11930  if isinstance(p, tuple):
11931  d, p = p
11932  self.__dict__.update(d)
11933  return self._set_from_binary(p)
11934 
11935  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding3D
11936  __del__ = lambda self: None
11937 DefaultEmbedding3D_swigregister = _IMP_algebra.DefaultEmbedding3D_swigregister
11938 DefaultEmbedding3D_swigregister(DefaultEmbedding3D)
11939 
11940 class DefaultEmbedding4D(object):
11941  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(4)> class"""
11942  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
11943 
11944  def __init__(self, *args):
11945  """
11946  __init__(IMP::algebra::DefaultEmbeddingD<(4)> self, Vector4D origin, Vector4D cell) -> DefaultEmbedding4D
11947  __init__(IMP::algebra::DefaultEmbeddingD<(4)> self) -> DefaultEmbedding4D
11948  """
11949  this = _IMP_algebra.new_DefaultEmbedding4D(*args)
11950  try:
11951  self.this.append(this)
11952  except:
11953  self.this = this
11954 
11955  def set_origin(self, o):
11956  """set_origin(DefaultEmbedding4D self, Vector4D o)"""
11957  return _IMP_algebra.DefaultEmbedding4D_set_origin(self, o)
11958 
11959 
11960  def get_origin(self):
11961  """get_origin(DefaultEmbedding4D self) -> Vector4D"""
11962  return _IMP_algebra.DefaultEmbedding4D_get_origin(self)
11963 
11964 
11965  def get_dimension(self):
11966  """get_dimension(DefaultEmbedding4D self) -> unsigned int"""
11967  return _IMP_algebra.DefaultEmbedding4D_get_dimension(self)
11968 
11969 
11970  def set_unit_cell(self, o):
11971  """set_unit_cell(DefaultEmbedding4D self, Vector4D o)"""
11972  return _IMP_algebra.DefaultEmbedding4D_set_unit_cell(self, o)
11973 
11974 
11975  def get_inverse_unit_cell(self):
11976  """get_inverse_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
11977  return _IMP_algebra.DefaultEmbedding4D_get_inverse_unit_cell(self)
11978 
11979 
11980  def get_unit_cell(self):
11981  """get_unit_cell(DefaultEmbedding4D self) -> Vector4D"""
11982  return _IMP_algebra.DefaultEmbedding4D_get_unit_cell(self)
11983 
11984 
11985  def get_extended_index(self, o):
11986  """get_extended_index(DefaultEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
11987  return _IMP_algebra.DefaultEmbedding4D_get_extended_index(self, o)
11988 
11989 
11990  def get_index(self, o):
11991  """get_index(DefaultEmbedding4D self, Vector4D o) -> GridIndex4D"""
11992  return _IMP_algebra.DefaultEmbedding4D_get_index(self, o)
11993 
11994 
11995  def get_center(self, *args):
11996  """
11997  get_center(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
11998  get_center(DefaultEmbedding4D self, GridIndex4D ei) -> Vector4D
11999  """
12000  return _IMP_algebra.DefaultEmbedding4D_get_center(self, *args)
12001 
12002 
12003  def get_bounding_box(self, *args):
12004  """
12005  get_bounding_box(DefaultEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
12006  get_bounding_box(DefaultEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
12007  """
12008  return _IMP_algebra.DefaultEmbedding4D_get_bounding_box(self, *args)
12009 
12010 
12011  def show(self, *args):
12012  """
12013  show(DefaultEmbedding4D self, _ostream out)
12014  show(DefaultEmbedding4D self)
12015  """
12016  return _IMP_algebra.DefaultEmbedding4D_show(self, *args)
12017 
12018 
12019  def __str__(self):
12020  """__str__(DefaultEmbedding4D self) -> std::string"""
12021  return _IMP_algebra.DefaultEmbedding4D___str__(self)
12022 
12023 
12024  def __repr__(self):
12025  """__repr__(DefaultEmbedding4D self) -> std::string"""
12026  return _IMP_algebra.DefaultEmbedding4D___repr__(self)
12027 
12028 
12029  def __cmp__(self, arg2):
12030  """__cmp__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> int"""
12031  return _IMP_algebra.DefaultEmbedding4D___cmp__(self, arg2)
12032 
12033 
12034  def __eq__(self, arg2):
12035  """__eq__(DefaultEmbedding4D self, DefaultEmbedding4D arg2) -> bool"""
12036  return _IMP_algebra.DefaultEmbedding4D___eq__(self, arg2)
12037 
12038 
12039  def _get_as_binary(self):
12040  """_get_as_binary(DefaultEmbedding4D self) -> PyObject *"""
12041  return _IMP_algebra.DefaultEmbedding4D__get_as_binary(self)
12042 
12043 
12044  def _set_from_binary(self, p):
12045  """_set_from_binary(DefaultEmbedding4D self, PyObject * p)"""
12046  return _IMP_algebra.DefaultEmbedding4D__set_from_binary(self, p)
12047 
12048 
12049  def __getstate__(self):
12050  p = self._get_as_binary()
12051  if len(self.__dict__) > 1:
12052  d = self.__dict__.copy()
12053  del d['this']
12054  p = (d, p)
12055  return p
12056 
12057  def __setstate__(self, p):
12058  if not hasattr(self, 'this'):
12059  self.__init__()
12060  if isinstance(p, tuple):
12061  d, p = p
12062  self.__dict__.update(d)
12063  return self._set_from_binary(p)
12064 
12065  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding4D
12066  __del__ = lambda self: None
12067 DefaultEmbedding4D_swigregister = _IMP_algebra.DefaultEmbedding4D_swigregister
12068 DefaultEmbedding4D_swigregister(DefaultEmbedding4D)
12069 
12070 class DefaultEmbedding5D(object):
12071  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(5)> class"""
12072  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12073 
12074  def __init__(self, *args):
12075  """
12076  __init__(IMP::algebra::DefaultEmbeddingD<(5)> self, Vector5D origin, Vector5D cell) -> DefaultEmbedding5D
12077  __init__(IMP::algebra::DefaultEmbeddingD<(5)> self) -> DefaultEmbedding5D
12078  """
12079  this = _IMP_algebra.new_DefaultEmbedding5D(*args)
12080  try:
12081  self.this.append(this)
12082  except:
12083  self.this = this
12084 
12085  def set_origin(self, o):
12086  """set_origin(DefaultEmbedding5D self, Vector5D o)"""
12087  return _IMP_algebra.DefaultEmbedding5D_set_origin(self, o)
12088 
12089 
12090  def get_origin(self):
12091  """get_origin(DefaultEmbedding5D self) -> Vector5D"""
12092  return _IMP_algebra.DefaultEmbedding5D_get_origin(self)
12093 
12094 
12095  def get_dimension(self):
12096  """get_dimension(DefaultEmbedding5D self) -> unsigned int"""
12097  return _IMP_algebra.DefaultEmbedding5D_get_dimension(self)
12098 
12099 
12100  def set_unit_cell(self, o):
12101  """set_unit_cell(DefaultEmbedding5D self, Vector5D o)"""
12102  return _IMP_algebra.DefaultEmbedding5D_set_unit_cell(self, o)
12103 
12104 
12105  def get_inverse_unit_cell(self):
12106  """get_inverse_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
12107  return _IMP_algebra.DefaultEmbedding5D_get_inverse_unit_cell(self)
12108 
12109 
12110  def get_unit_cell(self):
12111  """get_unit_cell(DefaultEmbedding5D self) -> Vector5D"""
12112  return _IMP_algebra.DefaultEmbedding5D_get_unit_cell(self)
12113 
12114 
12115  def get_extended_index(self, o):
12116  """get_extended_index(DefaultEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
12117  return _IMP_algebra.DefaultEmbedding5D_get_extended_index(self, o)
12118 
12119 
12120  def get_index(self, o):
12121  """get_index(DefaultEmbedding5D self, Vector5D o) -> GridIndex5D"""
12122  return _IMP_algebra.DefaultEmbedding5D_get_index(self, o)
12123 
12124 
12125  def get_center(self, *args):
12126  """
12127  get_center(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
12128  get_center(DefaultEmbedding5D self, GridIndex5D ei) -> Vector5D
12129  """
12130  return _IMP_algebra.DefaultEmbedding5D_get_center(self, *args)
12131 
12132 
12133  def get_bounding_box(self, *args):
12134  """
12135  get_bounding_box(DefaultEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
12136  get_bounding_box(DefaultEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
12137  """
12138  return _IMP_algebra.DefaultEmbedding5D_get_bounding_box(self, *args)
12139 
12140 
12141  def show(self, *args):
12142  """
12143  show(DefaultEmbedding5D self, _ostream out)
12144  show(DefaultEmbedding5D self)
12145  """
12146  return _IMP_algebra.DefaultEmbedding5D_show(self, *args)
12147 
12148 
12149  def __str__(self):
12150  """__str__(DefaultEmbedding5D self) -> std::string"""
12151  return _IMP_algebra.DefaultEmbedding5D___str__(self)
12152 
12153 
12154  def __repr__(self):
12155  """__repr__(DefaultEmbedding5D self) -> std::string"""
12156  return _IMP_algebra.DefaultEmbedding5D___repr__(self)
12157 
12158 
12159  def __cmp__(self, arg2):
12160  """__cmp__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> int"""
12161  return _IMP_algebra.DefaultEmbedding5D___cmp__(self, arg2)
12162 
12163 
12164  def __eq__(self, arg2):
12165  """__eq__(DefaultEmbedding5D self, DefaultEmbedding5D arg2) -> bool"""
12166  return _IMP_algebra.DefaultEmbedding5D___eq__(self, arg2)
12167 
12168 
12169  def _get_as_binary(self):
12170  """_get_as_binary(DefaultEmbedding5D self) -> PyObject *"""
12171  return _IMP_algebra.DefaultEmbedding5D__get_as_binary(self)
12172 
12173 
12174  def _set_from_binary(self, p):
12175  """_set_from_binary(DefaultEmbedding5D self, PyObject * p)"""
12176  return _IMP_algebra.DefaultEmbedding5D__set_from_binary(self, p)
12177 
12178 
12179  def __getstate__(self):
12180  p = self._get_as_binary()
12181  if len(self.__dict__) > 1:
12182  d = self.__dict__.copy()
12183  del d['this']
12184  p = (d, p)
12185  return p
12186 
12187  def __setstate__(self, p):
12188  if not hasattr(self, 'this'):
12189  self.__init__()
12190  if isinstance(p, tuple):
12191  d, p = p
12192  self.__dict__.update(d)
12193  return self._set_from_binary(p)
12194 
12195  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding5D
12196  __del__ = lambda self: None
12197 DefaultEmbedding5D_swigregister = _IMP_algebra.DefaultEmbedding5D_swigregister
12198 DefaultEmbedding5D_swigregister(DefaultEmbedding5D)
12199 
12200 class DefaultEmbedding6D(object):
12201  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(6)> class"""
12202  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12203 
12204  def __init__(self, *args):
12205  """
12206  __init__(IMP::algebra::DefaultEmbeddingD<(6)> self, Vector6D origin, Vector6D cell) -> DefaultEmbedding6D
12207  __init__(IMP::algebra::DefaultEmbeddingD<(6)> self) -> DefaultEmbedding6D
12208  """
12209  this = _IMP_algebra.new_DefaultEmbedding6D(*args)
12210  try:
12211  self.this.append(this)
12212  except:
12213  self.this = this
12214 
12215  def set_origin(self, o):
12216  """set_origin(DefaultEmbedding6D self, Vector6D o)"""
12217  return _IMP_algebra.DefaultEmbedding6D_set_origin(self, o)
12218 
12219 
12220  def get_origin(self):
12221  """get_origin(DefaultEmbedding6D self) -> Vector6D"""
12222  return _IMP_algebra.DefaultEmbedding6D_get_origin(self)
12223 
12224 
12225  def get_dimension(self):
12226  """get_dimension(DefaultEmbedding6D self) -> unsigned int"""
12227  return _IMP_algebra.DefaultEmbedding6D_get_dimension(self)
12228 
12229 
12230  def set_unit_cell(self, o):
12231  """set_unit_cell(DefaultEmbedding6D self, Vector6D o)"""
12232  return _IMP_algebra.DefaultEmbedding6D_set_unit_cell(self, o)
12233 
12234 
12235  def get_inverse_unit_cell(self):
12236  """get_inverse_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
12237  return _IMP_algebra.DefaultEmbedding6D_get_inverse_unit_cell(self)
12238 
12239 
12240  def get_unit_cell(self):
12241  """get_unit_cell(DefaultEmbedding6D self) -> Vector6D"""
12242  return _IMP_algebra.DefaultEmbedding6D_get_unit_cell(self)
12243 
12244 
12245  def get_extended_index(self, o):
12246  """get_extended_index(DefaultEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
12247  return _IMP_algebra.DefaultEmbedding6D_get_extended_index(self, o)
12248 
12249 
12250  def get_index(self, o):
12251  """get_index(DefaultEmbedding6D self, Vector6D o) -> GridIndex6D"""
12252  return _IMP_algebra.DefaultEmbedding6D_get_index(self, o)
12253 
12254 
12255  def get_center(self, *args):
12256  """
12257  get_center(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
12258  get_center(DefaultEmbedding6D self, GridIndex6D ei) -> Vector6D
12259  """
12260  return _IMP_algebra.DefaultEmbedding6D_get_center(self, *args)
12261 
12262 
12263  def get_bounding_box(self, *args):
12264  """
12265  get_bounding_box(DefaultEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
12266  get_bounding_box(DefaultEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
12267  """
12268  return _IMP_algebra.DefaultEmbedding6D_get_bounding_box(self, *args)
12269 
12270 
12271  def show(self, *args):
12272  """
12273  show(DefaultEmbedding6D self, _ostream out)
12274  show(DefaultEmbedding6D self)
12275  """
12276  return _IMP_algebra.DefaultEmbedding6D_show(self, *args)
12277 
12278 
12279  def __str__(self):
12280  """__str__(DefaultEmbedding6D self) -> std::string"""
12281  return _IMP_algebra.DefaultEmbedding6D___str__(self)
12282 
12283 
12284  def __repr__(self):
12285  """__repr__(DefaultEmbedding6D self) -> std::string"""
12286  return _IMP_algebra.DefaultEmbedding6D___repr__(self)
12287 
12288 
12289  def __cmp__(self, arg2):
12290  """__cmp__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> int"""
12291  return _IMP_algebra.DefaultEmbedding6D___cmp__(self, arg2)
12292 
12293 
12294  def __eq__(self, arg2):
12295  """__eq__(DefaultEmbedding6D self, DefaultEmbedding6D arg2) -> bool"""
12296  return _IMP_algebra.DefaultEmbedding6D___eq__(self, arg2)
12297 
12298 
12299  def _get_as_binary(self):
12300  """_get_as_binary(DefaultEmbedding6D self) -> PyObject *"""
12301  return _IMP_algebra.DefaultEmbedding6D__get_as_binary(self)
12302 
12303 
12304  def _set_from_binary(self, p):
12305  """_set_from_binary(DefaultEmbedding6D self, PyObject * p)"""
12306  return _IMP_algebra.DefaultEmbedding6D__set_from_binary(self, p)
12307 
12308 
12309  def __getstate__(self):
12310  p = self._get_as_binary()
12311  if len(self.__dict__) > 1:
12312  d = self.__dict__.copy()
12313  del d['this']
12314  p = (d, p)
12315  return p
12316 
12317  def __setstate__(self, p):
12318  if not hasattr(self, 'this'):
12319  self.__init__()
12320  if isinstance(p, tuple):
12321  d, p = p
12322  self.__dict__.update(d)
12323  return self._set_from_binary(p)
12324 
12325  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbedding6D
12326  __del__ = lambda self: None
12327 DefaultEmbedding6D_swigregister = _IMP_algebra.DefaultEmbedding6D_swigregister
12328 DefaultEmbedding6D_swigregister(DefaultEmbedding6D)
12329 
12330 class DefaultEmbeddingKD(object):
12331  """Proxy of C++ IMP::algebra::DefaultEmbeddingD<(-1)> class"""
12332  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12333 
12334  def __init__(self, *args):
12335  """
12336  __init__(IMP::algebra::DefaultEmbeddingD<(-1)> self, VectorKD origin, VectorKD cell) -> DefaultEmbeddingKD
12337  __init__(IMP::algebra::DefaultEmbeddingD<(-1)> self) -> DefaultEmbeddingKD
12338  """
12339  this = _IMP_algebra.new_DefaultEmbeddingKD(*args)
12340  try:
12341  self.this.append(this)
12342  except:
12343  self.this = this
12344 
12345  def set_origin(self, o):
12346  """set_origin(DefaultEmbeddingKD self, VectorKD o)"""
12347  return _IMP_algebra.DefaultEmbeddingKD_set_origin(self, o)
12348 
12349 
12350  def get_origin(self):
12351  """get_origin(DefaultEmbeddingKD self) -> VectorKD"""
12352  return _IMP_algebra.DefaultEmbeddingKD_get_origin(self)
12353 
12354 
12355  def get_dimension(self):
12356  """get_dimension(DefaultEmbeddingKD self) -> unsigned int"""
12357  return _IMP_algebra.DefaultEmbeddingKD_get_dimension(self)
12358 
12359 
12360  def set_unit_cell(self, o):
12361  """set_unit_cell(DefaultEmbeddingKD self, VectorKD o)"""
12362  return _IMP_algebra.DefaultEmbeddingKD_set_unit_cell(self, o)
12363 
12364 
12365  def get_inverse_unit_cell(self):
12366  """get_inverse_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
12367  return _IMP_algebra.DefaultEmbeddingKD_get_inverse_unit_cell(self)
12368 
12369 
12370  def get_unit_cell(self):
12371  """get_unit_cell(DefaultEmbeddingKD self) -> VectorKD"""
12372  return _IMP_algebra.DefaultEmbeddingKD_get_unit_cell(self)
12373 
12374 
12375  def get_extended_index(self, o):
12376  """get_extended_index(DefaultEmbeddingKD self, VectorKD o) -> ExtendedGridIndexKD"""
12377  return _IMP_algebra.DefaultEmbeddingKD_get_extended_index(self, o)
12378 
12379 
12380  def get_index(self, o):
12381  """get_index(DefaultEmbeddingKD self, VectorKD o) -> GridIndexKD"""
12382  return _IMP_algebra.DefaultEmbeddingKD_get_index(self, o)
12383 
12384 
12385  def get_center(self, *args):
12386  """
12387  get_center(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> VectorKD
12388  get_center(DefaultEmbeddingKD self, GridIndexKD ei) -> VectorKD
12389  """
12390  return _IMP_algebra.DefaultEmbeddingKD_get_center(self, *args)
12391 
12392 
12393  def get_bounding_box(self, *args):
12394  """
12395  get_bounding_box(DefaultEmbeddingKD self, ExtendedGridIndexKD ei) -> BoundingBoxKD
12396  get_bounding_box(DefaultEmbeddingKD self, GridIndexKD ei) -> BoundingBoxKD
12397  """
12398  return _IMP_algebra.DefaultEmbeddingKD_get_bounding_box(self, *args)
12399 
12400 
12401  def show(self, *args):
12402  """
12403  show(DefaultEmbeddingKD self, _ostream out)
12404  show(DefaultEmbeddingKD self)
12405  """
12406  return _IMP_algebra.DefaultEmbeddingKD_show(self, *args)
12407 
12408 
12409  def __str__(self):
12410  """__str__(DefaultEmbeddingKD self) -> std::string"""
12411  return _IMP_algebra.DefaultEmbeddingKD___str__(self)
12412 
12413 
12414  def __repr__(self):
12415  """__repr__(DefaultEmbeddingKD self) -> std::string"""
12416  return _IMP_algebra.DefaultEmbeddingKD___repr__(self)
12417 
12418 
12419  def __cmp__(self, arg2):
12420  """__cmp__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> int"""
12421  return _IMP_algebra.DefaultEmbeddingKD___cmp__(self, arg2)
12422 
12423 
12424  def __eq__(self, arg2):
12425  """__eq__(DefaultEmbeddingKD self, DefaultEmbeddingKD arg2) -> bool"""
12426  return _IMP_algebra.DefaultEmbeddingKD___eq__(self, arg2)
12427 
12428 
12429  def _get_as_binary(self):
12430  """_get_as_binary(DefaultEmbeddingKD self) -> PyObject *"""
12431  return _IMP_algebra.DefaultEmbeddingKD__get_as_binary(self)
12432 
12433 
12434  def _set_from_binary(self, p):
12435  """_set_from_binary(DefaultEmbeddingKD self, PyObject * p)"""
12436  return _IMP_algebra.DefaultEmbeddingKD__set_from_binary(self, p)
12437 
12438 
12439  def __getstate__(self):
12440  p = self._get_as_binary()
12441  if len(self.__dict__) > 1:
12442  d = self.__dict__.copy()
12443  del d['this']
12444  p = (d, p)
12445  return p
12446 
12447  def __setstate__(self, p):
12448  if not hasattr(self, 'this'):
12449  self.__init__()
12450  if isinstance(p, tuple):
12451  d, p = p
12452  self.__dict__.update(d)
12453  return self._set_from_binary(p)
12454 
12455  __swig_destroy__ = _IMP_algebra.delete_DefaultEmbeddingKD
12456  __del__ = lambda self: None
12457 DefaultEmbeddingKD_swigregister = _IMP_algebra.DefaultEmbeddingKD_swigregister
12458 DefaultEmbeddingKD_swigregister(DefaultEmbeddingKD)
12459 
12460 class LogEmbedding1D(object):
12461  """Proxy of C++ IMP::algebra::LogEmbeddingD<(1)> class"""
12462  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12463 
12464  def __init__(self, *args):
12465  """
12466  __init__(IMP::algebra::LogEmbeddingD<(1)> self, Vector1D origin, Vector1D cell, Vector1D base) -> LogEmbedding1D
12467  __init__(IMP::algebra::LogEmbeddingD<(1)> self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding1D
12468  __init__(IMP::algebra::LogEmbeddingD<(1)> self, BoundingBox1D bb, Vector1D bases, IMP::Ints const & counts) -> LogEmbedding1D
12469  __init__(IMP::algebra::LogEmbeddingD<(1)> self, Vector1D arg2, Vector1D arg3) -> LogEmbedding1D
12470  __init__(IMP::algebra::LogEmbeddingD<(1)> self) -> LogEmbedding1D
12471  """
12472  this = _IMP_algebra.new_LogEmbedding1D(*args)
12473  try:
12474  self.this.append(this)
12475  except:
12476  self.this = this
12477 
12478  def set_origin(self, o):
12479  """set_origin(LogEmbedding1D self, Vector1D o)"""
12480  return _IMP_algebra.LogEmbedding1D_set_origin(self, o)
12481 
12482 
12483  def get_origin(self):
12484  """get_origin(LogEmbedding1D self) -> Vector1D"""
12485  return _IMP_algebra.LogEmbedding1D_get_origin(self)
12486 
12487 
12488  def get_dimension(self):
12489  """get_dimension(LogEmbedding1D self) -> unsigned int"""
12490  return _IMP_algebra.LogEmbedding1D_get_dimension(self)
12491 
12492 
12493  def set_unit_cell(self, *args):
12494  """
12495  set_unit_cell(LogEmbedding1D self, Vector1D o, Vector1D base)
12496  set_unit_cell(LogEmbedding1D self, Vector1D o)
12497  """
12498  return _IMP_algebra.LogEmbedding1D_set_unit_cell(self, *args)
12499 
12500 
12501  def get_unit_cell(self):
12502  """get_unit_cell(LogEmbedding1D self) -> Vector1D"""
12503  return _IMP_algebra.LogEmbedding1D_get_unit_cell(self)
12504 
12505 
12506  def get_extended_index(self, o):
12507  """get_extended_index(LogEmbedding1D self, Vector1D o) -> ExtendedGridIndex1D"""
12508  return _IMP_algebra.LogEmbedding1D_get_extended_index(self, o)
12509 
12510 
12511  def get_index(self, o):
12512  """get_index(LogEmbedding1D self, Vector1D o) -> GridIndex1D"""
12513  return _IMP_algebra.LogEmbedding1D_get_index(self, o)
12514 
12515 
12516  def get_center(self, *args):
12517  """
12518  get_center(LogEmbedding1D self, ExtendedGridIndex1D ei) -> Vector1D
12519  get_center(LogEmbedding1D self, GridIndex1D ei) -> Vector1D
12520  """
12521  return _IMP_algebra.LogEmbedding1D_get_center(self, *args)
12522 
12523 
12524  def get_bounding_box(self, *args):
12525  """
12526  get_bounding_box(LogEmbedding1D self, ExtendedGridIndex1D ei) -> BoundingBox1D
12527  get_bounding_box(LogEmbedding1D self, GridIndex1D ei) -> BoundingBox1D
12528  """
12529  return _IMP_algebra.LogEmbedding1D_get_bounding_box(self, *args)
12530 
12531 
12532  def show(self, *args):
12533  """
12534  show(LogEmbedding1D self, _ostream out)
12535  show(LogEmbedding1D self)
12536  """
12537  return _IMP_algebra.LogEmbedding1D_show(self, *args)
12538 
12539 
12540  def __str__(self):
12541  """__str__(LogEmbedding1D self) -> std::string"""
12542  return _IMP_algebra.LogEmbedding1D___str__(self)
12543 
12544 
12545  def __repr__(self):
12546  """__repr__(LogEmbedding1D self) -> std::string"""
12547  return _IMP_algebra.LogEmbedding1D___repr__(self)
12548 
12549 
12550  def __cmp__(self, arg2):
12551  """__cmp__(LogEmbedding1D self, LogEmbedding1D arg2) -> int"""
12552  return _IMP_algebra.LogEmbedding1D___cmp__(self, arg2)
12553 
12554 
12555  def __eq__(self, arg2):
12556  """__eq__(LogEmbedding1D self, LogEmbedding1D arg2) -> bool"""
12557  return _IMP_algebra.LogEmbedding1D___eq__(self, arg2)
12558 
12559 
12560  def _get_as_binary(self):
12561  """_get_as_binary(LogEmbedding1D self) -> PyObject *"""
12562  return _IMP_algebra.LogEmbedding1D__get_as_binary(self)
12563 
12564 
12565  def _set_from_binary(self, p):
12566  """_set_from_binary(LogEmbedding1D self, PyObject * p)"""
12567  return _IMP_algebra.LogEmbedding1D__set_from_binary(self, p)
12568 
12569 
12570  def __getstate__(self):
12571  p = self._get_as_binary()
12572  if len(self.__dict__) > 1:
12573  d = self.__dict__.copy()
12574  del d['this']
12575  p = (d, p)
12576  return p
12577 
12578  def __setstate__(self, p):
12579  if not hasattr(self, 'this'):
12580  self.__init__()
12581  if isinstance(p, tuple):
12582  d, p = p
12583  self.__dict__.update(d)
12584  return self._set_from_binary(p)
12585 
12586  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding1D
12587  __del__ = lambda self: None
12588 LogEmbedding1D_swigregister = _IMP_algebra.LogEmbedding1D_swigregister
12589 LogEmbedding1D_swigregister(LogEmbedding1D)
12590 
12591 class LogEmbedding2D(object):
12592  """Proxy of C++ IMP::algebra::LogEmbeddingD<(2)> class"""
12593  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12594 
12595  def __init__(self, *args):
12596  """
12597  __init__(IMP::algebra::LogEmbeddingD<(2)> self, Vector2D origin, Vector2D cell, Vector2D base) -> LogEmbedding2D
12598  __init__(IMP::algebra::LogEmbeddingD<(2)> self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding2D
12599  __init__(IMP::algebra::LogEmbeddingD<(2)> self, BoundingBox2D bb, Vector2D bases, IMP::Ints const & counts) -> LogEmbedding2D
12600  __init__(IMP::algebra::LogEmbeddingD<(2)> self, Vector2D arg2, Vector2D arg3) -> LogEmbedding2D
12601  __init__(IMP::algebra::LogEmbeddingD<(2)> self) -> LogEmbedding2D
12602  """
12603  this = _IMP_algebra.new_LogEmbedding2D(*args)
12604  try:
12605  self.this.append(this)
12606  except:
12607  self.this = this
12608 
12609  def set_origin(self, o):
12610  """set_origin(LogEmbedding2D self, Vector2D o)"""
12611  return _IMP_algebra.LogEmbedding2D_set_origin(self, o)
12612 
12613 
12614  def get_origin(self):
12615  """get_origin(LogEmbedding2D self) -> Vector2D"""
12616  return _IMP_algebra.LogEmbedding2D_get_origin(self)
12617 
12618 
12619  def get_dimension(self):
12620  """get_dimension(LogEmbedding2D self) -> unsigned int"""
12621  return _IMP_algebra.LogEmbedding2D_get_dimension(self)
12622 
12623 
12624  def set_unit_cell(self, *args):
12625  """
12626  set_unit_cell(LogEmbedding2D self, Vector2D o, Vector2D base)
12627  set_unit_cell(LogEmbedding2D self, Vector2D o)
12628  """
12629  return _IMP_algebra.LogEmbedding2D_set_unit_cell(self, *args)
12630 
12631 
12632  def get_unit_cell(self):
12633  """get_unit_cell(LogEmbedding2D self) -> Vector2D"""
12634  return _IMP_algebra.LogEmbedding2D_get_unit_cell(self)
12635 
12636 
12637  def get_extended_index(self, o):
12638  """get_extended_index(LogEmbedding2D self, Vector2D o) -> ExtendedGridIndex2D"""
12639  return _IMP_algebra.LogEmbedding2D_get_extended_index(self, o)
12640 
12641 
12642  def get_index(self, o):
12643  """get_index(LogEmbedding2D self, Vector2D o) -> GridIndex2D"""
12644  return _IMP_algebra.LogEmbedding2D_get_index(self, o)
12645 
12646 
12647  def get_center(self, *args):
12648  """
12649  get_center(LogEmbedding2D self, ExtendedGridIndex2D ei) -> Vector2D
12650  get_center(LogEmbedding2D self, GridIndex2D ei) -> Vector2D
12651  """
12652  return _IMP_algebra.LogEmbedding2D_get_center(self, *args)
12653 
12654 
12655  def get_bounding_box(self, *args):
12656  """
12657  get_bounding_box(LogEmbedding2D self, ExtendedGridIndex2D ei) -> BoundingBox2D
12658  get_bounding_box(LogEmbedding2D self, GridIndex2D ei) -> BoundingBox2D
12659  """
12660  return _IMP_algebra.LogEmbedding2D_get_bounding_box(self, *args)
12661 
12662 
12663  def show(self, *args):
12664  """
12665  show(LogEmbedding2D self, _ostream out)
12666  show(LogEmbedding2D self)
12667  """
12668  return _IMP_algebra.LogEmbedding2D_show(self, *args)
12669 
12670 
12671  def __str__(self):
12672  """__str__(LogEmbedding2D self) -> std::string"""
12673  return _IMP_algebra.LogEmbedding2D___str__(self)
12674 
12675 
12676  def __repr__(self):
12677  """__repr__(LogEmbedding2D self) -> std::string"""
12678  return _IMP_algebra.LogEmbedding2D___repr__(self)
12679 
12680 
12681  def __cmp__(self, arg2):
12682  """__cmp__(LogEmbedding2D self, LogEmbedding2D arg2) -> int"""
12683  return _IMP_algebra.LogEmbedding2D___cmp__(self, arg2)
12684 
12685 
12686  def __eq__(self, arg2):
12687  """__eq__(LogEmbedding2D self, LogEmbedding2D arg2) -> bool"""
12688  return _IMP_algebra.LogEmbedding2D___eq__(self, arg2)
12689 
12690 
12691  def _get_as_binary(self):
12692  """_get_as_binary(LogEmbedding2D self) -> PyObject *"""
12693  return _IMP_algebra.LogEmbedding2D__get_as_binary(self)
12694 
12695 
12696  def _set_from_binary(self, p):
12697  """_set_from_binary(LogEmbedding2D self, PyObject * p)"""
12698  return _IMP_algebra.LogEmbedding2D__set_from_binary(self, p)
12699 
12700 
12701  def __getstate__(self):
12702  p = self._get_as_binary()
12703  if len(self.__dict__) > 1:
12704  d = self.__dict__.copy()
12705  del d['this']
12706  p = (d, p)
12707  return p
12708 
12709  def __setstate__(self, p):
12710  if not hasattr(self, 'this'):
12711  self.__init__()
12712  if isinstance(p, tuple):
12713  d, p = p
12714  self.__dict__.update(d)
12715  return self._set_from_binary(p)
12716 
12717  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding2D
12718  __del__ = lambda self: None
12719 LogEmbedding2D_swigregister = _IMP_algebra.LogEmbedding2D_swigregister
12720 LogEmbedding2D_swigregister(LogEmbedding2D)
12721 
12722 class LogEmbedding4D(object):
12723  """Proxy of C++ IMP::algebra::LogEmbeddingD<(4)> class"""
12724  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12725 
12726  def __init__(self, *args):
12727  """
12728  __init__(IMP::algebra::LogEmbeddingD<(4)> self, Vector4D origin, Vector4D cell, Vector4D base) -> LogEmbedding4D
12729  __init__(IMP::algebra::LogEmbeddingD<(4)> self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding4D
12730  __init__(IMP::algebra::LogEmbeddingD<(4)> self, BoundingBox4D bb, Vector4D bases, IMP::Ints const & counts) -> LogEmbedding4D
12731  __init__(IMP::algebra::LogEmbeddingD<(4)> self, Vector4D arg2, Vector4D arg3) -> LogEmbedding4D
12732  __init__(IMP::algebra::LogEmbeddingD<(4)> self) -> LogEmbedding4D
12733  """
12734  this = _IMP_algebra.new_LogEmbedding4D(*args)
12735  try:
12736  self.this.append(this)
12737  except:
12738  self.this = this
12739 
12740  def set_origin(self, o):
12741  """set_origin(LogEmbedding4D self, Vector4D o)"""
12742  return _IMP_algebra.LogEmbedding4D_set_origin(self, o)
12743 
12744 
12745  def get_origin(self):
12746  """get_origin(LogEmbedding4D self) -> Vector4D"""
12747  return _IMP_algebra.LogEmbedding4D_get_origin(self)
12748 
12749 
12750  def get_dimension(self):
12751  """get_dimension(LogEmbedding4D self) -> unsigned int"""
12752  return _IMP_algebra.LogEmbedding4D_get_dimension(self)
12753 
12754 
12755  def set_unit_cell(self, *args):
12756  """
12757  set_unit_cell(LogEmbedding4D self, Vector4D o, Vector4D base)
12758  set_unit_cell(LogEmbedding4D self, Vector4D o)
12759  """
12760  return _IMP_algebra.LogEmbedding4D_set_unit_cell(self, *args)
12761 
12762 
12763  def get_unit_cell(self):
12764  """get_unit_cell(LogEmbedding4D self) -> Vector4D"""
12765  return _IMP_algebra.LogEmbedding4D_get_unit_cell(self)
12766 
12767 
12768  def get_extended_index(self, o):
12769  """get_extended_index(LogEmbedding4D self, Vector4D o) -> ExtendedGridIndex4D"""
12770  return _IMP_algebra.LogEmbedding4D_get_extended_index(self, o)
12771 
12772 
12773  def get_index(self, o):
12774  """get_index(LogEmbedding4D self, Vector4D o) -> GridIndex4D"""
12775  return _IMP_algebra.LogEmbedding4D_get_index(self, o)
12776 
12777 
12778  def get_center(self, *args):
12779  """
12780  get_center(LogEmbedding4D self, ExtendedGridIndex4D ei) -> Vector4D
12781  get_center(LogEmbedding4D self, GridIndex4D ei) -> Vector4D
12782  """
12783  return _IMP_algebra.LogEmbedding4D_get_center(self, *args)
12784 
12785 
12786  def get_bounding_box(self, *args):
12787  """
12788  get_bounding_box(LogEmbedding4D self, ExtendedGridIndex4D ei) -> BoundingBox4D
12789  get_bounding_box(LogEmbedding4D self, GridIndex4D ei) -> BoundingBox4D
12790  """
12791  return _IMP_algebra.LogEmbedding4D_get_bounding_box(self, *args)
12792 
12793 
12794  def show(self, *args):
12795  """
12796  show(LogEmbedding4D self, _ostream out)
12797  show(LogEmbedding4D self)
12798  """
12799  return _IMP_algebra.LogEmbedding4D_show(self, *args)
12800 
12801 
12802  def __str__(self):
12803  """__str__(LogEmbedding4D self) -> std::string"""
12804  return _IMP_algebra.LogEmbedding4D___str__(self)
12805 
12806 
12807  def __repr__(self):
12808  """__repr__(LogEmbedding4D self) -> std::string"""
12809  return _IMP_algebra.LogEmbedding4D___repr__(self)
12810 
12811 
12812  def __cmp__(self, arg2):
12813  """__cmp__(LogEmbedding4D self, LogEmbedding4D arg2) -> int"""
12814  return _IMP_algebra.LogEmbedding4D___cmp__(self, arg2)
12815 
12816 
12817  def __eq__(self, arg2):
12818  """__eq__(LogEmbedding4D self, LogEmbedding4D arg2) -> bool"""
12819  return _IMP_algebra.LogEmbedding4D___eq__(self, arg2)
12820 
12821 
12822  def _get_as_binary(self):
12823  """_get_as_binary(LogEmbedding4D self) -> PyObject *"""
12824  return _IMP_algebra.LogEmbedding4D__get_as_binary(self)
12825 
12826 
12827  def _set_from_binary(self, p):
12828  """_set_from_binary(LogEmbedding4D self, PyObject * p)"""
12829  return _IMP_algebra.LogEmbedding4D__set_from_binary(self, p)
12830 
12831 
12832  def __getstate__(self):
12833  p = self._get_as_binary()
12834  if len(self.__dict__) > 1:
12835  d = self.__dict__.copy()
12836  del d['this']
12837  p = (d, p)
12838  return p
12839 
12840  def __setstate__(self, p):
12841  if not hasattr(self, 'this'):
12842  self.__init__()
12843  if isinstance(p, tuple):
12844  d, p = p
12845  self.__dict__.update(d)
12846  return self._set_from_binary(p)
12847 
12848  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding4D
12849  __del__ = lambda self: None
12850 LogEmbedding4D_swigregister = _IMP_algebra.LogEmbedding4D_swigregister
12851 LogEmbedding4D_swigregister(LogEmbedding4D)
12852 
12853 class LogEmbedding5D(object):
12854  """Proxy of C++ IMP::algebra::LogEmbeddingD<(5)> class"""
12855  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12856 
12857  def __init__(self, *args):
12858  """
12859  __init__(IMP::algebra::LogEmbeddingD<(5)> self, Vector5D origin, Vector5D cell, Vector5D base) -> LogEmbedding5D
12860  __init__(IMP::algebra::LogEmbeddingD<(5)> self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding5D
12861  __init__(IMP::algebra::LogEmbeddingD<(5)> self, BoundingBox5D bb, Vector5D bases, IMP::Ints const & counts) -> LogEmbedding5D
12862  __init__(IMP::algebra::LogEmbeddingD<(5)> self, Vector5D arg2, Vector5D arg3) -> LogEmbedding5D
12863  __init__(IMP::algebra::LogEmbeddingD<(5)> self) -> LogEmbedding5D
12864  """
12865  this = _IMP_algebra.new_LogEmbedding5D(*args)
12866  try:
12867  self.this.append(this)
12868  except:
12869  self.this = this
12870 
12871  def set_origin(self, o):
12872  """set_origin(LogEmbedding5D self, Vector5D o)"""
12873  return _IMP_algebra.LogEmbedding5D_set_origin(self, o)
12874 
12875 
12876  def get_origin(self):
12877  """get_origin(LogEmbedding5D self) -> Vector5D"""
12878  return _IMP_algebra.LogEmbedding5D_get_origin(self)
12879 
12880 
12881  def get_dimension(self):
12882  """get_dimension(LogEmbedding5D self) -> unsigned int"""
12883  return _IMP_algebra.LogEmbedding5D_get_dimension(self)
12884 
12885 
12886  def set_unit_cell(self, *args):
12887  """
12888  set_unit_cell(LogEmbedding5D self, Vector5D o, Vector5D base)
12889  set_unit_cell(LogEmbedding5D self, Vector5D o)
12890  """
12891  return _IMP_algebra.LogEmbedding5D_set_unit_cell(self, *args)
12892 
12893 
12894  def get_unit_cell(self):
12895  """get_unit_cell(LogEmbedding5D self) -> Vector5D"""
12896  return _IMP_algebra.LogEmbedding5D_get_unit_cell(self)
12897 
12898 
12899  def get_extended_index(self, o):
12900  """get_extended_index(LogEmbedding5D self, Vector5D o) -> ExtendedGridIndex5D"""
12901  return _IMP_algebra.LogEmbedding5D_get_extended_index(self, o)
12902 
12903 
12904  def get_index(self, o):
12905  """get_index(LogEmbedding5D self, Vector5D o) -> GridIndex5D"""
12906  return _IMP_algebra.LogEmbedding5D_get_index(self, o)
12907 
12908 
12909  def get_center(self, *args):
12910  """
12911  get_center(LogEmbedding5D self, ExtendedGridIndex5D ei) -> Vector5D
12912  get_center(LogEmbedding5D self, GridIndex5D ei) -> Vector5D
12913  """
12914  return _IMP_algebra.LogEmbedding5D_get_center(self, *args)
12915 
12916 
12917  def get_bounding_box(self, *args):
12918  """
12919  get_bounding_box(LogEmbedding5D self, ExtendedGridIndex5D ei) -> BoundingBox5D
12920  get_bounding_box(LogEmbedding5D self, GridIndex5D ei) -> BoundingBox5D
12921  """
12922  return _IMP_algebra.LogEmbedding5D_get_bounding_box(self, *args)
12923 
12924 
12925  def show(self, *args):
12926  """
12927  show(LogEmbedding5D self, _ostream out)
12928  show(LogEmbedding5D self)
12929  """
12930  return _IMP_algebra.LogEmbedding5D_show(self, *args)
12931 
12932 
12933  def __str__(self):
12934  """__str__(LogEmbedding5D self) -> std::string"""
12935  return _IMP_algebra.LogEmbedding5D___str__(self)
12936 
12937 
12938  def __repr__(self):
12939  """__repr__(LogEmbedding5D self) -> std::string"""
12940  return _IMP_algebra.LogEmbedding5D___repr__(self)
12941 
12942 
12943  def __cmp__(self, arg2):
12944  """__cmp__(LogEmbedding5D self, LogEmbedding5D arg2) -> int"""
12945  return _IMP_algebra.LogEmbedding5D___cmp__(self, arg2)
12946 
12947 
12948  def __eq__(self, arg2):
12949  """__eq__(LogEmbedding5D self, LogEmbedding5D arg2) -> bool"""
12950  return _IMP_algebra.LogEmbedding5D___eq__(self, arg2)
12951 
12952 
12953  def _get_as_binary(self):
12954  """_get_as_binary(LogEmbedding5D self) -> PyObject *"""
12955  return _IMP_algebra.LogEmbedding5D__get_as_binary(self)
12956 
12957 
12958  def _set_from_binary(self, p):
12959  """_set_from_binary(LogEmbedding5D self, PyObject * p)"""
12960  return _IMP_algebra.LogEmbedding5D__set_from_binary(self, p)
12961 
12962 
12963  def __getstate__(self):
12964  p = self._get_as_binary()
12965  if len(self.__dict__) > 1:
12966  d = self.__dict__.copy()
12967  del d['this']
12968  p = (d, p)
12969  return p
12970 
12971  def __setstate__(self, p):
12972  if not hasattr(self, 'this'):
12973  self.__init__()
12974  if isinstance(p, tuple):
12975  d, p = p
12976  self.__dict__.update(d)
12977  return self._set_from_binary(p)
12978 
12979  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding5D
12980  __del__ = lambda self: None
12981 LogEmbedding5D_swigregister = _IMP_algebra.LogEmbedding5D_swigregister
12982 LogEmbedding5D_swigregister(LogEmbedding5D)
12983 
12984 class LogEmbedding6D(object):
12985  """Proxy of C++ IMP::algebra::LogEmbeddingD<(6)> class"""
12986  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
12987 
12988  def __init__(self, *args):
12989  """
12990  __init__(IMP::algebra::LogEmbeddingD<(6)> self, Vector6D origin, Vector6D cell, Vector6D base) -> LogEmbedding6D
12991  __init__(IMP::algebra::LogEmbeddingD<(6)> self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts, bool bound_centers=False) -> LogEmbedding6D
12992  __init__(IMP::algebra::LogEmbeddingD<(6)> self, BoundingBox6D bb, Vector6D bases, IMP::Ints const & counts) -> LogEmbedding6D
12993  __init__(IMP::algebra::LogEmbeddingD<(6)> self, Vector6D arg2, Vector6D arg3) -> LogEmbedding6D
12994  __init__(IMP::algebra::LogEmbeddingD<(6)> self) -> LogEmbedding6D
12995  """
12996  this = _IMP_algebra.new_LogEmbedding6D(*args)
12997  try:
12998  self.this.append(this)
12999  except:
13000  self.this = this
13001 
13002  def set_origin(self, o):
13003  """set_origin(LogEmbedding6D self, Vector6D o)"""
13004  return _IMP_algebra.LogEmbedding6D_set_origin(self, o)
13005 
13006 
13007  def get_origin(self):
13008  """get_origin(LogEmbedding6D self) -> Vector6D"""
13009  return _IMP_algebra.LogEmbedding6D_get_origin(self)
13010 
13011 
13012  def get_dimension(self):
13013  """get_dimension(LogEmbedding6D self) -> unsigned int"""
13014  return _IMP_algebra.LogEmbedding6D_get_dimension(self)
13015 
13016 
13017  def set_unit_cell(self, *args):
13018  """
13019  set_unit_cell(LogEmbedding6D self, Vector6D o, Vector6D base)
13020  set_unit_cell(LogEmbedding6D self, Vector6D o)
13021  """
13022  return _IMP_algebra.LogEmbedding6D_set_unit_cell(self, *args)
13023 
13024 
13025  def get_unit_cell(self):
13026  """get_unit_cell(LogEmbedding6D self) -> Vector6D"""
13027  return _IMP_algebra.LogEmbedding6D_get_unit_cell(self)
13028 
13029 
13030  def get_extended_index(self, o):
13031  """get_extended_index(LogEmbedding6D self, Vector6D o) -> ExtendedGridIndex6D"""
13032  return _IMP_algebra.LogEmbedding6D_get_extended_index(self, o)
13033 
13034 
13035  def get_index(self, o):
13036  """get_index(LogEmbedding6D self, Vector6D o) -> GridIndex6D"""
13037  return _IMP_algebra.LogEmbedding6D_get_index(self, o)
13038 
13039 
13040  def get_center(self, *args):
13041  """
13042  get_center(LogEmbedding6D self, ExtendedGridIndex6D ei) -> Vector6D
13043  get_center(LogEmbedding6D self, GridIndex6D ei) -> Vector6D
13044  """
13045  return _IMP_algebra.LogEmbedding6D_get_center(self, *args)
13046 
13047 
13048  def get_bounding_box(self, *args):
13049  """
13050  get_bounding_box(LogEmbedding6D self, ExtendedGridIndex6D ei) -> BoundingBox6D
13051  get_bounding_box(LogEmbedding6D self, GridIndex6D ei) -> BoundingBox6D
13052  """
13053  return _IMP_algebra.LogEmbedding6D_get_bounding_box(self, *args)
13054 
13055 
13056  def show(self, *args):
13057  """
13058  show(LogEmbedding6D self, _ostream out)
13059  show(LogEmbedding6D self)
13060  """
13061  return _IMP_algebra.LogEmbedding6D_show(self, *args)
13062 
13063 
13064  def __str__(self):
13065  """__str__(LogEmbedding6D self) -> std::string"""
13066  return _IMP_algebra.LogEmbedding6D___str__(self)
13067 
13068 
13069  def __repr__(self):
13070  """__repr__(LogEmbedding6D self) -> std::string"""
13071  return _IMP_algebra.LogEmbedding6D___repr__(self)
13072 
13073 
13074  def __cmp__(self, arg2):
13075  """__cmp__(LogEmbedding6D self, LogEmbedding6D arg2) -> int"""
13076  return _IMP_algebra.LogEmbedding6D___cmp__(self, arg2)
13077 
13078 
13079  def __eq__(self, arg2):
13080  """__eq__(LogEmbedding6D self, LogEmbedding6D arg2) -> bool"""
13081  return _IMP_algebra.LogEmbedding6D___eq__(self, arg2)
13082 
13083 
13084  def _get_as_binary(self):
13085  """_get_as_binary(LogEmbedding6D self) -> PyObject *"""
13086  return _IMP_algebra.LogEmbedding6D__get_as_binary(self)
13087 
13088 
13089  def _set_from_binary(self, p):
13090  """_set_from_binary(LogEmbedding6D self, PyObject * p)"""
13091  return _IMP_algebra.LogEmbedding6D__set_from_binary(self, p)
13092 
13093 
13094  def __getstate__(self):
13095  p = self._get_as_binary()
13096  if len(self.__dict__) > 1:
13097  d = self.__dict__.copy()
13098  del d['this']
13099  p = (d, p)
13100  return p
13101 
13102  def __setstate__(self, p):
13103  if not hasattr(self, 'this'):
13104  self.__init__()
13105  if isinstance(p, tuple):
13106  d, p = p
13107  self.__dict__.update(d)
13108  return self._set_from_binary(p)
13109 
13110  __swig_destroy__ = _IMP_algebra.delete_LogEmbedding6D
13111  __del__ = lambda self: None
13112 LogEmbedding6D_swigregister = _IMP_algebra.LogEmbedding6D_swigregister
13113 LogEmbedding6D_swigregister(LogEmbedding6D)
13114 
13115 class SpherePatch3D(_GeometricPrimitive3D):
13116  """Proxy of C++ IMP::algebra::SpherePatch3D class"""
13117  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13118 
13119  def __init__(self, *args):
13120  """
13121  __init__(IMP::algebra::SpherePatch3D self) -> SpherePatch3D
13122  __init__(IMP::algebra::SpherePatch3D self, Sphere3D sph, Plane3D crossing_plane) -> SpherePatch3D
13123  """
13124  this = _IMP_algebra.new_SpherePatch3D(*args)
13125  try:
13126  self.this.append(this)
13127  except:
13128  self.this = this
13129 
13130  def get_contains(self, p):
13131  """get_contains(SpherePatch3D self, Vector3D p) -> bool"""
13132  return _IMP_algebra.SpherePatch3D_get_contains(self, p)
13133 
13134 
13135  def get_plane(self):
13136  """get_plane(SpherePatch3D self) -> Plane3D"""
13137  return _IMP_algebra.SpherePatch3D_get_plane(self)
13138 
13139 
13140  def get_sphere(self):
13141  """get_sphere(SpherePatch3D self) -> Sphere3D"""
13142  return _IMP_algebra.SpherePatch3D_get_sphere(self)
13143 
13144 
13145  def show(self, *args):
13146  """
13147  show(SpherePatch3D self, _ostream out)
13148  show(SpherePatch3D self)
13149  """
13150  return _IMP_algebra.SpherePatch3D_show(self, *args)
13151 
13152 
13153  def get_boundary_point(self):
13154  """get_boundary_point(SpherePatch3D self) -> Vector3D"""
13155  return _IMP_algebra.SpherePatch3D_get_boundary_point(self)
13156 
13157 
13158  def __str__(self):
13159  """__str__(SpherePatch3D self) -> std::string"""
13160  return _IMP_algebra.SpherePatch3D___str__(self)
13161 
13162 
13163  def __repr__(self):
13164  """__repr__(SpherePatch3D self) -> std::string"""
13165  return _IMP_algebra.SpherePatch3D___repr__(self)
13166 
13167 
13168  def _get_as_binary(self):
13169  """_get_as_binary(SpherePatch3D self) -> PyObject *"""
13170  return _IMP_algebra.SpherePatch3D__get_as_binary(self)
13171 
13172 
13173  def _set_from_binary(self, p):
13174  """_set_from_binary(SpherePatch3D self, PyObject * p)"""
13175  return _IMP_algebra.SpherePatch3D__set_from_binary(self, p)
13176 
13177 
13178  def __getstate__(self):
13179  p = self._get_as_binary()
13180  if len(self.__dict__) > 1:
13181  d = self.__dict__.copy()
13182  del d['this']
13183  p = (d, p)
13184  return p
13185 
13186  def __setstate__(self, p):
13187  if not hasattr(self, 'this'):
13188  self.__init__()
13189  if isinstance(p, tuple):
13190  d, p = p
13191  self.__dict__.update(d)
13192  return self._set_from_binary(p)
13193 
13194  __swig_destroy__ = _IMP_algebra.delete_SpherePatch3D
13195  __del__ = lambda self: None
13196 SpherePatch3D_swigregister = _IMP_algebra.SpherePatch3D_swigregister
13197 SpherePatch3D_swigregister(SpherePatch3D)
13198 
13199 
13200 def get_area(*args):
13201  """
13202  get_area(Plane3D g) -> double
13203  get_area(SpherePatch3D g) -> double
13204  """
13205  return _IMP_algebra.get_area(*args)
13206 
13207 def get_sphere_patch_3d_geometry(g):
13208  """get_sphere_patch_3d_geometry(SpherePatch3D g) -> SpherePatch3D"""
13209  return _IMP_algebra.get_sphere_patch_3d_geometry(g)
13210 class Cone3D(_GeometricPrimitive3D):
13211  """Proxy of C++ IMP::algebra::Cone3D class"""
13212  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13213 
13214  def __init__(self, *args):
13215  """
13216  __init__(IMP::algebra::Cone3D self) -> Cone3D
13217  __init__(IMP::algebra::Cone3D self, Segment3D s, double radius) -> Cone3D
13218  """
13219  this = _IMP_algebra.new_Cone3D(*args)
13220  try:
13221  self.this.append(this)
13222  except:
13223  self.this = this
13224 
13225  def get_tip(self):
13226  """get_tip(Cone3D self) -> Vector3D"""
13227  return _IMP_algebra.Cone3D_get_tip(self)
13228 
13229 
13230  def get_direction(self):
13231  """get_direction(Cone3D self) -> Vector3D"""
13232  return _IMP_algebra.Cone3D_get_direction(self)
13233 
13234 
13235  def get_height(self):
13236  """get_height(Cone3D self) -> double"""
13237  return _IMP_algebra.Cone3D_get_height(self)
13238 
13239 
13240  def get_angle(self):
13241  """get_angle(Cone3D self) -> double"""
13242  return _IMP_algebra.Cone3D_get_angle(self)
13243 
13244 
13245  def get_radius(self):
13246  """get_radius(Cone3D self) -> double"""
13247  return _IMP_algebra.Cone3D_get_radius(self)
13248 
13249 
13250  def get_contains(self, v):
13251  """get_contains(Cone3D self, Vector3D v) -> bool"""
13252  return _IMP_algebra.Cone3D_get_contains(self, v)
13253 
13254 
13255  def get_base_plane(self):
13256  """get_base_plane(Cone3D self) -> Plane3D"""
13257  return _IMP_algebra.Cone3D_get_base_plane(self)
13258 
13259 
13260  def show(self, *args):
13261  """
13262  show(Cone3D self, _ostream out)
13263  show(Cone3D self)
13264  """
13265  return _IMP_algebra.Cone3D_show(self, *args)
13266 
13267 
13268  def __str__(self):
13269  """__str__(Cone3D self) -> std::string"""
13270  return _IMP_algebra.Cone3D___str__(self)
13271 
13272 
13273  def __repr__(self):
13274  """__repr__(Cone3D self) -> std::string"""
13275  return _IMP_algebra.Cone3D___repr__(self)
13276 
13277 
13278  def _get_as_binary(self):
13279  """_get_as_binary(Cone3D self) -> PyObject *"""
13280  return _IMP_algebra.Cone3D__get_as_binary(self)
13281 
13282 
13283  def _set_from_binary(self, p):
13284  """_set_from_binary(Cone3D self, PyObject * p)"""
13285  return _IMP_algebra.Cone3D__set_from_binary(self, p)
13286 
13287 
13288  def __getstate__(self):
13289  p = self._get_as_binary()
13290  if len(self.__dict__) > 1:
13291  d = self.__dict__.copy()
13292  del d['this']
13293  p = (d, p)
13294  return p
13295 
13296  def __setstate__(self, p):
13297  if not hasattr(self, 'this'):
13298  self.__init__()
13299  if isinstance(p, tuple):
13300  d, p = p
13301  self.__dict__.update(d)
13302  return self._set_from_binary(p)
13303 
13304  __swig_destroy__ = _IMP_algebra.delete_Cone3D
13305  __del__ = lambda self: None
13306 Cone3D_swigregister = _IMP_algebra.Cone3D_swigregister
13307 Cone3D_swigregister(Cone3D)
13308 
13309 
13310 def get_surface_area(*args):
13311  """
13312  get_surface_area(BoundingBox3D g) -> double
13313  get_surface_area(Sphere3D g) -> double
13314  get_surface_area(Cylinder3D g) -> double
13315  get_surface_area(Ellipsoid3D g) -> double
13316  get_surface_area(Cone3D g) -> double
13317  """
13318  return _IMP_algebra.get_surface_area(*args)
13319 
13320 def get_volume(*args):
13321  """
13322  get_volume(BoundingBox3D g) -> double
13323  get_volume(Sphere3D g) -> double
13324  get_volume(Cylinder3D g) -> double
13325  get_volume(Ellipsoid3D g) -> double
13326  get_volume(Cone3D g) -> double
13327  """
13328  return _IMP_algebra.get_volume(*args)
13329 
13330 def get_cone_3d_geometry(g):
13331  """get_cone_3d_geometry(Cone3D g) -> Cone3D"""
13332  return _IMP_algebra.get_cone_3d_geometry(g)
13333 
13334 def write_pts(vs, out):
13335  """write_pts(IMP::algebra::Vector3Ds const & vs, TextOutput out)"""
13336  return _IMP_algebra.write_pts(vs, out)
13337 
13338 def read_pts(input):
13339  """read_pts(TextInput input) -> IMP::algebra::Vector3Ds"""
13340  return _IMP_algebra.read_pts(input)
13341 
13342 def write_spheres(vs, out):
13343  """write_spheres(IMP::algebra::Sphere3Ds const & vs, TextOutput out)"""
13344  return _IMP_algebra.write_spheres(vs, out)
13345 
13346 def read_spheres(input):
13347  """read_spheres(TextInput input) -> IMP::algebra::Sphere3Ds"""
13348  return _IMP_algebra.read_spheres(input)
13349 
13350 def get_random_vector_on_unit_sphere():
13351  """get_random_vector_on_unit_sphere() -> Vector3D"""
13352  return _IMP_algebra.get_random_vector_on_unit_sphere()
13353 
13354 def get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle):
13355  """get_grid_surface_cover(Cylinder3D cyl, int number_of_cycles, int number_of_points_on_cycle) -> IMP::algebra::Vector3Ds"""
13356  return _IMP_algebra.get_grid_surface_cover(cyl, number_of_cycles, number_of_points_on_cycle)
13357 
13358 def get_random_chain(*args):
13359  """
13360  get_random_chain(unsigned int n, double r, Vector3D start, IMP::algebra::Sphere3Ds const & obstacles) -> IMP::algebra::Vector3Ds
13361  get_random_chain(unsigned int n, double r, Vector3D start) -> IMP::algebra::Vector3Ds
13362  get_random_chain(unsigned int n, double r) -> IMP::algebra::Vector3Ds
13363  """
13364  return _IMP_algebra.get_random_chain(*args)
13365 
13366 def reversed_read(dest, size, nitems, f, reverse):
13367  """reversed_read(void * dest, size_t size, size_t nitems, std::ifstream & f, bool reverse)"""
13368  return _IMP_algebra.reversed_read(dest, size, nitems, f, reverse)
13369 
13370 def reversed_write(src, size, nitems, f, reverse=False):
13371  """
13372  reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f, bool reverse=False)
13373  reversed_write(void const * src, size_t size, size_t nitems, std::ofstream & f)
13374  """
13375  return _IMP_algebra.reversed_write(src, size, nitems, f, reverse)
13376 
13377 def get_is_big_endian():
13378  """get_is_big_endian() -> bool"""
13379  return _IMP_algebra.get_is_big_endian()
13380 
13381 def get_is_little_endian():
13382  """get_is_little_endian() -> bool"""
13383  return _IMP_algebra.get_is_little_endian()
13384 
13385 def get_shortest_segment(*args):
13386  """
13387  get_shortest_segment(Segment3D s, Vector3D p) -> Segment3D
13388  get_shortest_segment(Segment3D sa, Segment3D sb) -> Segment3D
13389  """
13390  return _IMP_algebra.get_shortest_segment(*args)
13391 class DynamicNearestNeighbor3D(IMP.Object):
13392  """Proxy of C++ IMP::algebra::DynamicNearestNeighbor3D class"""
13393  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13394 
13395  def __init__(self, vs, query_estimate=1):
13396  """
13397  __init__(IMP::algebra::DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs, double query_estimate=1) -> DynamicNearestNeighbor3D
13398  __init__(IMP::algebra::DynamicNearestNeighbor3D self, IMP::algebra::Vector3Ds const & vs) -> DynamicNearestNeighbor3D
13399  """
13400  this = _IMP_algebra.new_DynamicNearestNeighbor3D(vs, query_estimate)
13401  try:
13402  self.this.append(this)
13403  except:
13404  self.this = this
13405 
13406  def get_in_ball(self, id, distance):
13407  """get_in_ball(DynamicNearestNeighbor3D self, int id, double distance) -> IMP::Ints"""
13408  return _IMP_algebra.DynamicNearestNeighbor3D_get_in_ball(self, id, distance)
13409 
13410 
13411  def set_coordinates(self, id, nc):
13412  """set_coordinates(DynamicNearestNeighbor3D self, int id, Vector3D nc)"""
13413  return _IMP_algebra.DynamicNearestNeighbor3D_set_coordinates(self, id, nc)
13414 
13415 
13416  def get_version_info(self):
13417  """get_version_info(DynamicNearestNeighbor3D self) -> VersionInfo"""
13418  return _IMP_algebra.DynamicNearestNeighbor3D_get_version_info(self)
13419 
13420 
13421  def __str__(self):
13422  """__str__(DynamicNearestNeighbor3D self) -> std::string"""
13423  return _IMP_algebra.DynamicNearestNeighbor3D___str__(self)
13424 
13425 
13426  def __repr__(self):
13427  """__repr__(DynamicNearestNeighbor3D self) -> std::string"""
13428  return _IMP_algebra.DynamicNearestNeighbor3D___repr__(self)
13429 
13430 
13431  @staticmethod
13432  def get_from(o):
13433  return _object_cast_to_DynamicNearestNeighbor3D(o)
13434 
13435 DynamicNearestNeighbor3D_swigregister = _IMP_algebra.DynamicNearestNeighbor3D_swigregister
13436 DynamicNearestNeighbor3D_swigregister(DynamicNearestNeighbor3D)
13437 
13438 class VectorKDMetric(IMP.Object):
13439  """Proxy of C++ IMP::algebra::VectorKDMetric class"""
13440  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13441 
13442  def __init__(self, name):
13443  """__init__(IMP::algebra::VectorKDMetric self, std::string name) -> VectorKDMetric"""
13444  if self.__class__ == VectorKDMetric:
13445  _self = None
13446  else:
13447  _self = self
13448  this = _IMP_algebra.new_VectorKDMetric(_self, name)
13449  try:
13450  self.this.append(this)
13451  except:
13452  self.this = this
13453 
13454  if self.__class__ != VectorKDMetric:
13455  _director_objects.register(self)
13456 
13457 
13458 
13459 
13460  def get_distance(self, a, b):
13461  """get_distance(VectorKDMetric self, VectorKD a, VectorKD b) -> double"""
13462  return _IMP_algebra.VectorKDMetric_get_distance(self, a, b)
13463 
13464 
13465  def get_centroid(self, vs):
13466  """get_centroid(VectorKDMetric self, IMP::algebra::VectorKDs const & vs) -> VectorKD"""
13467  return _IMP_algebra.VectorKDMetric_get_centroid(self, vs)
13468 
13469 
13470  def __str__(self):
13471  """__str__(VectorKDMetric self) -> std::string"""
13472  return _IMP_algebra.VectorKDMetric___str__(self)
13473 
13474 
13475  def __repr__(self):
13476  """__repr__(VectorKDMetric self) -> std::string"""
13477  return _IMP_algebra.VectorKDMetric___repr__(self)
13478 
13479 
13480  @staticmethod
13481  def get_from(o):
13482  return _object_cast_to_VectorKDMetric(o)
13483 
13484 
13485  def get_type_name(self):
13486  return self.__class__.__name__
13487  def do_show(self, out):
13488  pass
13489  def get_version_info(self):
13490  if"IMP::algebra" == "IMP":
13491  return VersionInfo(self.__module__,
13492  __import__(self.__module__).get_module_version())
13493  else:
13494  return IMP.VersionInfo(self.__module__,
13495  __import__(self.__module__).get_module_version())
13496  @staticmethod
13497  def get_from(o):
13498  return _object_cast_to_VectorKDMetric(o)
13499 
13500  __swig_destroy__ = _IMP_algebra.delete_VectorKDMetric
13501  __del__ = lambda self: None
13502  def __disown__(self):
13503  self.this.disown()
13504  _IMP_algebra.disown_VectorKDMetric(self)
13505  return weakref_proxy(self)
13506 
13507  def do_destroy(self):
13508  """do_destroy(VectorKDMetric self)"""
13509  return _IMP_algebra.VectorKDMetric_do_destroy(self)
13510 
13511 VectorKDMetric_swigregister = _IMP_algebra.VectorKDMetric_swigregister
13512 VectorKDMetric_swigregister(VectorKDMetric)
13513 
13514 class EuclideanVectorKDMetric(VectorKDMetric):
13515  """Proxy of C++ IMP::algebra::EuclideanVectorKDMetric class"""
13516  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13517 
13518  def __init__(self, *args):
13519  """
13520  __init__(IMP::algebra::EuclideanVectorKDMetric self, std::string name) -> EuclideanVectorKDMetric
13521  __init__(IMP::algebra::EuclideanVectorKDMetric self) -> EuclideanVectorKDMetric
13522  """
13523  this = _IMP_algebra.new_EuclideanVectorKDMetric(*args)
13524  try:
13525  self.this.append(this)
13526  except:
13527  self.this = this
13528 
13529  def get_version_info(self):
13530  """get_version_info(EuclideanVectorKDMetric self) -> VersionInfo"""
13531  return _IMP_algebra.EuclideanVectorKDMetric_get_version_info(self)
13532 
13533 
13534  def __str__(self):
13535  """__str__(EuclideanVectorKDMetric self) -> std::string"""
13536  return _IMP_algebra.EuclideanVectorKDMetric___str__(self)
13537 
13538 
13539  def __repr__(self):
13540  """__repr__(EuclideanVectorKDMetric self) -> std::string"""
13541  return _IMP_algebra.EuclideanVectorKDMetric___repr__(self)
13542 
13543 
13544  @staticmethod
13545  def get_from(o):
13546  return _object_cast_to_EuclideanVectorKDMetric(o)
13547 
13548 EuclideanVectorKDMetric_swigregister = _IMP_algebra.EuclideanVectorKDMetric_swigregister
13549 EuclideanVectorKDMetric_swigregister(EuclideanVectorKDMetric)
13550 
13551 class MaxVectorKDMetric(VectorKDMetric):
13552  """Proxy of C++ IMP::algebra::MaxVectorKDMetric class"""
13553  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13554 
13555  def __init__(self, *args):
13556  """
13557  __init__(IMP::algebra::MaxVectorKDMetric self, std::string name) -> MaxVectorKDMetric
13558  __init__(IMP::algebra::MaxVectorKDMetric self) -> MaxVectorKDMetric
13559  """
13560  this = _IMP_algebra.new_MaxVectorKDMetric(*args)
13561  try:
13562  self.this.append(this)
13563  except:
13564  self.this = this
13565 
13566  def get_version_info(self):
13567  """get_version_info(MaxVectorKDMetric self) -> VersionInfo"""
13568  return _IMP_algebra.MaxVectorKDMetric_get_version_info(self)
13569 
13570 
13571  def __str__(self):
13572  """__str__(MaxVectorKDMetric self) -> std::string"""
13573  return _IMP_algebra.MaxVectorKDMetric___str__(self)
13574 
13575 
13576  def __repr__(self):
13577  """__repr__(MaxVectorKDMetric self) -> std::string"""
13578  return _IMP_algebra.MaxVectorKDMetric___repr__(self)
13579 
13580 
13581  @staticmethod
13582  def get_from(o):
13583  return _object_cast_to_MaxVectorKDMetric(o)
13584 
13585 MaxVectorKDMetric_swigregister = _IMP_algebra.MaxVectorKDMetric_swigregister
13586 MaxVectorKDMetric_swigregister(MaxVectorKDMetric)
13587 
13588 class Gaussian3D(_GeometricPrimitive3D):
13589  """Proxy of C++ IMP::algebra::Gaussian3D class"""
13590  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13591 
13592  def __init__(self, *args):
13593  """
13594  __init__(IMP::algebra::Gaussian3D self) -> Gaussian3D
13595  __init__(IMP::algebra::Gaussian3D self, ReferenceFrame3D tr, Vector3D variances) -> Gaussian3D
13596  """
13597  this = _IMP_algebra.new_Gaussian3D(*args)
13598  try:
13599  self.this.append(this)
13600  except:
13601  self.this = this
13602 
13603  def get_reference_frame(self):
13604  """get_reference_frame(Gaussian3D self) -> ReferenceFrame3D"""
13605  return _IMP_algebra.Gaussian3D_get_reference_frame(self)
13606 
13607 
13608  def get_variances(self):
13609  """get_variances(Gaussian3D self) -> Vector3D"""
13610  return _IMP_algebra.Gaussian3D_get_variances(self)
13611 
13612 
13613  def get_center(self):
13614  """get_center(Gaussian3D self) -> Vector3D"""
13615  return _IMP_algebra.Gaussian3D_get_center(self)
13616 
13617 
13618  def show(self, *args):
13619  """
13620  show(Gaussian3D self, _ostream out)
13621  show(Gaussian3D self)
13622  """
13623  return _IMP_algebra.Gaussian3D_show(self, *args)
13624 
13625 
13626  def __str__(self):
13627  """__str__(Gaussian3D self) -> std::string"""
13628  return _IMP_algebra.Gaussian3D___str__(self)
13629 
13630 
13631  def __repr__(self):
13632  """__repr__(Gaussian3D self) -> std::string"""
13633  return _IMP_algebra.Gaussian3D___repr__(self)
13634 
13635 
13636  def _get_as_binary(self):
13637  """_get_as_binary(Gaussian3D self) -> PyObject *"""
13638  return _IMP_algebra.Gaussian3D__get_as_binary(self)
13639 
13640 
13641  def _set_from_binary(self, p):
13642  """_set_from_binary(Gaussian3D self, PyObject * p)"""
13643  return _IMP_algebra.Gaussian3D__set_from_binary(self, p)
13644 
13645 
13646  def __getstate__(self):
13647  p = self._get_as_binary()
13648  if len(self.__dict__) > 1:
13649  d = self.__dict__.copy()
13650  del d['this']
13651  p = (d, p)
13652  return p
13653 
13654  def __setstate__(self, p):
13655  if not hasattr(self, 'this'):
13656  self.__init__()
13657  if isinstance(p, tuple):
13658  d, p = p
13659  self.__dict__.update(d)
13660  return self._set_from_binary(p)
13661 
13662  __swig_destroy__ = _IMP_algebra.delete_Gaussian3D
13663  __del__ = lambda self: None
13664 Gaussian3D_swigregister = _IMP_algebra.Gaussian3D_swigregister
13665 Gaussian3D_swigregister(Gaussian3D)
13666 
13667 
13668 def get_covariance(g):
13669  """get_covariance(Gaussian3D g) -> Eigen::Matrix3d"""
13670  return _IMP_algebra.get_covariance(g)
13671 
13672 def get_gaussian_from_covariance(covariance, center):
13673  """get_gaussian_from_covariance(Eigen::Matrix3d const & covariance, Vector3D center) -> Gaussian3D"""
13674  return _IMP_algebra.get_gaussian_from_covariance(covariance, center)
13675 
13676 def get_rasterized(gmm, weights, cell_width, bb):
13677  """get_rasterized(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D"""
13678  return _IMP_algebra.get_rasterized(gmm, weights, cell_width, bb)
13679 
13680 def get_rasterized_fast(gmm, weights, cell_width, bb, factor=2.5):
13681  """
13682  get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb, double factor=2.5) -> DenseDoubleGrid3D
13683  get_rasterized_fast(IMP::algebra::Gaussian3Ds const & gmm, IMP::Floats const & weights, double cell_width, BoundingBox3D bb) -> DenseDoubleGrid3D
13684  """
13685  return _IMP_algebra.get_rasterized_fast(gmm, weights, cell_width, bb, factor)
13686 
13687 def _pass_matrix_xf(m):
13688  """_pass_matrix_xf(Eigen::MatrixXf const & m) -> Eigen::MatrixXf"""
13689  return _IMP_algebra._pass_matrix_xf(m)
13690 
13691 def _pass_matrix_xd(m):
13692  """_pass_matrix_xd(Eigen::MatrixXd const & m) -> Eigen::MatrixXd"""
13693  return _IMP_algebra._pass_matrix_xd(m)
13694 
13695 def _pass_matrix_3d(m):
13696  """_pass_matrix_3d(Eigen::Matrix3d const & m) -> Eigen::Matrix3d"""
13697  return _IMP_algebra._pass_matrix_3d(m)
13698 
13699 def _pass_array_xd(m):
13700  """_pass_array_xd(Eigen::ArrayXXd const & m) -> Eigen::ArrayXXd"""
13701  return _IMP_algebra._pass_array_xd(m)
13702 
13703 def _pass_vector_xd(m):
13704  """_pass_vector_xd(Eigen::VectorXd const & m) -> Eigen::VectorXd"""
13705  return _IMP_algebra._pass_vector_xd(m)
13706 class NearestNeighbor1D(IMP.Object):
13707  """Proxy of C++ IMP::algebra::NearestNeighborD<(1)> class"""
13708  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13709 
13710  def __init__(self, *args):
13711  """
13712  __init__(IMP::algebra::NearestNeighborD<(1)> self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs, double epsilon=0) -> NearestNeighbor1D
13713  __init__(IMP::algebra::NearestNeighborD<(1)> self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & vs) -> NearestNeighbor1D
13714  """
13715  this = _IMP_algebra.new_NearestNeighbor1D(*args)
13716  try:
13717  self.this.append(this)
13718  except:
13719  self.this = this
13720 
13721  def set_query_log(self, fname):
13722  """set_query_log(NearestNeighbor1D self, std::string fname)"""
13723  return _IMP_algebra.NearestNeighbor1D_set_query_log(self, fname)
13724 
13725 
13726  def get_nearest_neighbor(self, *args):
13727  """
13728  get_nearest_neighbor(NearestNeighbor1D self, Vector1D q) -> unsigned int
13729  get_nearest_neighbor(NearestNeighbor1D self, unsigned int i) -> unsigned int
13730  """
13731  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbor(self, *args)
13732 
13733 
13734  def get_nearest_neighbors(self, *args):
13735  """
13736  get_nearest_neighbors(NearestNeighbor1D self, unsigned int i, unsigned int k) -> IMP::Ints
13737  get_nearest_neighbors(NearestNeighbor1D self, Vector1D v, unsigned int k) -> IMP::Ints
13738  """
13739  return _IMP_algebra.NearestNeighbor1D_get_nearest_neighbors(self, *args)
13740 
13741 
13742  def get_in_ball(self, *args):
13743  """
13744  get_in_ball(NearestNeighbor1D self, unsigned int i, double distance) -> IMP::Ints
13745  get_in_ball(NearestNeighbor1D self, Vector1D pt, double distance) -> IMP::Ints
13746  """
13747  return _IMP_algebra.NearestNeighbor1D_get_in_ball(self, *args)
13748 
13749 
13750  def get_version_info(self):
13751  """get_version_info(NearestNeighbor1D self) -> VersionInfo"""
13752  return _IMP_algebra.NearestNeighbor1D_get_version_info(self)
13753 
13754 
13755  def __str__(self):
13756  """__str__(NearestNeighbor1D self) -> std::string"""
13757  return _IMP_algebra.NearestNeighbor1D___str__(self)
13758 
13759 
13760  def __repr__(self):
13761  """__repr__(NearestNeighbor1D self) -> std::string"""
13762  return _IMP_algebra.NearestNeighbor1D___repr__(self)
13763 
13764 
13765  @staticmethod
13766  def get_from(o):
13767  return _object_cast_to_NearestNeighborD(o)
13768 
13769 NearestNeighbor1D_swigregister = _IMP_algebra.NearestNeighbor1D_swigregister
13770 NearestNeighbor1D_swigregister(NearestNeighbor1D)
13771 
13772 class NearestNeighbor2D(IMP.Object):
13773  """Proxy of C++ IMP::algebra::NearestNeighborD<(2)> class"""
13774  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13775 
13776  def __init__(self, *args):
13777  """
13778  __init__(IMP::algebra::NearestNeighborD<(2)> self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs, double epsilon=0) -> NearestNeighbor2D
13779  __init__(IMP::algebra::NearestNeighborD<(2)> self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & vs) -> NearestNeighbor2D
13780  """
13781  this = _IMP_algebra.new_NearestNeighbor2D(*args)
13782  try:
13783  self.this.append(this)
13784  except:
13785  self.this = this
13786 
13787  def set_query_log(self, fname):
13788  """set_query_log(NearestNeighbor2D self, std::string fname)"""
13789  return _IMP_algebra.NearestNeighbor2D_set_query_log(self, fname)
13790 
13791 
13792  def get_nearest_neighbor(self, *args):
13793  """
13794  get_nearest_neighbor(NearestNeighbor2D self, Vector2D q) -> unsigned int
13795  get_nearest_neighbor(NearestNeighbor2D self, unsigned int i) -> unsigned int
13796  """
13797  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbor(self, *args)
13798 
13799 
13800  def get_nearest_neighbors(self, *args):
13801  """
13802  get_nearest_neighbors(NearestNeighbor2D self, unsigned int i, unsigned int k) -> IMP::Ints
13803  get_nearest_neighbors(NearestNeighbor2D self, Vector2D v, unsigned int k) -> IMP::Ints
13804  """
13805  return _IMP_algebra.NearestNeighbor2D_get_nearest_neighbors(self, *args)
13806 
13807 
13808  def get_in_ball(self, *args):
13809  """
13810  get_in_ball(NearestNeighbor2D self, unsigned int i, double distance) -> IMP::Ints
13811  get_in_ball(NearestNeighbor2D self, Vector2D pt, double distance) -> IMP::Ints
13812  """
13813  return _IMP_algebra.NearestNeighbor2D_get_in_ball(self, *args)
13814 
13815 
13816  def get_version_info(self):
13817  """get_version_info(NearestNeighbor2D self) -> VersionInfo"""
13818  return _IMP_algebra.NearestNeighbor2D_get_version_info(self)
13819 
13820 
13821  def __str__(self):
13822  """__str__(NearestNeighbor2D self) -> std::string"""
13823  return _IMP_algebra.NearestNeighbor2D___str__(self)
13824 
13825 
13826  def __repr__(self):
13827  """__repr__(NearestNeighbor2D self) -> std::string"""
13828  return _IMP_algebra.NearestNeighbor2D___repr__(self)
13829 
13830 
13831  @staticmethod
13832  def get_from(o):
13833  return _object_cast_to_NearestNeighborD(o)
13834 
13835 NearestNeighbor2D_swigregister = _IMP_algebra.NearestNeighbor2D_swigregister
13836 NearestNeighbor2D_swigregister(NearestNeighbor2D)
13837 
13838 class NearestNeighbor3D(IMP.Object):
13839  """Proxy of C++ IMP::algebra::NearestNeighborD<(3)> class"""
13840  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13841 
13842  def __init__(self, *args):
13843  """
13844  __init__(IMP::algebra::NearestNeighborD<(3)> self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs, double epsilon=0) -> NearestNeighbor3D
13845  __init__(IMP::algebra::NearestNeighborD<(3)> self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & vs) -> NearestNeighbor3D
13846  """
13847  this = _IMP_algebra.new_NearestNeighbor3D(*args)
13848  try:
13849  self.this.append(this)
13850  except:
13851  self.this = this
13852 
13853  def set_query_log(self, fname):
13854  """set_query_log(NearestNeighbor3D self, std::string fname)"""
13855  return _IMP_algebra.NearestNeighbor3D_set_query_log(self, fname)
13856 
13857 
13858  def get_nearest_neighbor(self, *args):
13859  """
13860  get_nearest_neighbor(NearestNeighbor3D self, Vector3D q) -> unsigned int
13861  get_nearest_neighbor(NearestNeighbor3D self, unsigned int i) -> unsigned int
13862  """
13863  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbor(self, *args)
13864 
13865 
13866  def get_nearest_neighbors(self, *args):
13867  """
13868  get_nearest_neighbors(NearestNeighbor3D self, unsigned int i, unsigned int k) -> IMP::Ints
13869  get_nearest_neighbors(NearestNeighbor3D self, Vector3D v, unsigned int k) -> IMP::Ints
13870  """
13871  return _IMP_algebra.NearestNeighbor3D_get_nearest_neighbors(self, *args)
13872 
13873 
13874  def get_in_ball(self, *args):
13875  """
13876  get_in_ball(NearestNeighbor3D self, unsigned int i, double distance) -> IMP::Ints
13877  get_in_ball(NearestNeighbor3D self, Vector3D pt, double distance) -> IMP::Ints
13878  """
13879  return _IMP_algebra.NearestNeighbor3D_get_in_ball(self, *args)
13880 
13881 
13882  def get_version_info(self):
13883  """get_version_info(NearestNeighbor3D self) -> VersionInfo"""
13884  return _IMP_algebra.NearestNeighbor3D_get_version_info(self)
13885 
13886 
13887  def __str__(self):
13888  """__str__(NearestNeighbor3D self) -> std::string"""
13889  return _IMP_algebra.NearestNeighbor3D___str__(self)
13890 
13891 
13892  def __repr__(self):
13893  """__repr__(NearestNeighbor3D self) -> std::string"""
13894  return _IMP_algebra.NearestNeighbor3D___repr__(self)
13895 
13896 
13897  @staticmethod
13898  def get_from(o):
13899  return _object_cast_to_NearestNeighborD(o)
13900 
13901 NearestNeighbor3D_swigregister = _IMP_algebra.NearestNeighbor3D_swigregister
13902 NearestNeighbor3D_swigregister(NearestNeighbor3D)
13903 
13904 class NearestNeighbor4D(IMP.Object):
13905  """Proxy of C++ IMP::algebra::NearestNeighborD<(4)> class"""
13906  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13907 
13908  def __init__(self, *args):
13909  """
13910  __init__(IMP::algebra::NearestNeighborD<(4)> self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs, double epsilon=0) -> NearestNeighbor4D
13911  __init__(IMP::algebra::NearestNeighborD<(4)> self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & vs) -> NearestNeighbor4D
13912  """
13913  this = _IMP_algebra.new_NearestNeighbor4D(*args)
13914  try:
13915  self.this.append(this)
13916  except:
13917  self.this = this
13918 
13919  def set_query_log(self, fname):
13920  """set_query_log(NearestNeighbor4D self, std::string fname)"""
13921  return _IMP_algebra.NearestNeighbor4D_set_query_log(self, fname)
13922 
13923 
13924  def get_nearest_neighbor(self, *args):
13925  """
13926  get_nearest_neighbor(NearestNeighbor4D self, Vector4D q) -> unsigned int
13927  get_nearest_neighbor(NearestNeighbor4D self, unsigned int i) -> unsigned int
13928  """
13929  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbor(self, *args)
13930 
13931 
13932  def get_nearest_neighbors(self, *args):
13933  """
13934  get_nearest_neighbors(NearestNeighbor4D self, unsigned int i, unsigned int k) -> IMP::Ints
13935  get_nearest_neighbors(NearestNeighbor4D self, Vector4D v, unsigned int k) -> IMP::Ints
13936  """
13937  return _IMP_algebra.NearestNeighbor4D_get_nearest_neighbors(self, *args)
13938 
13939 
13940  def get_in_ball(self, *args):
13941  """
13942  get_in_ball(NearestNeighbor4D self, unsigned int i, double distance) -> IMP::Ints
13943  get_in_ball(NearestNeighbor4D self, Vector4D pt, double distance) -> IMP::Ints
13944  """
13945  return _IMP_algebra.NearestNeighbor4D_get_in_ball(self, *args)
13946 
13947 
13948  def get_version_info(self):
13949  """get_version_info(NearestNeighbor4D self) -> VersionInfo"""
13950  return _IMP_algebra.NearestNeighbor4D_get_version_info(self)
13951 
13952 
13953  def __str__(self):
13954  """__str__(NearestNeighbor4D self) -> std::string"""
13955  return _IMP_algebra.NearestNeighbor4D___str__(self)
13956 
13957 
13958  def __repr__(self):
13959  """__repr__(NearestNeighbor4D self) -> std::string"""
13960  return _IMP_algebra.NearestNeighbor4D___repr__(self)
13961 
13962 
13963  @staticmethod
13964  def get_from(o):
13965  return _object_cast_to_NearestNeighborD(o)
13966 
13967 NearestNeighbor4D_swigregister = _IMP_algebra.NearestNeighbor4D_swigregister
13968 NearestNeighbor4D_swigregister(NearestNeighbor4D)
13969 
13970 class NearestNeighbor5D(IMP.Object):
13971  """Proxy of C++ IMP::algebra::NearestNeighborD<(5)> class"""
13972  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
13973 
13974  def __init__(self, *args):
13975  """
13976  __init__(IMP::algebra::NearestNeighborD<(5)> self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs, double epsilon=0) -> NearestNeighbor5D
13977  __init__(IMP::algebra::NearestNeighborD<(5)> self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & vs) -> NearestNeighbor5D
13978  """
13979  this = _IMP_algebra.new_NearestNeighbor5D(*args)
13980  try:
13981  self.this.append(this)
13982  except:
13983  self.this = this
13984 
13985  def set_query_log(self, fname):
13986  """set_query_log(NearestNeighbor5D self, std::string fname)"""
13987  return _IMP_algebra.NearestNeighbor5D_set_query_log(self, fname)
13988 
13989 
13990  def get_nearest_neighbor(self, *args):
13991  """
13992  get_nearest_neighbor(NearestNeighbor5D self, Vector5D q) -> unsigned int
13993  get_nearest_neighbor(NearestNeighbor5D self, unsigned int i) -> unsigned int
13994  """
13995  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbor(self, *args)
13996 
13997 
13998  def get_nearest_neighbors(self, *args):
13999  """
14000  get_nearest_neighbors(NearestNeighbor5D self, unsigned int i, unsigned int k) -> IMP::Ints
14001  get_nearest_neighbors(NearestNeighbor5D self, Vector5D v, unsigned int k) -> IMP::Ints
14002  """
14003  return _IMP_algebra.NearestNeighbor5D_get_nearest_neighbors(self, *args)
14004 
14005 
14006  def get_in_ball(self, *args):
14007  """
14008  get_in_ball(NearestNeighbor5D self, unsigned int i, double distance) -> IMP::Ints
14009  get_in_ball(NearestNeighbor5D self, Vector5D pt, double distance) -> IMP::Ints
14010  """
14011  return _IMP_algebra.NearestNeighbor5D_get_in_ball(self, *args)
14012 
14013 
14014  def get_version_info(self):
14015  """get_version_info(NearestNeighbor5D self) -> VersionInfo"""
14016  return _IMP_algebra.NearestNeighbor5D_get_version_info(self)
14017 
14018 
14019  def __str__(self):
14020  """__str__(NearestNeighbor5D self) -> std::string"""
14021  return _IMP_algebra.NearestNeighbor5D___str__(self)
14022 
14023 
14024  def __repr__(self):
14025  """__repr__(NearestNeighbor5D self) -> std::string"""
14026  return _IMP_algebra.NearestNeighbor5D___repr__(self)
14027 
14028 
14029  @staticmethod
14030  def get_from(o):
14031  return _object_cast_to_NearestNeighborD(o)
14032 
14033 NearestNeighbor5D_swigregister = _IMP_algebra.NearestNeighbor5D_swigregister
14034 NearestNeighbor5D_swigregister(NearestNeighbor5D)
14035 
14036 class NearestNeighbor6D(IMP.Object):
14037  """Proxy of C++ IMP::algebra::NearestNeighborD<(6)> class"""
14038  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14039 
14040  def __init__(self, *args):
14041  """
14042  __init__(IMP::algebra::NearestNeighborD<(6)> self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs, double epsilon=0) -> NearestNeighbor6D
14043  __init__(IMP::algebra::NearestNeighborD<(6)> self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & vs) -> NearestNeighbor6D
14044  """
14045  this = _IMP_algebra.new_NearestNeighbor6D(*args)
14046  try:
14047  self.this.append(this)
14048  except:
14049  self.this = this
14050 
14051  def set_query_log(self, fname):
14052  """set_query_log(NearestNeighbor6D self, std::string fname)"""
14053  return _IMP_algebra.NearestNeighbor6D_set_query_log(self, fname)
14054 
14055 
14056  def get_nearest_neighbor(self, *args):
14057  """
14058  get_nearest_neighbor(NearestNeighbor6D self, Vector6D q) -> unsigned int
14059  get_nearest_neighbor(NearestNeighbor6D self, unsigned int i) -> unsigned int
14060  """
14061  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbor(self, *args)
14062 
14063 
14064  def get_nearest_neighbors(self, *args):
14065  """
14066  get_nearest_neighbors(NearestNeighbor6D self, unsigned int i, unsigned int k) -> IMP::Ints
14067  get_nearest_neighbors(NearestNeighbor6D self, Vector6D v, unsigned int k) -> IMP::Ints
14068  """
14069  return _IMP_algebra.NearestNeighbor6D_get_nearest_neighbors(self, *args)
14070 
14071 
14072  def get_in_ball(self, *args):
14073  """
14074  get_in_ball(NearestNeighbor6D self, unsigned int i, double distance) -> IMP::Ints
14075  get_in_ball(NearestNeighbor6D self, Vector6D pt, double distance) -> IMP::Ints
14076  """
14077  return _IMP_algebra.NearestNeighbor6D_get_in_ball(self, *args)
14078 
14079 
14080  def get_version_info(self):
14081  """get_version_info(NearestNeighbor6D self) -> VersionInfo"""
14082  return _IMP_algebra.NearestNeighbor6D_get_version_info(self)
14083 
14084 
14085  def __str__(self):
14086  """__str__(NearestNeighbor6D self) -> std::string"""
14087  return _IMP_algebra.NearestNeighbor6D___str__(self)
14088 
14089 
14090  def __repr__(self):
14091  """__repr__(NearestNeighbor6D self) -> std::string"""
14092  return _IMP_algebra.NearestNeighbor6D___repr__(self)
14093 
14094 
14095  @staticmethod
14096  def get_from(o):
14097  return _object_cast_to_NearestNeighborD(o)
14098 
14099 NearestNeighbor6D_swigregister = _IMP_algebra.NearestNeighbor6D_swigregister
14100 NearestNeighbor6D_swigregister(NearestNeighbor6D)
14101 
14102 class NearestNeighborKD(IMP.Object):
14103  """Proxy of C++ IMP::algebra::NearestNeighborD<(-1)> class"""
14104  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14105 
14106  def __init__(self, *args):
14107  """
14108  __init__(IMP::algebra::NearestNeighborD<(-1)> self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs, double epsilon=0) -> NearestNeighborKD
14109  __init__(IMP::algebra::NearestNeighborD<(-1)> self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & vs) -> NearestNeighborKD
14110  """
14111  this = _IMP_algebra.new_NearestNeighborKD(*args)
14112  try:
14113  self.this.append(this)
14114  except:
14115  self.this = this
14116 
14117  def set_query_log(self, fname):
14118  """set_query_log(NearestNeighborKD self, std::string fname)"""
14119  return _IMP_algebra.NearestNeighborKD_set_query_log(self, fname)
14120 
14121 
14122  def get_nearest_neighbor(self, *args):
14123  """
14124  get_nearest_neighbor(NearestNeighborKD self, VectorKD q) -> unsigned int
14125  get_nearest_neighbor(NearestNeighborKD self, unsigned int i) -> unsigned int
14126  """
14127  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbor(self, *args)
14128 
14129 
14130  def get_nearest_neighbors(self, *args):
14131  """
14132  get_nearest_neighbors(NearestNeighborKD self, unsigned int i, unsigned int k) -> IMP::Ints
14133  get_nearest_neighbors(NearestNeighborKD self, VectorKD v, unsigned int k) -> IMP::Ints
14134  """
14135  return _IMP_algebra.NearestNeighborKD_get_nearest_neighbors(self, *args)
14136 
14137 
14138  def get_in_ball(self, *args):
14139  """
14140  get_in_ball(NearestNeighborKD self, unsigned int i, double distance) -> IMP::Ints
14141  get_in_ball(NearestNeighborKD self, VectorKD pt, double distance) -> IMP::Ints
14142  """
14143  return _IMP_algebra.NearestNeighborKD_get_in_ball(self, *args)
14144 
14145 
14146  def get_version_info(self):
14147  """get_version_info(NearestNeighborKD self) -> VersionInfo"""
14148  return _IMP_algebra.NearestNeighborKD_get_version_info(self)
14149 
14150 
14151  def __str__(self):
14152  """__str__(NearestNeighborKD self) -> std::string"""
14153  return _IMP_algebra.NearestNeighborKD___str__(self)
14154 
14155 
14156  def __repr__(self):
14157  """__repr__(NearestNeighborKD self) -> std::string"""
14158  return _IMP_algebra.NearestNeighborKD___repr__(self)
14159 
14160 
14161  @staticmethod
14162  def get_from(o):
14163  return _object_cast_to_NearestNeighborD(o)
14164 
14165 NearestNeighborKD_swigregister = _IMP_algebra.NearestNeighborKD_swigregister
14166 NearestNeighborKD_swigregister(NearestNeighborKD)
14167 
14168 
14169 def get_transformation_aligning_pair(set_from, set_to):
14170  """get_transformation_aligning_pair(IMP::algebra::Vector2Ds const & set_from, IMP::algebra::Vector2Ds const & set_to) -> Transformation2D"""
14171  return _IMP_algebra.get_transformation_aligning_pair(set_from, set_to)
14172 class PrincipalComponentAnalysis1D(_GeometricPrimitive1D):
14173  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(1)> class"""
14174  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14175 
14176  def __init__(self, *args):
14177  """
14178  __init__(IMP::algebra::PrincipalComponentAnalysisD<(1)> self) -> PrincipalComponentAnalysis1D
14179  __init__(IMP::algebra::PrincipalComponentAnalysisD<(1)> self, IMP::Vector< IMP::algebra::VectorD< 1 > > const & pcs, Vector1D values, Vector1D centroid) -> PrincipalComponentAnalysis1D
14180  """
14181  this = _IMP_algebra.new_PrincipalComponentAnalysis1D(*args)
14182  try:
14183  self.this.append(this)
14184  except:
14185  self.this = this
14186 
14187  def get_principal_components(self):
14188  """get_principal_components(PrincipalComponentAnalysis1D self) -> IMP::Vector< IMP::algebra::VectorD< 1 > >"""
14189  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_components(self)
14190 
14191 
14192  def get_principal_component(self, i):
14193  """get_principal_component(PrincipalComponentAnalysis1D self, unsigned int i) -> Vector1D"""
14194  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_component(self, i)
14195 
14196 
14197  def get_principal_values(self):
14198  """get_principal_values(PrincipalComponentAnalysis1D self) -> Vector1D"""
14199  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_values(self)
14200 
14201 
14202  def get_principal_value(self, i):
14203  """get_principal_value(PrincipalComponentAnalysis1D self, unsigned int i) -> double"""
14204  return _IMP_algebra.PrincipalComponentAnalysis1D_get_principal_value(self, i)
14205 
14206 
14207  def get_centroid(self):
14208  """get_centroid(PrincipalComponentAnalysis1D self) -> Vector1D"""
14209  return _IMP_algebra.PrincipalComponentAnalysis1D_get_centroid(self)
14210 
14211 
14212  def set_centroid(self, cntr):
14213  """set_centroid(PrincipalComponentAnalysis1D self, Vector1D cntr)"""
14214  return _IMP_algebra.PrincipalComponentAnalysis1D_set_centroid(self, cntr)
14215 
14216 
14217  def show(self, *args):
14218  """
14219  show(PrincipalComponentAnalysis1D self, _ostream out)
14220  show(PrincipalComponentAnalysis1D self)
14221  """
14222  return _IMP_algebra.PrincipalComponentAnalysis1D_show(self, *args)
14223 
14224 
14225  def __cmp__(self, o):
14226  """__cmp__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> int"""
14227  return _IMP_algebra.PrincipalComponentAnalysis1D___cmp__(self, o)
14228 
14229 
14230  def __eq__(self, o):
14231  """__eq__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14232  return _IMP_algebra.PrincipalComponentAnalysis1D___eq__(self, o)
14233 
14234 
14235  def __ne__(self, o):
14236  """__ne__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14237  return _IMP_algebra.PrincipalComponentAnalysis1D___ne__(self, o)
14238 
14239 
14240  def __lt__(self, o):
14241  """__lt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14242  return _IMP_algebra.PrincipalComponentAnalysis1D___lt__(self, o)
14243 
14244 
14245  def __gt__(self, o):
14246  """__gt__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14247  return _IMP_algebra.PrincipalComponentAnalysis1D___gt__(self, o)
14248 
14249 
14250  def __ge__(self, o):
14251  """__ge__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14252  return _IMP_algebra.PrincipalComponentAnalysis1D___ge__(self, o)
14253 
14254 
14255  def __le__(self, o):
14256  """__le__(PrincipalComponentAnalysis1D self, PrincipalComponentAnalysis1D o) -> bool"""
14257  return _IMP_algebra.PrincipalComponentAnalysis1D___le__(self, o)
14258 
14259 
14260  def __str__(self):
14261  """__str__(PrincipalComponentAnalysis1D self) -> std::string"""
14262  return _IMP_algebra.PrincipalComponentAnalysis1D___str__(self)
14263 
14264 
14265  def __repr__(self):
14266  """__repr__(PrincipalComponentAnalysis1D self) -> std::string"""
14267  return _IMP_algebra.PrincipalComponentAnalysis1D___repr__(self)
14268 
14269 
14270  def _get_as_binary(self):
14271  """_get_as_binary(PrincipalComponentAnalysis1D self) -> PyObject *"""
14272  return _IMP_algebra.PrincipalComponentAnalysis1D__get_as_binary(self)
14273 
14274 
14275  def _set_from_binary(self, p):
14276  """_set_from_binary(PrincipalComponentAnalysis1D self, PyObject * p)"""
14277  return _IMP_algebra.PrincipalComponentAnalysis1D__set_from_binary(self, p)
14278 
14279 
14280  def __getstate__(self):
14281  p = self._get_as_binary()
14282  if len(self.__dict__) > 1:
14283  d = self.__dict__.copy()
14284  del d['this']
14285  p = (d, p)
14286  return p
14287 
14288  def __setstate__(self, p):
14289  if not hasattr(self, 'this'):
14290  self.__init__()
14291  if isinstance(p, tuple):
14292  d, p = p
14293  self.__dict__.update(d)
14294  return self._set_from_binary(p)
14295 
14296  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis1D
14297  __del__ = lambda self: None
14298 PrincipalComponentAnalysis1D_swigregister = _IMP_algebra.PrincipalComponentAnalysis1D_swigregister
14299 PrincipalComponentAnalysis1D_swigregister(PrincipalComponentAnalysis1D)
14300 
14301 class PrincipalComponentAnalysis2D(_GeometricPrimitive2D):
14302  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(2)> class"""
14303  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14304 
14305  def __init__(self, *args):
14306  """
14307  __init__(IMP::algebra::PrincipalComponentAnalysisD<(2)> self) -> PrincipalComponentAnalysis2D
14308  __init__(IMP::algebra::PrincipalComponentAnalysisD<(2)> self, IMP::Vector< IMP::algebra::VectorD< 2 > > const & pcs, Vector2D values, Vector2D centroid) -> PrincipalComponentAnalysis2D
14309  """
14310  this = _IMP_algebra.new_PrincipalComponentAnalysis2D(*args)
14311  try:
14312  self.this.append(this)
14313  except:
14314  self.this = this
14315 
14316  def get_principal_components(self):
14317  """get_principal_components(PrincipalComponentAnalysis2D self) -> IMP::Vector< IMP::algebra::VectorD< 2 > >"""
14318  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_components(self)
14319 
14320 
14321  def get_principal_component(self, i):
14322  """get_principal_component(PrincipalComponentAnalysis2D self, unsigned int i) -> Vector2D"""
14323  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_component(self, i)
14324 
14325 
14326  def get_principal_values(self):
14327  """get_principal_values(PrincipalComponentAnalysis2D self) -> Vector2D"""
14328  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_values(self)
14329 
14330 
14331  def get_principal_value(self, i):
14332  """get_principal_value(PrincipalComponentAnalysis2D self, unsigned int i) -> double"""
14333  return _IMP_algebra.PrincipalComponentAnalysis2D_get_principal_value(self, i)
14334 
14335 
14336  def get_centroid(self):
14337  """get_centroid(PrincipalComponentAnalysis2D self) -> Vector2D"""
14338  return _IMP_algebra.PrincipalComponentAnalysis2D_get_centroid(self)
14339 
14340 
14341  def set_centroid(self, cntr):
14342  """set_centroid(PrincipalComponentAnalysis2D self, Vector2D cntr)"""
14343  return _IMP_algebra.PrincipalComponentAnalysis2D_set_centroid(self, cntr)
14344 
14345 
14346  def show(self, *args):
14347  """
14348  show(PrincipalComponentAnalysis2D self, _ostream out)
14349  show(PrincipalComponentAnalysis2D self)
14350  """
14351  return _IMP_algebra.PrincipalComponentAnalysis2D_show(self, *args)
14352 
14353 
14354  def __cmp__(self, o):
14355  """__cmp__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> int"""
14356  return _IMP_algebra.PrincipalComponentAnalysis2D___cmp__(self, o)
14357 
14358 
14359  def __eq__(self, o):
14360  """__eq__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14361  return _IMP_algebra.PrincipalComponentAnalysis2D___eq__(self, o)
14362 
14363 
14364  def __ne__(self, o):
14365  """__ne__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14366  return _IMP_algebra.PrincipalComponentAnalysis2D___ne__(self, o)
14367 
14368 
14369  def __lt__(self, o):
14370  """__lt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14371  return _IMP_algebra.PrincipalComponentAnalysis2D___lt__(self, o)
14372 
14373 
14374  def __gt__(self, o):
14375  """__gt__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14376  return _IMP_algebra.PrincipalComponentAnalysis2D___gt__(self, o)
14377 
14378 
14379  def __ge__(self, o):
14380  """__ge__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14381  return _IMP_algebra.PrincipalComponentAnalysis2D___ge__(self, o)
14382 
14383 
14384  def __le__(self, o):
14385  """__le__(PrincipalComponentAnalysis2D self, PrincipalComponentAnalysis2D o) -> bool"""
14386  return _IMP_algebra.PrincipalComponentAnalysis2D___le__(self, o)
14387 
14388 
14389  def __str__(self):
14390  """__str__(PrincipalComponentAnalysis2D self) -> std::string"""
14391  return _IMP_algebra.PrincipalComponentAnalysis2D___str__(self)
14392 
14393 
14394  def __repr__(self):
14395  """__repr__(PrincipalComponentAnalysis2D self) -> std::string"""
14396  return _IMP_algebra.PrincipalComponentAnalysis2D___repr__(self)
14397 
14398 
14399  def _get_as_binary(self):
14400  """_get_as_binary(PrincipalComponentAnalysis2D self) -> PyObject *"""
14401  return _IMP_algebra.PrincipalComponentAnalysis2D__get_as_binary(self)
14402 
14403 
14404  def _set_from_binary(self, p):
14405  """_set_from_binary(PrincipalComponentAnalysis2D self, PyObject * p)"""
14406  return _IMP_algebra.PrincipalComponentAnalysis2D__set_from_binary(self, p)
14407 
14408 
14409  def __getstate__(self):
14410  p = self._get_as_binary()
14411  if len(self.__dict__) > 1:
14412  d = self.__dict__.copy()
14413  del d['this']
14414  p = (d, p)
14415  return p
14416 
14417  def __setstate__(self, p):
14418  if not hasattr(self, 'this'):
14419  self.__init__()
14420  if isinstance(p, tuple):
14421  d, p = p
14422  self.__dict__.update(d)
14423  return self._set_from_binary(p)
14424 
14425  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis2D
14426  __del__ = lambda self: None
14427 PrincipalComponentAnalysis2D_swigregister = _IMP_algebra.PrincipalComponentAnalysis2D_swigregister
14428 PrincipalComponentAnalysis2D_swigregister(PrincipalComponentAnalysis2D)
14429 
14430 class PrincipalComponentAnalysis3D(_GeometricPrimitive3D):
14431  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(3)> class"""
14432  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14433 
14434  def __init__(self, *args):
14435  """
14436  __init__(IMP::algebra::PrincipalComponentAnalysisD<(3)> self) -> PrincipalComponentAnalysis3D
14437  __init__(IMP::algebra::PrincipalComponentAnalysisD<(3)> self, IMP::Vector< IMP::algebra::VectorD< 3 > > const & pcs, Vector3D values, Vector3D centroid) -> PrincipalComponentAnalysis3D
14438  """
14439  this = _IMP_algebra.new_PrincipalComponentAnalysis3D(*args)
14440  try:
14441  self.this.append(this)
14442  except:
14443  self.this = this
14444 
14445  def get_principal_components(self):
14446  """get_principal_components(PrincipalComponentAnalysis3D self) -> IMP::Vector< IMP::algebra::VectorD< 3 > >"""
14447  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_components(self)
14448 
14449 
14450  def get_principal_component(self, i):
14451  """get_principal_component(PrincipalComponentAnalysis3D self, unsigned int i) -> Vector3D"""
14452  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_component(self, i)
14453 
14454 
14455  def get_principal_values(self):
14456  """get_principal_values(PrincipalComponentAnalysis3D self) -> Vector3D"""
14457  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_values(self)
14458 
14459 
14460  def get_principal_value(self, i):
14461  """get_principal_value(PrincipalComponentAnalysis3D self, unsigned int i) -> double"""
14462  return _IMP_algebra.PrincipalComponentAnalysis3D_get_principal_value(self, i)
14463 
14464 
14465  def get_centroid(self):
14466  """get_centroid(PrincipalComponentAnalysis3D self) -> Vector3D"""
14467  return _IMP_algebra.PrincipalComponentAnalysis3D_get_centroid(self)
14468 
14469 
14470  def set_centroid(self, cntr):
14471  """set_centroid(PrincipalComponentAnalysis3D self, Vector3D cntr)"""
14472  return _IMP_algebra.PrincipalComponentAnalysis3D_set_centroid(self, cntr)
14473 
14474 
14475  def show(self, *args):
14476  """
14477  show(PrincipalComponentAnalysis3D self, _ostream out)
14478  show(PrincipalComponentAnalysis3D self)
14479  """
14480  return _IMP_algebra.PrincipalComponentAnalysis3D_show(self, *args)
14481 
14482 
14483  def __cmp__(self, o):
14484  """__cmp__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> int"""
14485  return _IMP_algebra.PrincipalComponentAnalysis3D___cmp__(self, o)
14486 
14487 
14488  def __eq__(self, o):
14489  """__eq__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14490  return _IMP_algebra.PrincipalComponentAnalysis3D___eq__(self, o)
14491 
14492 
14493  def __ne__(self, o):
14494  """__ne__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14495  return _IMP_algebra.PrincipalComponentAnalysis3D___ne__(self, o)
14496 
14497 
14498  def __lt__(self, o):
14499  """__lt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14500  return _IMP_algebra.PrincipalComponentAnalysis3D___lt__(self, o)
14501 
14502 
14503  def __gt__(self, o):
14504  """__gt__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14505  return _IMP_algebra.PrincipalComponentAnalysis3D___gt__(self, o)
14506 
14507 
14508  def __ge__(self, o):
14509  """__ge__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14510  return _IMP_algebra.PrincipalComponentAnalysis3D___ge__(self, o)
14511 
14512 
14513  def __le__(self, o):
14514  """__le__(PrincipalComponentAnalysis3D self, PrincipalComponentAnalysis3D o) -> bool"""
14515  return _IMP_algebra.PrincipalComponentAnalysis3D___le__(self, o)
14516 
14517 
14518  def __str__(self):
14519  """__str__(PrincipalComponentAnalysis3D self) -> std::string"""
14520  return _IMP_algebra.PrincipalComponentAnalysis3D___str__(self)
14521 
14522 
14523  def __repr__(self):
14524  """__repr__(PrincipalComponentAnalysis3D self) -> std::string"""
14525  return _IMP_algebra.PrincipalComponentAnalysis3D___repr__(self)
14526 
14527 
14528  def _get_as_binary(self):
14529  """_get_as_binary(PrincipalComponentAnalysis3D self) -> PyObject *"""
14530  return _IMP_algebra.PrincipalComponentAnalysis3D__get_as_binary(self)
14531 
14532 
14533  def _set_from_binary(self, p):
14534  """_set_from_binary(PrincipalComponentAnalysis3D self, PyObject * p)"""
14535  return _IMP_algebra.PrincipalComponentAnalysis3D__set_from_binary(self, p)
14536 
14537 
14538  def __getstate__(self):
14539  p = self._get_as_binary()
14540  if len(self.__dict__) > 1:
14541  d = self.__dict__.copy()
14542  del d['this']
14543  p = (d, p)
14544  return p
14545 
14546  def __setstate__(self, p):
14547  if not hasattr(self, 'this'):
14548  self.__init__()
14549  if isinstance(p, tuple):
14550  d, p = p
14551  self.__dict__.update(d)
14552  return self._set_from_binary(p)
14553 
14554  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis3D
14555  __del__ = lambda self: None
14556 PrincipalComponentAnalysis3D_swigregister = _IMP_algebra.PrincipalComponentAnalysis3D_swigregister
14557 PrincipalComponentAnalysis3D_swigregister(PrincipalComponentAnalysis3D)
14558 
14559 class PrincipalComponentAnalysis4D(_GeometricPrimitive4D):
14560  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(4)> class"""
14561  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14562 
14563  def __init__(self, *args):
14564  """
14565  __init__(IMP::algebra::PrincipalComponentAnalysisD<(4)> self) -> PrincipalComponentAnalysis4D
14566  __init__(IMP::algebra::PrincipalComponentAnalysisD<(4)> self, IMP::Vector< IMP::algebra::VectorD< 4 > > const & pcs, Vector4D values, Vector4D centroid) -> PrincipalComponentAnalysis4D
14567  """
14568  this = _IMP_algebra.new_PrincipalComponentAnalysis4D(*args)
14569  try:
14570  self.this.append(this)
14571  except:
14572  self.this = this
14573 
14574  def get_principal_components(self):
14575  """get_principal_components(PrincipalComponentAnalysis4D self) -> IMP::Vector< IMP::algebra::VectorD< 4 > >"""
14576  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_components(self)
14577 
14578 
14579  def get_principal_component(self, i):
14580  """get_principal_component(PrincipalComponentAnalysis4D self, unsigned int i) -> Vector4D"""
14581  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_component(self, i)
14582 
14583 
14584  def get_principal_values(self):
14585  """get_principal_values(PrincipalComponentAnalysis4D self) -> Vector4D"""
14586  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_values(self)
14587 
14588 
14589  def get_principal_value(self, i):
14590  """get_principal_value(PrincipalComponentAnalysis4D self, unsigned int i) -> double"""
14591  return _IMP_algebra.PrincipalComponentAnalysis4D_get_principal_value(self, i)
14592 
14593 
14594  def get_centroid(self):
14595  """get_centroid(PrincipalComponentAnalysis4D self) -> Vector4D"""
14596  return _IMP_algebra.PrincipalComponentAnalysis4D_get_centroid(self)
14597 
14598 
14599  def set_centroid(self, cntr):
14600  """set_centroid(PrincipalComponentAnalysis4D self, Vector4D cntr)"""
14601  return _IMP_algebra.PrincipalComponentAnalysis4D_set_centroid(self, cntr)
14602 
14603 
14604  def show(self, *args):
14605  """
14606  show(PrincipalComponentAnalysis4D self, _ostream out)
14607  show(PrincipalComponentAnalysis4D self)
14608  """
14609  return _IMP_algebra.PrincipalComponentAnalysis4D_show(self, *args)
14610 
14611 
14612  def __cmp__(self, o):
14613  """__cmp__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> int"""
14614  return _IMP_algebra.PrincipalComponentAnalysis4D___cmp__(self, o)
14615 
14616 
14617  def __eq__(self, o):
14618  """__eq__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14619  return _IMP_algebra.PrincipalComponentAnalysis4D___eq__(self, o)
14620 
14621 
14622  def __ne__(self, o):
14623  """__ne__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14624  return _IMP_algebra.PrincipalComponentAnalysis4D___ne__(self, o)
14625 
14626 
14627  def __lt__(self, o):
14628  """__lt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14629  return _IMP_algebra.PrincipalComponentAnalysis4D___lt__(self, o)
14630 
14631 
14632  def __gt__(self, o):
14633  """__gt__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14634  return _IMP_algebra.PrincipalComponentAnalysis4D___gt__(self, o)
14635 
14636 
14637  def __ge__(self, o):
14638  """__ge__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14639  return _IMP_algebra.PrincipalComponentAnalysis4D___ge__(self, o)
14640 
14641 
14642  def __le__(self, o):
14643  """__le__(PrincipalComponentAnalysis4D self, PrincipalComponentAnalysis4D o) -> bool"""
14644  return _IMP_algebra.PrincipalComponentAnalysis4D___le__(self, o)
14645 
14646 
14647  def __str__(self):
14648  """__str__(PrincipalComponentAnalysis4D self) -> std::string"""
14649  return _IMP_algebra.PrincipalComponentAnalysis4D___str__(self)
14650 
14651 
14652  def __repr__(self):
14653  """__repr__(PrincipalComponentAnalysis4D self) -> std::string"""
14654  return _IMP_algebra.PrincipalComponentAnalysis4D___repr__(self)
14655 
14656 
14657  def _get_as_binary(self):
14658  """_get_as_binary(PrincipalComponentAnalysis4D self) -> PyObject *"""
14659  return _IMP_algebra.PrincipalComponentAnalysis4D__get_as_binary(self)
14660 
14661 
14662  def _set_from_binary(self, p):
14663  """_set_from_binary(PrincipalComponentAnalysis4D self, PyObject * p)"""
14664  return _IMP_algebra.PrincipalComponentAnalysis4D__set_from_binary(self, p)
14665 
14666 
14667  def __getstate__(self):
14668  p = self._get_as_binary()
14669  if len(self.__dict__) > 1:
14670  d = self.__dict__.copy()
14671  del d['this']
14672  p = (d, p)
14673  return p
14674 
14675  def __setstate__(self, p):
14676  if not hasattr(self, 'this'):
14677  self.__init__()
14678  if isinstance(p, tuple):
14679  d, p = p
14680  self.__dict__.update(d)
14681  return self._set_from_binary(p)
14682 
14683  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis4D
14684  __del__ = lambda self: None
14685 PrincipalComponentAnalysis4D_swigregister = _IMP_algebra.PrincipalComponentAnalysis4D_swigregister
14686 PrincipalComponentAnalysis4D_swigregister(PrincipalComponentAnalysis4D)
14687 
14688 class PrincipalComponentAnalysis5D(_GeometricPrimitive5D):
14689  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(5)> class"""
14690  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14691 
14692  def __init__(self, *args):
14693  """
14694  __init__(IMP::algebra::PrincipalComponentAnalysisD<(5)> self) -> PrincipalComponentAnalysis5D
14695  __init__(IMP::algebra::PrincipalComponentAnalysisD<(5)> self, IMP::Vector< IMP::algebra::VectorD< 5 > > const & pcs, Vector5D values, Vector5D centroid) -> PrincipalComponentAnalysis5D
14696  """
14697  this = _IMP_algebra.new_PrincipalComponentAnalysis5D(*args)
14698  try:
14699  self.this.append(this)
14700  except:
14701  self.this = this
14702 
14703  def get_principal_components(self):
14704  """get_principal_components(PrincipalComponentAnalysis5D self) -> IMP::Vector< IMP::algebra::VectorD< 5 > >"""
14705  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_components(self)
14706 
14707 
14708  def get_principal_component(self, i):
14709  """get_principal_component(PrincipalComponentAnalysis5D self, unsigned int i) -> Vector5D"""
14710  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_component(self, i)
14711 
14712 
14713  def get_principal_values(self):
14714  """get_principal_values(PrincipalComponentAnalysis5D self) -> Vector5D"""
14715  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_values(self)
14716 
14717 
14718  def get_principal_value(self, i):
14719  """get_principal_value(PrincipalComponentAnalysis5D self, unsigned int i) -> double"""
14720  return _IMP_algebra.PrincipalComponentAnalysis5D_get_principal_value(self, i)
14721 
14722 
14723  def get_centroid(self):
14724  """get_centroid(PrincipalComponentAnalysis5D self) -> Vector5D"""
14725  return _IMP_algebra.PrincipalComponentAnalysis5D_get_centroid(self)
14726 
14727 
14728  def set_centroid(self, cntr):
14729  """set_centroid(PrincipalComponentAnalysis5D self, Vector5D cntr)"""
14730  return _IMP_algebra.PrincipalComponentAnalysis5D_set_centroid(self, cntr)
14731 
14732 
14733  def show(self, *args):
14734  """
14735  show(PrincipalComponentAnalysis5D self, _ostream out)
14736  show(PrincipalComponentAnalysis5D self)
14737  """
14738  return _IMP_algebra.PrincipalComponentAnalysis5D_show(self, *args)
14739 
14740 
14741  def __cmp__(self, o):
14742  """__cmp__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> int"""
14743  return _IMP_algebra.PrincipalComponentAnalysis5D___cmp__(self, o)
14744 
14745 
14746  def __eq__(self, o):
14747  """__eq__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14748  return _IMP_algebra.PrincipalComponentAnalysis5D___eq__(self, o)
14749 
14750 
14751  def __ne__(self, o):
14752  """__ne__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14753  return _IMP_algebra.PrincipalComponentAnalysis5D___ne__(self, o)
14754 
14755 
14756  def __lt__(self, o):
14757  """__lt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14758  return _IMP_algebra.PrincipalComponentAnalysis5D___lt__(self, o)
14759 
14760 
14761  def __gt__(self, o):
14762  """__gt__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14763  return _IMP_algebra.PrincipalComponentAnalysis5D___gt__(self, o)
14764 
14765 
14766  def __ge__(self, o):
14767  """__ge__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14768  return _IMP_algebra.PrincipalComponentAnalysis5D___ge__(self, o)
14769 
14770 
14771  def __le__(self, o):
14772  """__le__(PrincipalComponentAnalysis5D self, PrincipalComponentAnalysis5D o) -> bool"""
14773  return _IMP_algebra.PrincipalComponentAnalysis5D___le__(self, o)
14774 
14775 
14776  def __str__(self):
14777  """__str__(PrincipalComponentAnalysis5D self) -> std::string"""
14778  return _IMP_algebra.PrincipalComponentAnalysis5D___str__(self)
14779 
14780 
14781  def __repr__(self):
14782  """__repr__(PrincipalComponentAnalysis5D self) -> std::string"""
14783  return _IMP_algebra.PrincipalComponentAnalysis5D___repr__(self)
14784 
14785 
14786  def _get_as_binary(self):
14787  """_get_as_binary(PrincipalComponentAnalysis5D self) -> PyObject *"""
14788  return _IMP_algebra.PrincipalComponentAnalysis5D__get_as_binary(self)
14789 
14790 
14791  def _set_from_binary(self, p):
14792  """_set_from_binary(PrincipalComponentAnalysis5D self, PyObject * p)"""
14793  return _IMP_algebra.PrincipalComponentAnalysis5D__set_from_binary(self, p)
14794 
14795 
14796  def __getstate__(self):
14797  p = self._get_as_binary()
14798  if len(self.__dict__) > 1:
14799  d = self.__dict__.copy()
14800  del d['this']
14801  p = (d, p)
14802  return p
14803 
14804  def __setstate__(self, p):
14805  if not hasattr(self, 'this'):
14806  self.__init__()
14807  if isinstance(p, tuple):
14808  d, p = p
14809  self.__dict__.update(d)
14810  return self._set_from_binary(p)
14811 
14812  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis5D
14813  __del__ = lambda self: None
14814 PrincipalComponentAnalysis5D_swigregister = _IMP_algebra.PrincipalComponentAnalysis5D_swigregister
14815 PrincipalComponentAnalysis5D_swigregister(PrincipalComponentAnalysis5D)
14816 
14817 class PrincipalComponentAnalysis6D(_GeometricPrimitive6D):
14818  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(6)> class"""
14819  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14820 
14821  def __init__(self, *args):
14822  """
14823  __init__(IMP::algebra::PrincipalComponentAnalysisD<(6)> self) -> PrincipalComponentAnalysis6D
14824  __init__(IMP::algebra::PrincipalComponentAnalysisD<(6)> self, IMP::Vector< IMP::algebra::VectorD< 6 > > const & pcs, Vector6D values, Vector6D centroid) -> PrincipalComponentAnalysis6D
14825  """
14826  this = _IMP_algebra.new_PrincipalComponentAnalysis6D(*args)
14827  try:
14828  self.this.append(this)
14829  except:
14830  self.this = this
14831 
14832  def get_principal_components(self):
14833  """get_principal_components(PrincipalComponentAnalysis6D self) -> IMP::Vector< IMP::algebra::VectorD< 6 > >"""
14834  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_components(self)
14835 
14836 
14837  def get_principal_component(self, i):
14838  """get_principal_component(PrincipalComponentAnalysis6D self, unsigned int i) -> Vector6D"""
14839  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_component(self, i)
14840 
14841 
14842  def get_principal_values(self):
14843  """get_principal_values(PrincipalComponentAnalysis6D self) -> Vector6D"""
14844  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_values(self)
14845 
14846 
14847  def get_principal_value(self, i):
14848  """get_principal_value(PrincipalComponentAnalysis6D self, unsigned int i) -> double"""
14849  return _IMP_algebra.PrincipalComponentAnalysis6D_get_principal_value(self, i)
14850 
14851 
14852  def get_centroid(self):
14853  """get_centroid(PrincipalComponentAnalysis6D self) -> Vector6D"""
14854  return _IMP_algebra.PrincipalComponentAnalysis6D_get_centroid(self)
14855 
14856 
14857  def set_centroid(self, cntr):
14858  """set_centroid(PrincipalComponentAnalysis6D self, Vector6D cntr)"""
14859  return _IMP_algebra.PrincipalComponentAnalysis6D_set_centroid(self, cntr)
14860 
14861 
14862  def show(self, *args):
14863  """
14864  show(PrincipalComponentAnalysis6D self, _ostream out)
14865  show(PrincipalComponentAnalysis6D self)
14866  """
14867  return _IMP_algebra.PrincipalComponentAnalysis6D_show(self, *args)
14868 
14869 
14870  def __cmp__(self, o):
14871  """__cmp__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> int"""
14872  return _IMP_algebra.PrincipalComponentAnalysis6D___cmp__(self, o)
14873 
14874 
14875  def __eq__(self, o):
14876  """__eq__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14877  return _IMP_algebra.PrincipalComponentAnalysis6D___eq__(self, o)
14878 
14879 
14880  def __ne__(self, o):
14881  """__ne__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14882  return _IMP_algebra.PrincipalComponentAnalysis6D___ne__(self, o)
14883 
14884 
14885  def __lt__(self, o):
14886  """__lt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14887  return _IMP_algebra.PrincipalComponentAnalysis6D___lt__(self, o)
14888 
14889 
14890  def __gt__(self, o):
14891  """__gt__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14892  return _IMP_algebra.PrincipalComponentAnalysis6D___gt__(self, o)
14893 
14894 
14895  def __ge__(self, o):
14896  """__ge__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14897  return _IMP_algebra.PrincipalComponentAnalysis6D___ge__(self, o)
14898 
14899 
14900  def __le__(self, o):
14901  """__le__(PrincipalComponentAnalysis6D self, PrincipalComponentAnalysis6D o) -> bool"""
14902  return _IMP_algebra.PrincipalComponentAnalysis6D___le__(self, o)
14903 
14904 
14905  def __str__(self):
14906  """__str__(PrincipalComponentAnalysis6D self) -> std::string"""
14907  return _IMP_algebra.PrincipalComponentAnalysis6D___str__(self)
14908 
14909 
14910  def __repr__(self):
14911  """__repr__(PrincipalComponentAnalysis6D self) -> std::string"""
14912  return _IMP_algebra.PrincipalComponentAnalysis6D___repr__(self)
14913 
14914 
14915  def _get_as_binary(self):
14916  """_get_as_binary(PrincipalComponentAnalysis6D self) -> PyObject *"""
14917  return _IMP_algebra.PrincipalComponentAnalysis6D__get_as_binary(self)
14918 
14919 
14920  def _set_from_binary(self, p):
14921  """_set_from_binary(PrincipalComponentAnalysis6D self, PyObject * p)"""
14922  return _IMP_algebra.PrincipalComponentAnalysis6D__set_from_binary(self, p)
14923 
14924 
14925  def __getstate__(self):
14926  p = self._get_as_binary()
14927  if len(self.__dict__) > 1:
14928  d = self.__dict__.copy()
14929  del d['this']
14930  p = (d, p)
14931  return p
14932 
14933  def __setstate__(self, p):
14934  if not hasattr(self, 'this'):
14935  self.__init__()
14936  if isinstance(p, tuple):
14937  d, p = p
14938  self.__dict__.update(d)
14939  return self._set_from_binary(p)
14940 
14941  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysis6D
14942  __del__ = lambda self: None
14943 PrincipalComponentAnalysis6D_swigregister = _IMP_algebra.PrincipalComponentAnalysis6D_swigregister
14944 PrincipalComponentAnalysis6D_swigregister(PrincipalComponentAnalysis6D)
14945 
14946 class PrincipalComponentAnalysisKD(_GeometricPrimitiveKD):
14947  """Proxy of C++ IMP::algebra::PrincipalComponentAnalysisD<(-1)> class"""
14948  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
14949 
14950  def __init__(self, *args):
14951  """
14952  __init__(IMP::algebra::PrincipalComponentAnalysisD<(-1)> self) -> PrincipalComponentAnalysisKD
14953  __init__(IMP::algebra::PrincipalComponentAnalysisD<(-1)> self, IMP::Vector< IMP::algebra::VectorD< -1 > > const & pcs, VectorKD values, VectorKD centroid) -> PrincipalComponentAnalysisKD
14954  """
14955  this = _IMP_algebra.new_PrincipalComponentAnalysisKD(*args)
14956  try:
14957  self.this.append(this)
14958  except:
14959  self.this = this
14960 
14961  def get_principal_components(self):
14962  """get_principal_components(PrincipalComponentAnalysisKD self) -> IMP::Vector< IMP::algebra::VectorD< -1 > >"""
14963  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_components(self)
14964 
14965 
14966  def get_principal_component(self, i):
14967  """get_principal_component(PrincipalComponentAnalysisKD self, unsigned int i) -> VectorKD"""
14968  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_component(self, i)
14969 
14970 
14971  def get_principal_values(self):
14972  """get_principal_values(PrincipalComponentAnalysisKD self) -> VectorKD"""
14973  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_values(self)
14974 
14975 
14976  def get_principal_value(self, i):
14977  """get_principal_value(PrincipalComponentAnalysisKD self, unsigned int i) -> double"""
14978  return _IMP_algebra.PrincipalComponentAnalysisKD_get_principal_value(self, i)
14979 
14980 
14981  def get_centroid(self):
14982  """get_centroid(PrincipalComponentAnalysisKD self) -> VectorKD"""
14983  return _IMP_algebra.PrincipalComponentAnalysisKD_get_centroid(self)
14984 
14985 
14986  def set_centroid(self, cntr):
14987  """set_centroid(PrincipalComponentAnalysisKD self, VectorKD cntr)"""
14988  return _IMP_algebra.PrincipalComponentAnalysisKD_set_centroid(self, cntr)
14989 
14990 
14991  def show(self, *args):
14992  """
14993  show(PrincipalComponentAnalysisKD self, _ostream out)
14994  show(PrincipalComponentAnalysisKD self)
14995  """
14996  return _IMP_algebra.PrincipalComponentAnalysisKD_show(self, *args)
14997 
14998 
14999  def __cmp__(self, o):
15000  """__cmp__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> int"""
15001  return _IMP_algebra.PrincipalComponentAnalysisKD___cmp__(self, o)
15002 
15003 
15004  def __eq__(self, o):
15005  """__eq__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15006  return _IMP_algebra.PrincipalComponentAnalysisKD___eq__(self, o)
15007 
15008 
15009  def __ne__(self, o):
15010  """__ne__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15011  return _IMP_algebra.PrincipalComponentAnalysisKD___ne__(self, o)
15012 
15013 
15014  def __lt__(self, o):
15015  """__lt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15016  return _IMP_algebra.PrincipalComponentAnalysisKD___lt__(self, o)
15017 
15018 
15019  def __gt__(self, o):
15020  """__gt__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15021  return _IMP_algebra.PrincipalComponentAnalysisKD___gt__(self, o)
15022 
15023 
15024  def __ge__(self, o):
15025  """__ge__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15026  return _IMP_algebra.PrincipalComponentAnalysisKD___ge__(self, o)
15027 
15028 
15029  def __le__(self, o):
15030  """__le__(PrincipalComponentAnalysisKD self, PrincipalComponentAnalysisKD o) -> bool"""
15031  return _IMP_algebra.PrincipalComponentAnalysisKD___le__(self, o)
15032 
15033 
15034  def __str__(self):
15035  """__str__(PrincipalComponentAnalysisKD self) -> std::string"""
15036  return _IMP_algebra.PrincipalComponentAnalysisKD___str__(self)
15037 
15038 
15039  def __repr__(self):
15040  """__repr__(PrincipalComponentAnalysisKD self) -> std::string"""
15041  return _IMP_algebra.PrincipalComponentAnalysisKD___repr__(self)
15042 
15043 
15044  def _get_as_binary(self):
15045  """_get_as_binary(PrincipalComponentAnalysisKD self) -> PyObject *"""
15046  return _IMP_algebra.PrincipalComponentAnalysisKD__get_as_binary(self)
15047 
15048 
15049  def _set_from_binary(self, p):
15050  """_set_from_binary(PrincipalComponentAnalysisKD self, PyObject * p)"""
15051  return _IMP_algebra.PrincipalComponentAnalysisKD__set_from_binary(self, p)
15052 
15053 
15054  def __getstate__(self):
15055  p = self._get_as_binary()
15056  if len(self.__dict__) > 1:
15057  d = self.__dict__.copy()
15058  del d['this']
15059  p = (d, p)
15060  return p
15061 
15062  def __setstate__(self, p):
15063  if not hasattr(self, 'this'):
15064  self.__init__()
15065  if isinstance(p, tuple):
15066  d, p = p
15067  self.__dict__.update(d)
15068  return self._set_from_binary(p)
15069 
15070  __swig_destroy__ = _IMP_algebra.delete_PrincipalComponentAnalysisKD
15071  __del__ = lambda self: None
15072 PrincipalComponentAnalysisKD_swigregister = _IMP_algebra.PrincipalComponentAnalysisKD_swigregister
15073 PrincipalComponentAnalysisKD_swigregister(PrincipalComponentAnalysisKD)
15074 
15075 
15076 def get_principal_components(*args):
15077  """
15078  get_principal_components(IMP::Vector< IMP::algebra::Vector1D > const & a) -> PrincipalComponentAnalysis1D
15079  get_principal_components(IMP::Vector< IMP::algebra::Vector2D > const & a) -> PrincipalComponentAnalysis2D
15080  get_principal_components(IMP::Vector< IMP::algebra::Vector3D > const & a) -> PrincipalComponentAnalysis3D
15081  get_principal_components(IMP::Vector< IMP::algebra::Vector4D > const & a) -> PrincipalComponentAnalysis4D
15082  get_principal_components(IMP::Vector< IMP::algebra::Vector5D > const & a) -> PrincipalComponentAnalysis5D
15083  get_principal_components(IMP::Vector< IMP::algebra::Vector6D > const & a) -> PrincipalComponentAnalysis6D
15084  get_principal_components(IMP::Vector< IMP::algebra::VectorKD > const & a) -> PrincipalComponentAnalysisKD
15085  """
15086  return _IMP_algebra.get_principal_components(*args)
15087 
15088 def get_distance(*args):
15089  """
15090  get_distance(Rotation3D r0, Rotation3D r1) -> double
15091  get_distance(Line3D s, Vector3D p) -> double
15092  get_distance(Line3D a, Line3D b) -> double
15093  get_distance(Segment3D s, Vector3D p) -> double
15094  get_distance(Segment3D a, Segment3D b) -> double
15095  get_distance(Plane3D pln, Vector3D p) -> double
15096  get_distance(Vector1D a, Vector1D b) -> double
15097  get_distance(Vector2D a, Vector2D b) -> double
15098  get_distance(Vector3D a, Vector3D b) -> double
15099  get_distance(Vector4D a, Vector4D b) -> double
15100  get_distance(Vector5D a, Vector5D b) -> double
15101  get_distance(Vector6D a, Vector6D b) -> double
15102  get_distance(VectorKD a, VectorKD b) -> double
15103  get_distance(Sphere1D a, Sphere1D b) -> double
15104  get_distance(Sphere2D a, Sphere2D b) -> double
15105  get_distance(Sphere3D a, Sphere3D b) -> double
15106  get_distance(Sphere4D a, Sphere4D b) -> double
15107  get_distance(Sphere5D a, Sphere5D b) -> double
15108  get_distance(Sphere6D a, Sphere6D b) -> double
15109  get_distance(SphereKD a, SphereKD b) -> double
15110  """
15111  return _IMP_algebra.get_distance(*args)
15112 
15113 def get_squared_distance(*args):
15114  """
15115  get_squared_distance(Vector1D a, Vector1D b) -> double
15116  get_squared_distance(Vector2D a, Vector2D b) -> double
15117  get_squared_distance(Vector3D a, Vector3D b) -> double
15118  get_squared_distance(Vector4D a, Vector4D b) -> double
15119  get_squared_distance(Vector5D a, Vector5D b) -> double
15120  get_squared_distance(Vector6D a, Vector6D b) -> double
15121  get_squared_distance(VectorKD a, VectorKD b) -> double
15122  """
15123  return _IMP_algebra.get_squared_distance(*args)
15124 
15125 def get_basis_vector_1d(coordinate):
15126  """get_basis_vector_1d(unsigned int coordinate) -> Vector1D"""
15127  return _IMP_algebra.get_basis_vector_1d(coordinate)
15128 
15129 def get_basis_vector_2d(coordinate):
15130  """get_basis_vector_2d(unsigned int coordinate) -> Vector2D"""
15131  return _IMP_algebra.get_basis_vector_2d(coordinate)
15132 
15133 def get_basis_vector_3d(coordinate):
15134  """get_basis_vector_3d(unsigned int coordinate) -> Vector3D"""
15135  return _IMP_algebra.get_basis_vector_3d(coordinate)
15136 
15137 def get_basis_vector_4d(coordinate):
15138  """get_basis_vector_4d(unsigned int coordinate) -> Vector4D"""
15139  return _IMP_algebra.get_basis_vector_4d(coordinate)
15140 
15141 def get_basis_vector_5d(coordinate):
15142  """get_basis_vector_5d(unsigned int coordinate) -> Vector5D"""
15143  return _IMP_algebra.get_basis_vector_5d(coordinate)
15144 
15145 def get_basis_vector_6d(coordinate):
15146  """get_basis_vector_6d(unsigned int coordinate) -> Vector6D"""
15147  return _IMP_algebra.get_basis_vector_6d(coordinate)
15148 
15149 def get_zero_vector_1d():
15150  """get_zero_vector_1d() -> Vector1D"""
15151  return _IMP_algebra.get_zero_vector_1d()
15152 
15153 def get_zero_vector_2d():
15154  """get_zero_vector_2d() -> Vector2D"""
15155  return _IMP_algebra.get_zero_vector_2d()
15156 
15157 def get_zero_vector_3d():
15158  """get_zero_vector_3d() -> Vector3D"""
15159  return _IMP_algebra.get_zero_vector_3d()
15160 
15161 def get_zero_vector_4d():
15162  """get_zero_vector_4d() -> Vector4D"""
15163  return _IMP_algebra.get_zero_vector_4d()
15164 
15165 def get_zero_vector_5d():
15166  """get_zero_vector_5d() -> Vector5D"""
15167  return _IMP_algebra.get_zero_vector_5d()
15168 
15169 def get_zero_vector_6d():
15170  """get_zero_vector_6d() -> Vector6D"""
15171  return _IMP_algebra.get_zero_vector_6d()
15172 
15173 def get_ones_vector_1d(v=1):
15174  """
15175  get_ones_vector_1d(double v=1) -> Vector1D
15176  get_ones_vector_1d() -> Vector1D
15177  """
15178  return _IMP_algebra.get_ones_vector_1d(v)
15179 
15180 def get_ones_vector_2d(v=1):
15181  """
15182  get_ones_vector_2d(double v=1) -> Vector2D
15183  get_ones_vector_2d() -> Vector2D
15184  """
15185  return _IMP_algebra.get_ones_vector_2d(v)
15186 
15187 def get_ones_vector_3d(v=1):
15188  """
15189  get_ones_vector_3d(double v=1) -> Vector3D
15190  get_ones_vector_3d() -> Vector3D
15191  """
15192  return _IMP_algebra.get_ones_vector_3d(v)
15193 
15194 def get_ones_vector_4d(v=1):
15195  """
15196  get_ones_vector_4d(double v=1) -> Vector4D
15197  get_ones_vector_4d() -> Vector4D
15198  """
15199  return _IMP_algebra.get_ones_vector_4d(v)
15200 
15201 def get_ones_vector_5d(v=1):
15202  """
15203  get_ones_vector_5d(double v=1) -> Vector5D
15204  get_ones_vector_5d() -> Vector5D
15205  """
15206  return _IMP_algebra.get_ones_vector_5d(v)
15207 
15208 def get_ones_vector_6d(v=1):
15209  """
15210  get_ones_vector_6d(double v=1) -> Vector6D
15211  get_ones_vector_6d() -> Vector6D
15212  """
15213  return _IMP_algebra.get_ones_vector_6d(v)
15214 
15215 def get_unit_bounding_box_1d():
15216  """get_unit_bounding_box_1d() -> BoundingBox1D"""
15217  return _IMP_algebra.get_unit_bounding_box_1d()
15218 
15219 def get_unit_bounding_box_2d():
15220  """get_unit_bounding_box_2d() -> BoundingBox2D"""
15221  return _IMP_algebra.get_unit_bounding_box_2d()
15222 
15223 def get_unit_bounding_box_3d():
15224  """get_unit_bounding_box_3d() -> BoundingBox3D"""
15225  return _IMP_algebra.get_unit_bounding_box_3d()
15226 
15227 def get_unit_bounding_box_4d():
15228  """get_unit_bounding_box_4d() -> BoundingBox4D"""
15229  return _IMP_algebra.get_unit_bounding_box_4d()
15230 
15231 def get_unit_bounding_box_5d():
15232  """get_unit_bounding_box_5d() -> BoundingBox5D"""
15233  return _IMP_algebra.get_unit_bounding_box_5d()
15234 
15235 def get_unit_bounding_box_6d():
15236  """get_unit_bounding_box_6d() -> BoundingBox6D"""
15237  return _IMP_algebra.get_unit_bounding_box_6d()
15238 
15239 def get_cube_1d(radius):
15240  """get_cube_1d(double radius) -> BoundingBox1D"""
15241  return _IMP_algebra.get_cube_1d(radius)
15242 
15243 def get_cube_2d(radius):
15244  """get_cube_2d(double radius) -> BoundingBox2D"""
15245  return _IMP_algebra.get_cube_2d(radius)
15246 
15247 def get_cube_3d(radius):
15248  """get_cube_3d(double radius) -> BoundingBox3D"""
15249  return _IMP_algebra.get_cube_3d(radius)
15250 
15251 def get_cube_4d(radius):
15252  """get_cube_4d(double radius) -> BoundingBox4D"""
15253  return _IMP_algebra.get_cube_4d(radius)
15254 
15255 def get_cube_5d(radius):
15256  """get_cube_5d(double radius) -> BoundingBox5D"""
15257  return _IMP_algebra.get_cube_5d(radius)
15258 
15259 def get_cube_6d(radius):
15260  """get_cube_6d(double radius) -> BoundingBox6D"""
15261  return _IMP_algebra.get_cube_6d(radius)
15262 
15263 def get_unit_sphere_1d():
15264  """get_unit_sphere_1d() -> Sphere1D"""
15265  return _IMP_algebra.get_unit_sphere_1d()
15266 
15267 def get_unit_sphere_2d():
15268  """get_unit_sphere_2d() -> Sphere2D"""
15269  return _IMP_algebra.get_unit_sphere_2d()
15270 
15271 def get_unit_sphere_3d():
15272  """get_unit_sphere_3d() -> Sphere3D"""
15273  return _IMP_algebra.get_unit_sphere_3d()
15274 
15275 def get_unit_sphere_4d():
15276  """get_unit_sphere_4d() -> Sphere4D"""
15277  return _IMP_algebra.get_unit_sphere_4d()
15278 
15279 def get_unit_sphere_5d():
15280  """get_unit_sphere_5d() -> Sphere5D"""
15281  return _IMP_algebra.get_unit_sphere_5d()
15282 
15283 def get_unit_sphere_6d():
15284  """get_unit_sphere_6d() -> Sphere6D"""
15285  return _IMP_algebra.get_unit_sphere_6d()
15286 
15287 def get_interiors_intersect(*args):
15288  """
15289  get_interiors_intersect(Sphere1D a, Sphere1D b) -> bool
15290  get_interiors_intersect(Sphere2D a, Sphere2D b) -> bool
15291  get_interiors_intersect(Sphere3D a, Sphere3D b) -> bool
15292  get_interiors_intersect(Sphere4D a, Sphere4D b) -> bool
15293  get_interiors_intersect(Sphere5D a, Sphere5D b) -> bool
15294  get_interiors_intersect(Sphere6D a, Sphere6D b) -> bool
15295  get_interiors_intersect(SphereKD a, SphereKD b) -> bool
15296  get_interiors_intersect(BoundingBox1D a, BoundingBox1D b) -> bool
15297  get_interiors_intersect(BoundingBox2D a, BoundingBox2D b) -> bool
15298  get_interiors_intersect(BoundingBox3D a, BoundingBox3D b) -> bool
15299  get_interiors_intersect(BoundingBox4D a, BoundingBox4D b) -> bool
15300  get_interiors_intersect(BoundingBox5D a, BoundingBox5D b) -> bool
15301  get_interiors_intersect(BoundingBox6D a, BoundingBox6D b) -> bool
15302  get_interiors_intersect(BoundingBoxKD a, BoundingBoxKD b) -> bool
15303  """
15304  return _IMP_algebra.get_interiors_intersect(*args)
15305 
15306 def get_random_vector_on(*args):
15307  """
15308  get_random_vector_on(Sphere1D a) -> Vector1D
15309  get_random_vector_on(Sphere2D a) -> Vector2D
15310  get_random_vector_on(Sphere3D a) -> Vector3D
15311  get_random_vector_on(Sphere4D a) -> Vector4D
15312  get_random_vector_on(Sphere5D a) -> Vector5D
15313  get_random_vector_on(Sphere6D a) -> Vector6D
15314  get_random_vector_on(SphereKD a) -> VectorKD
15315  get_random_vector_on(UnitSimplex1D a) -> Vector1D
15316  get_random_vector_on(UnitSimplex2D a) -> Vector2D
15317  get_random_vector_on(UnitSimplex3D a) -> Vector3D
15318  get_random_vector_on(UnitSimplex4D a) -> Vector4D
15319  get_random_vector_on(UnitSimplex5D a) -> Vector5D
15320  get_random_vector_on(UnitSimplex6D a) -> Vector6D
15321  get_random_vector_on(UnitSimplexKD a) -> VectorKD
15322  get_random_vector_on(BoundingBox1D a) -> Vector1D
15323  get_random_vector_on(BoundingBox2D a) -> Vector2D
15324  get_random_vector_on(BoundingBox3D a) -> Vector3D
15325  get_random_vector_on(BoundingBox4D a) -> Vector4D
15326  get_random_vector_on(BoundingBox5D a) -> Vector5D
15327  get_random_vector_on(BoundingBox6D a) -> Vector6D
15328  get_random_vector_on(BoundingBoxKD a) -> VectorKD
15329  """
15330  return _IMP_algebra.get_random_vector_on(*args)
15331 
15332 def get_random_vector_in(*args):
15333  """
15334  get_random_vector_in(Cylinder3D c) -> Vector3D
15335  get_random_vector_in(Sphere1D a) -> Vector1D
15336  get_random_vector_in(Sphere2D a) -> Vector2D
15337  get_random_vector_in(Sphere3D a) -> Vector3D
15338  get_random_vector_in(Sphere4D a) -> Vector4D
15339  get_random_vector_in(Sphere5D a) -> Vector5D
15340  get_random_vector_in(Sphere6D a) -> Vector6D
15341  get_random_vector_in(SphereKD a) -> VectorKD
15342  get_random_vector_in(BoundingBox1D a) -> Vector1D
15343  get_random_vector_in(BoundingBox2D a) -> Vector2D
15344  get_random_vector_in(BoundingBox3D a) -> Vector3D
15345  get_random_vector_in(BoundingBox4D a) -> Vector4D
15346  get_random_vector_in(BoundingBox5D a) -> Vector5D
15347  get_random_vector_in(BoundingBox6D a) -> Vector6D
15348  get_random_vector_in(BoundingBoxKD a) -> VectorKD
15349  """
15350  return _IMP_algebra.get_random_vector_in(*args)
15351 
15352 def get_intersection(*args):
15353  """
15354  get_intersection(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
15355  get_intersection(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
15356  get_intersection(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
15357  get_intersection(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
15358  get_intersection(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
15359  get_intersection(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
15360  get_intersection(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
15361  """
15362  return _IMP_algebra.get_intersection(*args)
15363 
15364 def get_union(*args):
15365  """
15366  get_union(BoundingBox1D a, BoundingBox1D b) -> BoundingBox1D
15367  get_union(BoundingBox2D a, BoundingBox2D b) -> BoundingBox2D
15368  get_union(BoundingBox3D a, BoundingBox3D b) -> BoundingBox3D
15369  get_union(BoundingBox4D a, BoundingBox4D b) -> BoundingBox4D
15370  get_union(BoundingBox5D a, BoundingBox5D b) -> BoundingBox5D
15371  get_union(BoundingBox6D a, BoundingBox6D b) -> BoundingBox6D
15372  get_union(BoundingBoxKD a, BoundingBoxKD b) -> BoundingBoxKD
15373  """
15374  return _IMP_algebra.get_union(*args)
15375 
15376 def get_bounding_box(*args):
15377  """
15378  get_bounding_box(Line3D g) -> BoundingBox3D
15379  get_bounding_box(Segment3D g) -> BoundingBox3D
15380  get_bounding_box(Plane3D g) -> BoundingBox3D
15381  get_bounding_box(Cylinder3D g) -> BoundingBox3D
15382  get_bounding_box(Ellipsoid3D g) -> BoundingBox3D
15383  get_bounding_box(SpherePatch3D g) -> BoundingBox3D
15384  get_bounding_box(Cone3D g) -> BoundingBox3D
15385  get_bounding_box(Sphere1D a) -> BoundingBox1D
15386  get_bounding_box(Sphere2D a) -> BoundingBox2D
15387  get_bounding_box(Sphere3D a) -> BoundingBox3D
15388  get_bounding_box(Sphere4D a) -> BoundingBox4D
15389  get_bounding_box(Sphere5D a) -> BoundingBox5D
15390  get_bounding_box(Sphere6D a) -> BoundingBox6D
15391  get_bounding_box(SphereKD a) -> BoundingBoxKD
15392  """
15393  return _IMP_algebra.get_bounding_box(*args)
15394 
15395 def get_uniform_surface_cover(*args):
15396  """
15397  get_uniform_surface_cover(Cylinder3D cyl, int number_of_points) -> IMP::algebra::Vector3Ds
15398  get_uniform_surface_cover(SpherePatch3D sph, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
15399  get_uniform_surface_cover(Cone3D cone, unsigned int number_of_points) -> IMP::algebra::Vector3Ds
15400  get_uniform_surface_cover(IMP::algebra::Sphere3Ds const & arg1, double points_per_square_angstrom) -> IMP::algebra::Vector3Ds
15401  get_uniform_surface_cover(Sphere1D a, unsigned int const & b) -> IMP::algebra::Vector1Ds
15402  get_uniform_surface_cover(Sphere2D a, unsigned int const & b) -> IMP::algebra::Vector2Ds
15403  get_uniform_surface_cover(Sphere3D a, unsigned int const & b) -> IMP::algebra::Vector3Ds
15404  get_uniform_surface_cover(Sphere4D a, unsigned int const & b) -> IMP::algebra::Vector4Ds
15405  get_uniform_surface_cover(Sphere5D a, unsigned int const & b) -> IMP::algebra::Vector5Ds
15406  get_uniform_surface_cover(Sphere6D a, unsigned int const & b) -> IMP::algebra::Vector6Ds
15407  get_uniform_surface_cover(SphereKD a, unsigned int const & b) -> IMP::algebra::VectorKDs
15408  """
15409  return _IMP_algebra.get_uniform_surface_cover(*args)
15410 
15411 def get_grid_interior_cover_by_spacing(*args):
15412  """
15413  get_grid_interior_cover_by_spacing(BoundingBox1D a, double const & b) -> IMP::algebra::Vector1Ds
15414  get_grid_interior_cover_by_spacing(BoundingBox2D a, double const & b) -> IMP::algebra::Vector2Ds
15415  get_grid_interior_cover_by_spacing(BoundingBox3D a, double const & b) -> IMP::algebra::Vector3Ds
15416  get_grid_interior_cover_by_spacing(BoundingBox4D a, double const & b) -> IMP::algebra::Vector4Ds
15417  get_grid_interior_cover_by_spacing(BoundingBox5D a, double const & b) -> IMP::algebra::Vector5Ds
15418  get_grid_interior_cover_by_spacing(BoundingBox6D a, double const & b) -> IMP::algebra::Vector6Ds
15419  get_grid_interior_cover_by_spacing(BoundingBoxKD a, double const & b) -> IMP::algebra::VectorKDs
15420  """
15421  return _IMP_algebra.get_grid_interior_cover_by_spacing(*args)
15422 
15423 def get_projected(*args):
15424  """
15425  get_projected(Line3D l, Vector3D p) -> Vector3D
15426  get_projected(Line3D l, Segment3D s) -> Segment3D
15427  get_projected(UnitSimplex1D a, Vector1D b) -> Vector1D
15428  get_projected(UnitSimplex2D a, Vector2D b) -> Vector2D
15429  get_projected(UnitSimplex3D a, Vector3D b) -> Vector3D
15430  get_projected(UnitSimplex4D a, Vector4D b) -> Vector4D
15431  get_projected(UnitSimplex5D a, Vector5D b) -> Vector5D
15432  get_projected(UnitSimplex6D a, Vector6D b) -> Vector6D
15433  get_projected(UnitSimplexKD a, VectorKD b) -> VectorKD
15434  """
15435  return _IMP_algebra.get_projected(*args)
15436 
15437 def get_vertices(*args):
15438  """
15439  get_vertices(BoundingBox1D a) -> IMP::Vector< IMP::algebra::Vector1D >
15440  get_vertices(BoundingBox2D a) -> IMP::Vector< IMP::algebra::Vector2D >
15441  get_vertices(BoundingBox3D a) -> IMP::Vector< IMP::algebra::Vector3D >
15442  get_vertices(BoundingBox4D a) -> IMP::Vector< IMP::algebra::Vector4D >
15443  get_vertices(BoundingBox5D a) -> IMP::Vector< IMP::algebra::Vector5D >
15444  get_vertices(BoundingBox6D a) -> IMP::Vector< IMP::algebra::Vector6D >
15445  get_vertices(BoundingBoxKD a) -> IMP::Vector< IMP::algebra::VectorKD >
15446  get_vertices(UnitSimplex1D a) -> IMP::Vector< IMP::algebra::Vector1D >
15447  get_vertices(UnitSimplex2D a) -> IMP::Vector< IMP::algebra::Vector2D >
15448  get_vertices(UnitSimplex3D a) -> IMP::Vector< IMP::algebra::Vector3D >
15449  get_vertices(UnitSimplex4D a) -> IMP::Vector< IMP::algebra::Vector4D >
15450  get_vertices(UnitSimplex5D a) -> IMP::Vector< IMP::algebra::Vector5D >
15451  get_vertices(UnitSimplex6D a) -> IMP::Vector< IMP::algebra::Vector6D >
15452  get_vertices(UnitSimplexKD a) -> IMP::Vector< IMP::algebra::VectorKD >
15453  """
15454  return _IMP_algebra.get_vertices(*args)
15455 
15456 def get_increasing_from_embedded(*args):
15457  """
15458  get_increasing_from_embedded(UnitSimplex1D a, Vector1D b) -> Vector1D
15459  get_increasing_from_embedded(UnitSimplex2D a, Vector2D b) -> Vector2D
15460  get_increasing_from_embedded(UnitSimplex3D a, Vector3D b) -> Vector3D
15461  get_increasing_from_embedded(UnitSimplex4D a, Vector4D b) -> Vector4D
15462  get_increasing_from_embedded(UnitSimplex5D a, Vector5D b) -> Vector5D
15463  get_increasing_from_embedded(UnitSimplex6D a, Vector6D b) -> Vector6D
15464  get_increasing_from_embedded(UnitSimplexKD a, VectorKD b) -> VectorKD
15465  """
15466  return _IMP_algebra.get_increasing_from_embedded(*args)
15467 
15468 def get_embedded_from_increasing(*args):
15469  """
15470  get_embedded_from_increasing(UnitSimplex1D a, Vector1D b) -> Vector1D
15471  get_embedded_from_increasing(UnitSimplex2D a, Vector2D b) -> Vector2D
15472  get_embedded_from_increasing(UnitSimplex3D a, Vector3D b) -> Vector3D
15473  get_embedded_from_increasing(UnitSimplex4D a, Vector4D b) -> Vector4D
15474  get_embedded_from_increasing(UnitSimplex5D a, Vector5D b) -> Vector5D
15475  get_embedded_from_increasing(UnitSimplex6D a, Vector6D b) -> Vector6D
15476  get_embedded_from_increasing(UnitSimplexKD a, VectorKD b) -> VectorKD
15477  """
15478  return _IMP_algebra.get_embedded_from_increasing(*args)
15479 class _AxisAnglePair(object):
15480  """Proxy of C++ std::pair<(IMP::algebra::VectorD<(3)>,double)> class"""
15481  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15482  __repr__ = _swig_repr
15483 
15484  def __init__(self, *args):
15485  """
15486  __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self) -> _AxisAnglePair
15487  __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self, Vector3D first, double second) -> _AxisAnglePair
15488  __init__(std::pair<(IMP::algebra::VectorD<(3)>,double)> self, _AxisAnglePair p) -> _AxisAnglePair
15489  """
15490  this = _IMP_algebra.new__AxisAnglePair(*args)
15491  try:
15492  self.this.append(this)
15493  except:
15494  self.this = this
15495  first = _swig_property(_IMP_algebra._AxisAnglePair_first_get, _IMP_algebra._AxisAnglePair_first_set)
15496  second = _swig_property(_IMP_algebra._AxisAnglePair_second_get, _IMP_algebra._AxisAnglePair_second_set)
15497  def __len__(self):
15498  return 2
15499  def __repr__(self):
15500  return str((self.first, self.second))
15501  def __getitem__(self, index):
15502  if not (index % 2):
15503  return self.first
15504  else:
15505  return self.second
15506  def __setitem__(self, index, val):
15507  if not (index % 2):
15508  self.first = val
15509  else:
15510  self.second = val
15511  __swig_destroy__ = _IMP_algebra.delete__AxisAnglePair
15512  __del__ = lambda self: None
15513 _AxisAnglePair_swigregister = _IMP_algebra._AxisAnglePair_swigregister
15514 _AxisAnglePair_swigregister(_AxisAnglePair)
15515 
15516 
15517 def get_transformation_aligning_first_to_second(source, target):
15518  """get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 > > const & source, IMP::Vector< IMP::algebra::VectorD< 3 > > const & target) -> Transformation3D"""
15519  return _IMP_algebra.get_transformation_aligning_first_to_second(source, target)
15520 class _RotatedVector3DAdjoint(object):
15521  """Proxy of C++ std::pair<(IMP::algebra::VectorD<(3)>,IMP::algebra::VectorD<(4)>)> class"""
15522  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15523  __repr__ = _swig_repr
15524 
15525  def __init__(self, *args):
15526  """
15527  __init__(std::pair<(IMP::algebra::VectorD<(3)>,IMP::algebra::VectorD<(4)>)> self) -> _RotatedVector3DAdjoint
15528  __init__(std::pair<(IMP::algebra::VectorD<(3)>,IMP::algebra::VectorD<(4)>)> self, Vector3D first, Vector4D second) -> _RotatedVector3DAdjoint
15529  __init__(std::pair<(IMP::algebra::VectorD<(3)>,IMP::algebra::VectorD<(4)>)> self, _RotatedVector3DAdjoint p) -> _RotatedVector3DAdjoint
15530  """
15531  this = _IMP_algebra.new__RotatedVector3DAdjoint(*args)
15532  try:
15533  self.this.append(this)
15534  except:
15535  self.this = this
15536  first = _swig_property(_IMP_algebra._RotatedVector3DAdjoint_first_get, _IMP_algebra._RotatedVector3DAdjoint_first_set)
15537  second = _swig_property(_IMP_algebra._RotatedVector3DAdjoint_second_get, _IMP_algebra._RotatedVector3DAdjoint_second_set)
15538  def __len__(self):
15539  return 2
15540  def __repr__(self):
15541  return str((self.first, self.second))
15542  def __getitem__(self, index):
15543  if not (index % 2):
15544  return self.first
15545  else:
15546  return self.second
15547  def __setitem__(self, index, val):
15548  if not (index % 2):
15549  self.first = val
15550  else:
15551  self.second = val
15552  __swig_destroy__ = _IMP_algebra.delete__RotatedVector3DAdjoint
15553  __del__ = lambda self: None
15554 _RotatedVector3DAdjoint_swigregister = _IMP_algebra._RotatedVector3DAdjoint_swigregister
15555 _RotatedVector3DAdjoint_swigregister(_RotatedVector3DAdjoint)
15556 
15557 class _ComposeRotation3DAdjoint(object):
15558  """Proxy of C++ std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(4)>)> class"""
15559  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15560  __repr__ = _swig_repr
15561 
15562  def __init__(self, *args):
15563  """
15564  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(4)>)> self) -> _ComposeRotation3DAdjoint
15565  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(4)>)> self, Vector4D first, Vector4D second) -> _ComposeRotation3DAdjoint
15566  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(4)>)> self, _ComposeRotation3DAdjoint p) -> _ComposeRotation3DAdjoint
15567  """
15568  this = _IMP_algebra.new__ComposeRotation3DAdjoint(*args)
15569  try:
15570  self.this.append(this)
15571  except:
15572  self.this = this
15573  first = _swig_property(_IMP_algebra._ComposeRotation3DAdjoint_first_get, _IMP_algebra._ComposeRotation3DAdjoint_first_set)
15574  second = _swig_property(_IMP_algebra._ComposeRotation3DAdjoint_second_get, _IMP_algebra._ComposeRotation3DAdjoint_second_set)
15575  def __len__(self):
15576  return 2
15577  def __repr__(self):
15578  return str((self.first, self.second))
15579  def __getitem__(self, index):
15580  if not (index % 2):
15581  return self.first
15582  else:
15583  return self.second
15584  def __setitem__(self, index, val):
15585  if not (index % 2):
15586  self.first = val
15587  else:
15588  self.second = val
15589  __swig_destroy__ = _IMP_algebra.delete__ComposeRotation3DAdjoint
15590  __del__ = lambda self: None
15591 _ComposeRotation3DAdjoint_swigregister = _IMP_algebra._ComposeRotation3DAdjoint_swigregister
15592 _ComposeRotation3DAdjoint_swigregister(_ComposeRotation3DAdjoint)
15593 
15594 class _Transformation3DAdjoint(object):
15595  """Proxy of C++ std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)> class"""
15596  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15597  __repr__ = _swig_repr
15598 
15599  def __init__(self, *args):
15600  """
15601  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)> self) -> _Transformation3DAdjoint
15602  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)> self, Vector4D first, Vector3D second) -> _Transformation3DAdjoint
15603  __init__(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)> self, _Transformation3DAdjoint p) -> _Transformation3DAdjoint
15604  """
15605  this = _IMP_algebra.new__Transformation3DAdjoint(*args)
15606  try:
15607  self.this.append(this)
15608  except:
15609  self.this = this
15610  first = _swig_property(_IMP_algebra._Transformation3DAdjoint_first_get, _IMP_algebra._Transformation3DAdjoint_first_set)
15611  second = _swig_property(_IMP_algebra._Transformation3DAdjoint_second_get, _IMP_algebra._Transformation3DAdjoint_second_set)
15612  def __len__(self):
15613  return 2
15614  def __repr__(self):
15615  return str((self.first, self.second))
15616  def __getitem__(self, index):
15617  if not (index % 2):
15618  return self.first
15619  else:
15620  return self.second
15621  def __setitem__(self, index, val):
15622  if not (index % 2):
15623  self.first = val
15624  else:
15625  self.second = val
15626  __swig_destroy__ = _IMP_algebra.delete__Transformation3DAdjoint
15627  __del__ = lambda self: None
15628 _Transformation3DAdjoint_swigregister = _IMP_algebra._Transformation3DAdjoint_swigregister
15629 _Transformation3DAdjoint_swigregister(_Transformation3DAdjoint)
15630 
15631 class _TransformedVector3DAdjoint(object):
15632  """Proxy of C++ std::pair<(IMP::algebra::VectorD<(3)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> class"""
15633  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15634  __repr__ = _swig_repr
15635 
15636  def __init__(self, *args):
15637  """
15638  __init__(std::pair<(IMP::algebra::VectorD<(3)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self) -> _TransformedVector3DAdjoint
15639  __init__(std::pair<(IMP::algebra::VectorD<(3)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self, Vector3D first, _Transformation3DAdjoint second) -> _TransformedVector3DAdjoint
15640  __init__(std::pair<(IMP::algebra::VectorD<(3)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self, _TransformedVector3DAdjoint p) -> _TransformedVector3DAdjoint
15641  """
15642  this = _IMP_algebra.new__TransformedVector3DAdjoint(*args)
15643  try:
15644  self.this.append(this)
15645  except:
15646  self.this = this
15647  first = _swig_property(_IMP_algebra._TransformedVector3DAdjoint_first_get, _IMP_algebra._TransformedVector3DAdjoint_first_set)
15648  second = _swig_property(_IMP_algebra._TransformedVector3DAdjoint_second_get, _IMP_algebra._TransformedVector3DAdjoint_second_set)
15649  def __len__(self):
15650  return 2
15651  def __repr__(self):
15652  return str((self.first, self.second))
15653  def __getitem__(self, index):
15654  if not (index % 2):
15655  return self.first
15656  else:
15657  return self.second
15658  def __setitem__(self, index, val):
15659  if not (index % 2):
15660  self.first = val
15661  else:
15662  self.second = val
15663  __swig_destroy__ = _IMP_algebra.delete__TransformedVector3DAdjoint
15664  __del__ = lambda self: None
15665 _TransformedVector3DAdjoint_swigregister = _IMP_algebra._TransformedVector3DAdjoint_swigregister
15666 _TransformedVector3DAdjoint_swigregister(_TransformedVector3DAdjoint)
15667 
15668 class _ComposeTransformation3DAdjoint(object):
15669  """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"""
15670  thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
15671  __repr__ = _swig_repr
15672 
15673  def __init__(self, *args):
15674  """
15675  __init__(std::pair<(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self) -> _ComposeTransformation3DAdjoint
15676  __init__(std::pair<(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self, _Transformation3DAdjoint first, _Transformation3DAdjoint second) -> _ComposeTransformation3DAdjoint
15677  __init__(std::pair<(std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>,std::pair<(IMP::algebra::VectorD<(4)>,IMP::algebra::VectorD<(3)>)>)> self, _ComposeTransformation3DAdjoint p) -> _ComposeTransformation3DAdjoint
15678  """
15679  this = _IMP_algebra.new__ComposeTransformation3DAdjoint(*args)
15680  try:
15681  self.this.append(this)
15682  except:
15683  self.this = this
15684  first = _swig_property(_IMP_algebra._ComposeTransformation3DAdjoint_first_get, _IMP_algebra._ComposeTransformation3DAdjoint_first_set)
15685  second = _swig_property(_IMP_algebra._ComposeTransformation3DAdjoint_second_get, _IMP_algebra._ComposeTransformation3DAdjoint_second_set)
15686  def __len__(self):
15687  return 2
15688  def __repr__(self):
15689  return str((self.first, self.second))
15690  def __getitem__(self, index):
15691  if not (index % 2):
15692  return self.first
15693  else:
15694  return self.second
15695  def __setitem__(self, index, val):
15696  if not (index % 2):
15697  self.first = val
15698  else:
15699  self.second = val
15700  __swig_destroy__ = _IMP_algebra.delete__ComposeTransformation3DAdjoint
15701  __del__ = lambda self: None
15702 _ComposeTransformation3DAdjoint_swigregister = _IMP_algebra._ComposeTransformation3DAdjoint_swigregister
15703 _ComposeTransformation3DAdjoint_swigregister(_ComposeTransformation3DAdjoint)
15704 
15705 
15706 def get_rmsd_transforming_first(tr, v0, v1):
15707  """get_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
15708  return _IMP_algebra.get_rmsd_transforming_first(tr, v0, v1)
15709 
15710 def get_rmsd(v0, v1):
15711  """get_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1) -> double"""
15712  return _IMP_algebra.get_rmsd(v0, v1)
15713 
15714 def get_weighted_rmsd_transforming_first(tr, v0, v1, weights):
15715  """get_weighted_rmsd_transforming_first(Transformation3D tr, IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
15716  return _IMP_algebra.get_weighted_rmsd_transforming_first(tr, v0, v1, weights)
15717 
15718 def get_weighted_rmsd(v0, v1, weights):
15719  """get_weighted_rmsd(IMP::algebra::Vector3Ds const & v0, IMP::algebra::Vector3Ds const & v1, IMP::Floats const & weights) -> double"""
15720  return _IMP_algebra.get_weighted_rmsd(v0, v1, weights)
15721 
15722 LinearFit=LinearFit2D
15723 ParabolicFit=ParabolicFit2D
15724 
15725 
15726 def get_module_version():
15727  """get_module_version() -> std::string const"""
15728  return _IMP_algebra.get_module_version()
15729 
15730 def get_example_path(fname):
15731  """get_example_path(std::string fname) -> std::string"""
15732  return _IMP_algebra.get_example_path(fname)
15733 
15734 def get_data_path(fname):
15735  """get_data_path(std::string fname) -> std::string"""
15736  return _IMP_algebra.get_data_path(fname)
15737 
15738 from . import _version_check
15739 _version_check.check_version(get_module_version())
15740 __version__ = get_module_version()
15741 
15742 
15743 
IMP::algebra::get_is_big_endian
bool get_is_big_endian()
Returns 1 if machine is big endian else 0.
IMP::algebra::BoundingBoxKD
BoundingBoxD<-1 > BoundingBoxKD
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::get_rotation_about_normalized_axis
Rotation3D get_rotation_about_normalized_axis(const Vector3D &axis_norm, double angle)
Definition: Rotation3D.h:413
IMP::core::get_height
double get_height(const Surface &s, const XYZR &d)
Get height of sphere above surface.
Definition: Surface.h:129
IMP::algebra::get_transformation_aligning_pair
Transformation2D get_transformation_aligning_pair(const Vector2Ds &set_from, const Vector2Ds &set_to)
IMP::algebra::DenseFloatGrid3D
Grid3D< float, DenseGridStorage3D< float > > DenseFloatGrid3D
Definition: algebra/python_only.h:94
IMP::algebra::Sphere4D
SphereD< 4 > Sphere4D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::Sphere3D
SphereD< 3 > Sphere3D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::get_random_vector_on
VectorD< D > get_random_vector_on(const BoundingBoxD< D > &bb)
Generate a random vector on a box with uniform density.
Definition: vector_generators.h:48
IMP::algebra::write_pts
void write_pts(const Vector3Ds &vs, TextOutput out)
Write a set of 3D vectors to a file.
IMP::algebra::SparseUnboundedIntGrid3D
Grid3D< int, SparseGridStorage3D< int, UnboundedGridStorage3D > > SparseUnboundedIntGrid3D
Definition: algebra/python_only.h:88
IMP::algebra::get_rotation_from_x_y_axes
Rotation3D get_rotation_from_x_y_axes(const Vector3D &x, const Vector3D &y)
IMP::algebra::Vector6D
VectorD< 6 > Vector6D
Definition: VectorD.h:433
IMP::algebra::BoundingBox3D
BoundingBoxD< 3 > BoundingBox3D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::get_rotation_from_fixed_xyz
Rotation3D get_rotation_from_fixed_xyz(double xr, double yr, double zr)
Initialize a rotation in x-y-z order from three angles.
IMP::algebra::Vector2D
VectorD< 2 > Vector2D
Definition: VectorD.h:417
IMP::algebra::compose_adjoint
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.
IMP::algebra::get_random_vector_on_unit_sphere
VectorD< 3 > get_random_vector_on_unit_sphere()
Definition: vector_generators.h:91
IMP::algebra::get_rasterized
DenseGrid3D< double > get_rasterized(const Gaussian3Ds &gmm, const Floats &weights, double cell_width, const BoundingBox3D &bb)
Rasterize the Gaussians to a grid.
IMP::algebra::get_random_chain
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.
IMP::algebra::get_zero_vector_kd
VectorD< D > get_zero_vector_kd(int Di)
Return a dynamically sized vector of zeros.
Definition: VectorD.h:276
IMP::algebra::compose
Rotation2D compose(const Rotation2D &a, const Rotation2D &b)
Compose two rotations a and b.
Definition: Rotation2D.h:126
IMP::algebra::get_enclosing_sphere
Sphere3D get_enclosing_sphere(const Sphere3Ds &ss)
Return a sphere containing the listed spheres.
IMP::algebra::Vector5D
VectorD< 5 > Vector5D
Definition: VectorD.h:429
IMP::algebra::get_uniform_surface_cover
Vector< VectorD< D > > get_uniform_surface_cover(const SphereD< D > &s, unsigned int n)
Generate a set of vectors which covers a sphere uniformly.
Definition: vector_generators.h:116
IMP::algebra::get_uniformly_sampled_rotations
algebra::Rotation3Ds get_uniformly_sampled_rotations(double delta)
Generates a nondegenerate set of Euler angles with a delta resolution.
IMP::algebra::get_vertices
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
IMP::algebra::get_is_little_endian
bool get_is_little_endian()
Returns 1 if machine is little endian else 0.
IMP::algebra::get_largest_triangle
Triangle3D get_largest_triangle(const Vector3Ds &points)
Return the largest triangle defined by 3 points from the input.
IMP::UsageException
An exception for an invalid usage of IMP.
Definition: exception.h:122
IMP::cgal
Make CGAL functionality available to IMP.
IMP::algebra::get_gaussian_from_covariance
Gaussian3D get_gaussian_from_covariance(const Eigen::Matrix3d &covariance, const Vector3D &center)
Return a Gaussian centered at the origin from a covariance matrix.
IMP::algebra::get_edges
IntPairs get_edges(const BoundingBoxD< 3 > &)
Return the edges of the box as indices into the vertices list.
Definition: BoundingBoxD.h:314
IMP::algebra::get_area
double get_area(const Geometry &)
Compute the area of any surface object.
IMP::algebra::BoundingBox5D
BoundingBoxD< 5 > BoundingBox5D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::Sphere2D
SphereD< 2 > Sphere2D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::get_union
BoundingBoxD< D > get_union(BoundingBoxD< D > a, const BoundingBoxD< D > &b)
Return the union bounding box.
Definition: BoundingBoxD.h:261
IMP::algebra::get_squared_distance
double get_squared_distance(const VectorD< D > &v1, const VectorD< D > &v2)
Compute the squared distance between two vectors.
Definition: VectorD.h:201
IMP::algebra::get_unit_vector
VT get_unit_vector(VT vt)
Returns a unit vector pointing at the same direction as this vector.
Definition: VectorBaseD.h:247
IMP::algebra::get_transformation_from_first_triangle_to_second
Transformation3D get_transformation_from_first_triangle_to_second(Triangle3D first_tri, Triangle3D second_tri)
Return a transformation between two triangles.
IMP::algebra::get_ball_radius_from_volume_3d
double get_ball_radius_from_volume_3d(double volume)
Return the radius of a sphere with a given volume.
Definition: Sphere3D.h:35
IMP::algebra::get_weighted_rmsd
double get_weighted_rmsd(const Vector3DsOrXYZs0 &m1, const Vector3DsOrXYZs1 &m2, const Floats &weights)
Definition: algebra/distance.h:83
IMP::algebra::get_reflected
Vector3D get_reflected(const Plane3D &pln, const Vector3D &p)
Return the point reflected about the plane.
Definition: Plane3D.h:76
IMP::get_data_path
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
IMP::algebra::DenseDoubleGrid3D
Grid3D< double, DenseGridStorage3D< double > > DenseDoubleGrid3D
Definition: algebra/python_only.h:91
IMP::atom::get_atom
Atom get_atom(Residue rd, AtomType at)
Return a particle atom from the residue.
IMP::algebra::get_jacobian_of_composed_wrt_first
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.
IMP::algebra::get_basis_vector_kd
VectorD< D > get_basis_vector_kd(int Di, unsigned int coordinate)
Return the basis vector for the given coordinate.
Definition: VectorD.h:236
IMP::algebra::get_angle
double get_angle(const Line3D &a, const Line3D &b)
Get angle in radians between two lines around their closest points.
IMP::algebra::Vector4D
VectorD< 4 > Vector4D
Definition: VectorD.h:425
IMP::algebra::get_ones_vector_kd
VectorD< D > get_ones_vector_kd(unsigned int Di, double v=1)
Return a vector of ones (or another constant)
Definition: VectorD.h:309
IMP::algebra::BoundingBox2D
BoundingBoxD< 2 > BoundingBox2D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::get_rotation_about_axis
Rotation3D get_rotation_about_axis(const Vector3D &axis, double angle)
Generate a Rotation3D object from a rotation around an axis.
Definition: Rotation3D.h:439
IMP::algebra::get_shortest_segment
Segment3D get_shortest_segment(const Segment3D &s, const Vector3D &p)
IMP::algebra::read_pts
Vector3Ds read_pts(TextInput input)
Read a set of 3D vectors from a file.
IMP::algebra::get_intersection
BoundingBoxD< D > get_intersection(const BoundingBoxD< D > &a, const BoundingBoxD< D > &b)
Return the intersecting bounding box.
Definition: BoundingBoxD.h:230
IMP::algebra::get_transformation_aligning_first_to_second
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.
Definition: geometric_alignment.h:45
IMP::algebra::get_rotation_about_point
Transformation2D get_rotation_about_point(const Vector2D &point, const Rotation2D &rotation)
Generate a Transformation2D object from a rotation around a point.
Definition: Transformation2D.h:143
IMP::algebra::get_volume
double get_volume(const BoundingBoxD< D > &bb)
See BoundingBoxD.
Definition: BoundingBoxD.h:170
IMP::algebra::get_random_rotation_3d
Rotation3D get_random_rotation_3d()
Pick a rotation at random from all possible rotations.
IMP::algebra::get_vector_product
Vector3D get_vector_product(const Vector3D &p1, const Vector3D &p2)
Return the vector product (cross product) of two vectors.
Definition: Vector3D.h:31
IMP::algebra::get_interiors_intersect
bool get_interiors_intersect(const BoundingBoxD< D > &a, const BoundingBoxD< D > &b)
Return true if they intersect.
Definition: BoundingBoxD.h:216
IMP::algebra::get_increasing_from_embedded
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
IMP::domino::get_index
Ints get_index(const ParticlesTemp &particles, const Subset &subset, const Subsets &excluded)
IMP::Object
Common base class for heavy weight IMP objects.
Definition: Object.h:106
IMP::algebra::get_embedded_from_increasing
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
IMP::algebra::get_fixed_xyz_from_rotation
FixedXYZ get_fixed_xyz_from_rotation(const Rotation3D &r)
The inverse of rotation_from_fixed_xyz()
IMP::algebra::get_are_colinear
bool get_are_colinear(const Vector3D &p1, const Vector3D &p2, const Vector3D &p3)
Return true if the three points are co-linear.
IMP::algebra::BoundingBox4D
BoundingBoxD< 4 > BoundingBox4D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::get_identity_rotation_2d
Rotation2D get_identity_rotation_2d()
Build an identity rotation in 2D.
Definition: Rotation2D.h:108
IMP::algebra::read_spheres
Sphere3Ds read_spheres(TextInput input)
Read a set of 3D spheres from a file.
IMP::algebra::get_projected
Vector3D get_projected(const Line3D &l, const Vector3D &p)
Project a point onto the line.
IMP::algebra::get_rotation_from_fixed_zyz
Rotation3D get_rotation_from_fixed_zyz(double Rot, double Tilt, double Psi)
Generate a rotation object from Euler Angles.
IMP::algebra::Sphere6D
SphereD< 6 > Sphere6D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::get_rmsd
double get_rmsd(const Vector3DsOrXYZs0 &m1, const Vector3DsOrXYZs1 &m2)
Definition: algebra/distance.h:47
IMP::algebra::get_random_vector_in
VectorD< D > get_random_vector_in(const BoundingBoxD< D > &bb)
Generate a random vector in a box with uniform density.
Definition: vector_generators.h:39
IMP::algebra::Sphere5D
SphereD< 5 > Sphere5D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::get_unit_bounding_box_kd
BoundingBoxD<-1 > get_unit_bounding_box_kd(unsigned int d)
Box with radius one.
Definition: BoundingBoxD.h:194
IMP::VersionInfo
Version and module information for Objects.
Definition: VersionInfo.h:29
IMP::algebra::get_radius_of_gyration
double get_radius_of_gyration(const Vector3Ds &ps)
Return the radius of gyration of a set of points.
Definition: Vector3D.h:77
IMP::algebra::get_axis_and_angle
std::pair< Vector3D, double > get_axis_and_angle(const Rotation3D &rot)
Decompose a Rotation3D object into a rotation around an axis.
IMP::algebra::Vector1D
VectorD< 1 > Vector1D
Definition: VectorD.h:413
IMP::algebra::get_surface_area_and_volume
FloatPair get_surface_area_and_volume(const algebra::Sphere3Ds &ss)
Get surface area & volume of the union of the balls bounded by the spheres.
IMP::algebra::get_alignments_from_first_to_second
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.
IMP::algebra::Sphere1D
SphereD< 1 > Sphere1D
Typedef for Python.
Definition: SphereD.h:104
IMP::algebra::get_interpolated
Rotation3D get_interpolated(const Rotation3D &a, const Rotation3D &b, double f)
Interpolate between two rotations.
Definition: Rotation3D.h:633
IMP::algebra::get_rotation_from_vector4d
Rotation3D get_rotation_from_vector4d(const VectorD< 4 > &v)
Compute a rotation from an unnormalized quaternion.
Definition: Rotation3D.h:506
IMP::algebra::get_cube_kd
BoundingBoxD<-1 > get_cube_kd(unsigned int d, double radius)
Cube with radius of length side.
Definition: BoundingBoxD.h:208
IMP::algebra::get_rotation_taking_first_to_second
Rotation3D get_rotation_taking_first_to_second(const Vector3D &v1, const Vector3D &v2)
Create a rotation from the first vector to the second one.
IMP::algebra::get_uniform_cover_rotations_3d
Rotation3Ds get_uniform_cover_rotations_3d(unsigned int num_points)
Cover the space of rotations evenly.
IMP::algebra::get_principal_components
PrincipalComponentAnalysisD< D > get_principal_components(const Vector< VectorD< D > > &ps)
Perform principal components analysis on a set of vectors.
Definition: eigen_analysis.h:115
IMP::algebra::get_rotation_to_x_axis
Rotation2D get_rotation_to_x_axis(const Vector2D &v)
Definition: Rotation2D.h:118
IMP::algebra::get_centroid
Vector3D get_centroid(const Vector3Ds &ps)
Return the centroid of a set of vectors.
Definition: Vector3D.h:68
IMP::core::show
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
Definition: core/Hierarchy.h:411
IMP::algebra::get_identity_transformation_3d
Transformation3D get_identity_transformation_3d()
Return a transformation that does not do anything.
Definition: Transformation3D.h:134
IMP::algebra::get_jacobian_of_composed_wrt_second
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.
IMP::algebra::reversed_read
void reversed_read(void *dest, size_t size, size_t nitems, std::ifstream &f, bool reverse)
Reads from file in normal or reverse order.
IMP::algebra::get_rotation_from_matrix
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.
IMP::algebra::get_transformation_3d
Transformation3D get_transformation_3d(const Transformation2D &t2d)
Build a 3D transformation from a 2D one.
IMP::algebra::get_relative_projection_on_segment
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.
IMP::get_example_path
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
IMP::algebra::get_covariance
Eigen::Matrix3d get_covariance(const Gaussian3D &g)
IMP::algebra::Vector3D
VectorD< 3 > Vector3D
Definition: VectorD.h:421
IMP::algebra::get_identity_rotation_3d
Rotation3D get_identity_rotation_3d()
Return a rotation that does not do anything.
Definition: Rotation3D.h:374
IMP::algebra::write_spheres
void write_spheres(const Sphere3Ds &vs, TextOutput out)
Write a set of 3D spheres to a file.
IMP::algebra::get_simplified_from_volume
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.
IMP::algebra::reversed_write
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.
IMP::algebra::get_segment_connecting_first_to_second
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.
IMP::algebra::get_grid_interior_cover_by_spacing
Vector< VectorD< D > > get_grid_interior_cover_by_spacing(const BoundingBoxD< D > &bb, double s)
Definition: vector_generators.h:179
IMP::algebra::get_rasterized_fast
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.
IMP::algebra::get_orthogonal_vector
Vector3D get_orthogonal_vector(const Vector3D &v)
Return a vector that is perpendicular to the given vector.
Definition: Vector3D.h:51
IMP::algebra::get_surface_area
double get_surface_area(const Geometry &)
Compute the surface area of any volumetric object.
IMP::algebra::get_rmsd_transforming_first
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.
Definition: algebra/distance.h:27
IMP::algebra::VectorKD
VectorD<-1 > VectorKD
Definition: VectorD.h:437
IMP::algebra::BoundingBox6D
BoundingBoxD< 6 > BoundingBox6D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::SphereKD
SphereD<-1 > SphereKD
Typedef for Python.
Definition: SphereD.h:104
IMP::get_indexes
ParticleIndexes get_indexes(const ParticlesTemp &ps)
Get the indexes from a list of particles.
IMP::em::get_segment
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.
IMP::algebra::get_grid_surface_cover
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.
IMP::algebra::get_rotation_from_fixed_zxz
Rotation3D get_rotation_from_fixed_zxz(double phi, double theta, double psi)
Initialize a rotation from Euler angles.
IMP::algebra::BoundingBox1D
BoundingBoxD< 1 > BoundingBox1D
Typedef for Python.
Definition: BoundingBoxD.h:183
IMP::algebra::get_distance
double get_distance(const Line3D &s, const Vector3D &p)
Get closest distance between a line and a point.
IMP::algebra::get_random_local_transformation
Transformation3D get_random_local_transformation(Vector3D origin, double max_translation=5., double max_angle_in_rad=0.26)
Get a local transformation.
IMP::algebra::get_identity_transformation_2d
Transformation2D get_identity_transformation_2d()
Return a transformation that does not do anything.
Definition: Transformation2D.h:131
IMP::get_module_version
std::string get_module_version()
Return the version of this module, as a string.
Definition: EMageFit/__init__.py:5
IMP::algebra::get_connolly_surface
ConnollySurfacePoints get_connolly_surface(const algebra::Sphere3Ds &spheres, double density, double probe_radius)
IMP::algebra::get_random_rotation_2d
Rotation2D get_random_rotation_2d()
Build an identity rotation in 2D.
Definition: Rotation2D.h:111