# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.6
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_clipper', [dirname(__file__)])
        except ImportError:
            import _clipper
            return _clipper
        if fp is not None:
            try:
                _mod = imp.load_module('_clipper', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _clipper = swig_import_helper()
    del swig_import_helper
else:
    import _clipper
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _clipper.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _clipper.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _clipper.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _clipper.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _clipper.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _clipper.SwigPyIterator_equal(self, x)

    def copy(self):
        return _clipper.SwigPyIterator_copy(self)

    def next(self):
        return _clipper.SwigPyIterator_next(self)

    def __next__(self):
        return _clipper.SwigPyIterator___next__(self)

    def previous(self):
        return _clipper.SwigPyIterator_previous(self)

    def advance(self, n):
        return _clipper.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _clipper.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _clipper.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _clipper.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _clipper.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _clipper.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _clipper.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _clipper.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class FloatVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.FloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.FloatVector___nonzero__(self)

    def __bool__(self):
        return _clipper.FloatVector___bool__(self)

    def __len__(self):
        return _clipper.FloatVector___len__(self)

    def pop(self):
        return _clipper.FloatVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.FloatVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.FloatVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.FloatVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.FloatVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.FloatVector_append(self, x)

    def empty(self):
        return _clipper.FloatVector_empty(self)

    def size(self):
        return _clipper.FloatVector_size(self)

    def clear(self):
        return _clipper.FloatVector_clear(self)

    def swap(self, v):
        return _clipper.FloatVector_swap(self, v)

    def get_allocator(self):
        return _clipper.FloatVector_get_allocator(self)

    def begin(self):
        return _clipper.FloatVector_begin(self)

    def end(self):
        return _clipper.FloatVector_end(self)

    def rbegin(self):
        return _clipper.FloatVector_rbegin(self)

    def rend(self):
        return _clipper.FloatVector_rend(self)

    def pop_back(self):
        return _clipper.FloatVector_pop_back(self)

    def erase(self, *args):
        return _clipper.FloatVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_FloatVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.FloatVector_push_back(self, x)

    def front(self):
        return _clipper.FloatVector_front(self)

    def back(self):
        return _clipper.FloatVector_back(self)

    def assign(self, n, x):
        return _clipper.FloatVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.FloatVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.FloatVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.FloatVector_reserve(self, n)

    def capacity(self):
        return _clipper.FloatVector_capacity(self)
    __swig_destroy__ = _clipper.delete_FloatVector
    __del__ = lambda self: None
FloatVector_swigregister = _clipper.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _clipper.DoubleVector___bool__(self)

    def __len__(self):
        return _clipper.DoubleVector___len__(self)

    def pop(self):
        return _clipper.DoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.DoubleVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.DoubleVector_append(self, x)

    def empty(self):
        return _clipper.DoubleVector_empty(self)

    def size(self):
        return _clipper.DoubleVector_size(self)

    def clear(self):
        return _clipper.DoubleVector_clear(self)

    def swap(self, v):
        return _clipper.DoubleVector_swap(self, v)

    def get_allocator(self):
        return _clipper.DoubleVector_get_allocator(self)

    def begin(self):
        return _clipper.DoubleVector_begin(self)

    def end(self):
        return _clipper.DoubleVector_end(self)

    def rbegin(self):
        return _clipper.DoubleVector_rbegin(self)

    def rend(self):
        return _clipper.DoubleVector_rend(self)

    def pop_back(self):
        return _clipper.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _clipper.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.DoubleVector_push_back(self, x)

    def front(self):
        return _clipper.DoubleVector_front(self)

    def back(self):
        return _clipper.DoubleVector_back(self)

    def assign(self, n, x):
        return _clipper.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.DoubleVector_reserve(self, n)

    def capacity(self):
        return _clipper.DoubleVector_capacity(self)
    __swig_destroy__ = _clipper.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _clipper.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class FloatFloatVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatFloatVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.FloatFloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.FloatFloatVector___nonzero__(self)

    def __bool__(self):
        return _clipper.FloatFloatVector___bool__(self)

    def __len__(self):
        return _clipper.FloatFloatVector___len__(self)

    def pop(self):
        return _clipper.FloatFloatVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.FloatFloatVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.FloatFloatVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.FloatFloatVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.FloatFloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.FloatFloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.FloatFloatVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.FloatFloatVector_append(self, x)

    def empty(self):
        return _clipper.FloatFloatVector_empty(self)

    def size(self):
        return _clipper.FloatFloatVector_size(self)

    def clear(self):
        return _clipper.FloatFloatVector_clear(self)

    def swap(self, v):
        return _clipper.FloatFloatVector_swap(self, v)

    def get_allocator(self):
        return _clipper.FloatFloatVector_get_allocator(self)

    def begin(self):
        return _clipper.FloatFloatVector_begin(self)

    def end(self):
        return _clipper.FloatFloatVector_end(self)

    def rbegin(self):
        return _clipper.FloatFloatVector_rbegin(self)

    def rend(self):
        return _clipper.FloatFloatVector_rend(self)

    def pop_back(self):
        return _clipper.FloatFloatVector_pop_back(self)

    def erase(self, *args):
        return _clipper.FloatFloatVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_FloatFloatVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.FloatFloatVector_push_back(self, x)

    def front(self):
        return _clipper.FloatFloatVector_front(self)

    def back(self):
        return _clipper.FloatFloatVector_back(self)

    def assign(self, n, x):
        return _clipper.FloatFloatVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.FloatFloatVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.FloatFloatVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.FloatFloatVector_reserve(self, n)

    def capacity(self):
        return _clipper.FloatFloatVector_capacity(self)
    __swig_destroy__ = _clipper.delete_FloatFloatVector
    __del__ = lambda self: None
FloatFloatVector_swigregister = _clipper.FloatFloatVector_swigregister
FloatFloatVector_swigregister(FloatFloatVector)

class DoubleDoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.DoubleDoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.DoubleDoubleVector___nonzero__(self)

    def __bool__(self):
        return _clipper.DoubleDoubleVector___bool__(self)

    def __len__(self):
        return _clipper.DoubleDoubleVector___len__(self)

    def pop(self):
        return _clipper.DoubleDoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.DoubleDoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.DoubleDoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.DoubleDoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.DoubleDoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.DoubleDoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.DoubleDoubleVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.DoubleDoubleVector_append(self, x)

    def empty(self):
        return _clipper.DoubleDoubleVector_empty(self)

    def size(self):
        return _clipper.DoubleDoubleVector_size(self)

    def clear(self):
        return _clipper.DoubleDoubleVector_clear(self)

    def swap(self, v):
        return _clipper.DoubleDoubleVector_swap(self, v)

    def get_allocator(self):
        return _clipper.DoubleDoubleVector_get_allocator(self)

    def begin(self):
        return _clipper.DoubleDoubleVector_begin(self)

    def end(self):
        return _clipper.DoubleDoubleVector_end(self)

    def rbegin(self):
        return _clipper.DoubleDoubleVector_rbegin(self)

    def rend(self):
        return _clipper.DoubleDoubleVector_rend(self)

    def pop_back(self):
        return _clipper.DoubleDoubleVector_pop_back(self)

    def erase(self, *args):
        return _clipper.DoubleDoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_DoubleDoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.DoubleDoubleVector_push_back(self, x)

    def front(self):
        return _clipper.DoubleDoubleVector_front(self)

    def back(self):
        return _clipper.DoubleDoubleVector_back(self)

    def assign(self, n, x):
        return _clipper.DoubleDoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.DoubleDoubleVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.DoubleDoubleVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.DoubleDoubleVector_reserve(self, n)

    def capacity(self):
        return _clipper.DoubleDoubleVector_capacity(self)
    __swig_destroy__ = _clipper.delete_DoubleDoubleVector
    __del__ = lambda self: None
DoubleDoubleVector_swigregister = _clipper.DoubleDoubleVector_swigregister
DoubleDoubleVector_swigregister(DoubleDoubleVector)


def ClipperStringAsString(a):
    return _clipper.ClipperStringAsString(a)
ClipperStringAsString = _clipper.ClipperStringAsString
class UnsignedIntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnsignedIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UnsignedIntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.UnsignedIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.UnsignedIntVector___nonzero__(self)

    def __bool__(self):
        return _clipper.UnsignedIntVector___bool__(self)

    def __len__(self):
        return _clipper.UnsignedIntVector___len__(self)

    def pop(self):
        return _clipper.UnsignedIntVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.UnsignedIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.UnsignedIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.UnsignedIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.UnsignedIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.UnsignedIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.UnsignedIntVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.UnsignedIntVector_append(self, x)

    def empty(self):
        return _clipper.UnsignedIntVector_empty(self)

    def size(self):
        return _clipper.UnsignedIntVector_size(self)

    def clear(self):
        return _clipper.UnsignedIntVector_clear(self)

    def swap(self, v):
        return _clipper.UnsignedIntVector_swap(self, v)

    def get_allocator(self):
        return _clipper.UnsignedIntVector_get_allocator(self)

    def begin(self):
        return _clipper.UnsignedIntVector_begin(self)

    def end(self):
        return _clipper.UnsignedIntVector_end(self)

    def rbegin(self):
        return _clipper.UnsignedIntVector_rbegin(self)

    def rend(self):
        return _clipper.UnsignedIntVector_rend(self)

    def pop_back(self):
        return _clipper.UnsignedIntVector_pop_back(self)

    def erase(self, *args):
        return _clipper.UnsignedIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_UnsignedIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.UnsignedIntVector_push_back(self, x)

    def front(self):
        return _clipper.UnsignedIntVector_front(self)

    def back(self):
        return _clipper.UnsignedIntVector_back(self)

    def assign(self, n, x):
        return _clipper.UnsignedIntVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.UnsignedIntVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.UnsignedIntVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.UnsignedIntVector_reserve(self, n)

    def capacity(self):
        return _clipper.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _clipper.delete_UnsignedIntVector
    __del__ = lambda self: None
UnsignedIntVector_swigregister = _clipper.UnsignedIntVector_swigregister
UnsignedIntVector_swigregister(UnsignedIntVector)

class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.IntVector___nonzero__(self)

    def __bool__(self):
        return _clipper.IntVector___bool__(self)

    def __len__(self):
        return _clipper.IntVector___len__(self)

    def pop(self):
        return _clipper.IntVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.IntVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.IntVector_append(self, x)

    def empty(self):
        return _clipper.IntVector_empty(self)

    def size(self):
        return _clipper.IntVector_size(self)

    def clear(self):
        return _clipper.IntVector_clear(self)

    def swap(self, v):
        return _clipper.IntVector_swap(self, v)

    def get_allocator(self):
        return _clipper.IntVector_get_allocator(self)

    def begin(self):
        return _clipper.IntVector_begin(self)

    def end(self):
        return _clipper.IntVector_end(self)

    def rbegin(self):
        return _clipper.IntVector_rbegin(self)

    def rend(self):
        return _clipper.IntVector_rend(self)

    def pop_back(self):
        return _clipper.IntVector_pop_back(self)

    def erase(self, *args):
        return _clipper.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_IntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.IntVector_push_back(self, x)

    def front(self):
        return _clipper.IntVector_front(self)

    def back(self):
        return _clipper.IntVector_back(self)

    def assign(self, n, x):
        return _clipper.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.IntVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.IntVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.IntVector_reserve(self, n)

    def capacity(self):
        return _clipper.IntVector_capacity(self)
    __swig_destroy__ = _clipper.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _clipper.IntVector_swigregister
IntVector_swigregister(IntVector)

class IntIntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntIntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.IntIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.IntIntVector___nonzero__(self)

    def __bool__(self):
        return _clipper.IntIntVector___bool__(self)

    def __len__(self):
        return _clipper.IntIntVector___len__(self)

    def pop(self):
        return _clipper.IntIntVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.IntIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.IntIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.IntIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.IntIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.IntIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.IntIntVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.IntIntVector_append(self, x)

    def empty(self):
        return _clipper.IntIntVector_empty(self)

    def size(self):
        return _clipper.IntIntVector_size(self)

    def clear(self):
        return _clipper.IntIntVector_clear(self)

    def swap(self, v):
        return _clipper.IntIntVector_swap(self, v)

    def get_allocator(self):
        return _clipper.IntIntVector_get_allocator(self)

    def begin(self):
        return _clipper.IntIntVector_begin(self)

    def end(self):
        return _clipper.IntIntVector_end(self)

    def rbegin(self):
        return _clipper.IntIntVector_rbegin(self)

    def rend(self):
        return _clipper.IntIntVector_rend(self)

    def pop_back(self):
        return _clipper.IntIntVector_pop_back(self)

    def erase(self, *args):
        return _clipper.IntIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_IntIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.IntIntVector_push_back(self, x)

    def front(self):
        return _clipper.IntIntVector_front(self)

    def back(self):
        return _clipper.IntIntVector_back(self)

    def assign(self, n, x):
        return _clipper.IntIntVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.IntIntVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.IntIntVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.IntIntVector_reserve(self, n)

    def capacity(self):
        return _clipper.IntIntVector_capacity(self)
    __swig_destroy__ = _clipper.delete_IntIntVector
    __del__ = lambda self: None
IntIntVector_swigregister = _clipper.IntIntVector_swigregister
IntIntVector_swigregister(IntIntVector)

class ClipperStringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClipperStringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClipperStringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.ClipperStringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.ClipperStringVector___nonzero__(self)

    def __bool__(self):
        return _clipper.ClipperStringVector___bool__(self)

    def __len__(self):
        return _clipper.ClipperStringVector___len__(self)

    def pop(self):
        return _clipper.ClipperStringVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.ClipperStringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.ClipperStringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.ClipperStringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.ClipperStringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.ClipperStringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.ClipperStringVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.ClipperStringVector_append(self, x)

    def empty(self):
        return _clipper.ClipperStringVector_empty(self)

    def size(self):
        return _clipper.ClipperStringVector_size(self)

    def clear(self):
        return _clipper.ClipperStringVector_clear(self)

    def swap(self, v):
        return _clipper.ClipperStringVector_swap(self, v)

    def get_allocator(self):
        return _clipper.ClipperStringVector_get_allocator(self)

    def begin(self):
        return _clipper.ClipperStringVector_begin(self)

    def end(self):
        return _clipper.ClipperStringVector_end(self)

    def rbegin(self):
        return _clipper.ClipperStringVector_rbegin(self)

    def rend(self):
        return _clipper.ClipperStringVector_rend(self)

    def pop_back(self):
        return _clipper.ClipperStringVector_pop_back(self)

    def erase(self, *args):
        return _clipper.ClipperStringVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_ClipperStringVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.ClipperStringVector_push_back(self, x)

    def front(self):
        return _clipper.ClipperStringVector_front(self)

    def back(self):
        return _clipper.ClipperStringVector_back(self)

    def assign(self, n, x):
        return _clipper.ClipperStringVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.ClipperStringVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.ClipperStringVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.ClipperStringVector_reserve(self, n)

    def capacity(self):
        return _clipper.ClipperStringVector_capacity(self)
    __swig_destroy__ = _clipper.delete_ClipperStringVector
    __del__ = lambda self: None
ClipperStringVector_swigregister = _clipper.ClipperStringVector_swigregister
ClipperStringVector_swigregister(ClipperStringVector)

class HKLVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKLVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKLVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.HKLVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.HKLVector___nonzero__(self)

    def __bool__(self):
        return _clipper.HKLVector___bool__(self)

    def __len__(self):
        return _clipper.HKLVector___len__(self)

    def pop(self):
        return _clipper.HKLVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.HKLVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.HKLVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.HKLVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.HKLVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.HKLVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.HKLVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.HKLVector_append(self, x)

    def empty(self):
        return _clipper.HKLVector_empty(self)

    def size(self):
        return _clipper.HKLVector_size(self)

    def clear(self):
        return _clipper.HKLVector_clear(self)

    def swap(self, v):
        return _clipper.HKLVector_swap(self, v)

    def get_allocator(self):
        return _clipper.HKLVector_get_allocator(self)

    def begin(self):
        return _clipper.HKLVector_begin(self)

    def end(self):
        return _clipper.HKLVector_end(self)

    def rbegin(self):
        return _clipper.HKLVector_rbegin(self)

    def rend(self):
        return _clipper.HKLVector_rend(self)

    def pop_back(self):
        return _clipper.HKLVector_pop_back(self)

    def erase(self, *args):
        return _clipper.HKLVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_HKLVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.HKLVector_push_back(self, x)

    def front(self):
        return _clipper.HKLVector_front(self)

    def back(self):
        return _clipper.HKLVector_back(self)

    def assign(self, n, x):
        return _clipper.HKLVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.HKLVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.HKLVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.HKLVector_reserve(self, n)

    def capacity(self):
        return _clipper.HKLVector_capacity(self)
    __swig_destroy__ = _clipper.delete_HKLVector
    __del__ = lambda self: None
HKLVector_swigregister = _clipper.HKLVector_swigregister
HKLVector_swigregister(HKLVector)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _clipper.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _clipper.StringVector___nonzero__(self)

    def __bool__(self):
        return _clipper.StringVector___bool__(self)

    def __len__(self):
        return _clipper.StringVector___len__(self)

    def pop(self):
        return _clipper.StringVector_pop(self)

    def __getslice__(self, i, j):
        return _clipper.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _clipper.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _clipper.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _clipper.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _clipper.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _clipper.StringVector___setitem__(self, *args)

    def append(self, x):
        return _clipper.StringVector_append(self, x)

    def empty(self):
        return _clipper.StringVector_empty(self)

    def size(self):
        return _clipper.StringVector_size(self)

    def clear(self):
        return _clipper.StringVector_clear(self)

    def swap(self, v):
        return _clipper.StringVector_swap(self, v)

    def get_allocator(self):
        return _clipper.StringVector_get_allocator(self)

    def begin(self):
        return _clipper.StringVector_begin(self)

    def end(self):
        return _clipper.StringVector_end(self)

    def rbegin(self):
        return _clipper.StringVector_rbegin(self)

    def rend(self):
        return _clipper.StringVector_rend(self)

    def pop_back(self):
        return _clipper.StringVector_pop_back(self)

    def erase(self, *args):
        return _clipper.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _clipper.new_StringVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _clipper.StringVector_push_back(self, x)

    def front(self):
        return _clipper.StringVector_front(self)

    def back(self):
        return _clipper.StringVector_back(self)

    def assign(self, n, x):
        return _clipper.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _clipper.StringVector_resize(self, *args)

    def insert(self, *args):
        return _clipper.StringVector_insert(self, *args)

    def reserve(self, n):
        return _clipper.StringVector_reserve(self, n)

    def capacity(self):
        return _clipper.StringVector_capacity(self)
    __swig_destroy__ = _clipper.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _clipper.StringVector_swigregister
StringVector_swigregister(StringVector)

class Util(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Util, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Util, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_Util()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_getmethods__["nan"] = lambda x: _clipper.Util_nan
    if _newclass:
        nan = staticmethod(_clipper.Util_nan)
    __swig_getmethods__["nanf"] = lambda x: _clipper.Util_nanf
    if _newclass:
        nanf = staticmethod(_clipper.Util_nanf)
    __swig_getmethods__["nand"] = lambda x: _clipper.Util_nand
    if _newclass:
        nand = staticmethod(_clipper.Util_nand)
    __swig_getmethods__["set_null"] = lambda x: _clipper.Util_set_null
    if _newclass:
        set_null = staticmethod(_clipper.Util_set_null)
    __swig_getmethods__["is_null"] = lambda x: _clipper.Util_is_null
    if _newclass:
        is_null = staticmethod(_clipper.Util_is_null)
    __swig_getmethods__["is_nan"] = lambda x: _clipper.Util_is_nan
    if _newclass:
        is_nan = staticmethod(_clipper.Util_is_nan)
    __swig_getmethods__["isnan"] = lambda x: _clipper.Util_isnan
    if _newclass:
        isnan = staticmethod(_clipper.Util_isnan)
    __swig_getmethods__["sim"] = lambda x: _clipper.Util_sim
    if _newclass:
        sim = staticmethod(_clipper.Util_sim)
    __swig_getmethods__["invsim"] = lambda x: _clipper.Util_invsim
    if _newclass:
        invsim = staticmethod(_clipper.Util_invsim)
    __swig_getmethods__["sim_integ"] = lambda x: _clipper.Util_sim_integ
    if _newclass:
        sim_integ = staticmethod(_clipper.Util_sim_integ)
    __swig_getmethods__["sim_deriv"] = lambda x: _clipper.Util_sim_deriv
    if _newclass:
        sim_deriv = staticmethod(_clipper.Util_sim_deriv)
    __swig_getmethods__["sim_deriv_recur"] = lambda x: _clipper.Util_sim_deriv_recur
    if _newclass:
        sim_deriv_recur = staticmethod(_clipper.Util_sim_deriv_recur)
    __swig_getmethods__["atanh"] = lambda x: _clipper.Util_atanh
    if _newclass:
        atanh = staticmethod(_clipper.Util_atanh)
    __swig_getmethods__["bessel_i0"] = lambda x: _clipper.Util_bessel_i0
    if _newclass:
        bessel_i0 = staticmethod(_clipper.Util_bessel_i0)
    __swig_getmethods__["u2b"] = lambda x: _clipper.Util_u2b
    if _newclass:
        u2b = staticmethod(_clipper.Util_u2b)
    __swig_getmethods__["b2u"] = lambda x: _clipper.Util_b2u
    if _newclass:
        b2u = staticmethod(_clipper.Util_b2u)
    __swig_getmethods__["intf"] = lambda x: _clipper.Util_intf
    if _newclass:
        intf = staticmethod(_clipper.Util_intf)
    __swig_getmethods__["intc"] = lambda x: _clipper.Util_intc
    if _newclass:
        intc = staticmethod(_clipper.Util_intc)
    __swig_getmethods__["intr"] = lambda x: _clipper.Util_intr
    if _newclass:
        intr = staticmethod(_clipper.Util_intr)
    __swig_getmethods__["mod"] = lambda x: _clipper.Util_mod
    if _newclass:
        mod = staticmethod(_clipper.Util_mod)
    __swig_getmethods__["pi"] = lambda x: _clipper.Util_pi
    if _newclass:
        pi = staticmethod(_clipper.Util_pi)
    __swig_getmethods__["twopi"] = lambda x: _clipper.Util_twopi
    if _newclass:
        twopi = staticmethod(_clipper.Util_twopi)
    __swig_getmethods__["twopi2"] = lambda x: _clipper.Util_twopi2
    if _newclass:
        twopi2 = staticmethod(_clipper.Util_twopi2)
    __swig_getmethods__["eightpi2"] = lambda x: _clipper.Util_eightpi2
    if _newclass:
        eightpi2 = staticmethod(_clipper.Util_eightpi2)
    __swig_getmethods__["d2rad"] = lambda x: _clipper.Util_d2rad
    if _newclass:
        d2rad = staticmethod(_clipper.Util_d2rad)
    __swig_getmethods__["rad2d"] = lambda x: _clipper.Util_rad2d
    if _newclass:
        rad2d = staticmethod(_clipper.Util_rad2d)
    __swig_destroy__ = _clipper.delete_Util
    __del__ = lambda self: None
Util_swigregister = _clipper.Util_swigregister
Util_swigregister(Util)

def Util_nan():
    return _clipper.Util_nan()
Util_nan = _clipper.Util_nan

def Util_nanf():
    return _clipper.Util_nanf()
Util_nanf = _clipper.Util_nanf

def Util_nand():
    return _clipper.Util_nand()
Util_nand = _clipper.Util_nand

def Util_set_null(*args):
    return _clipper.Util_set_null(*args)
Util_set_null = _clipper.Util_set_null

def Util_is_null(*args):
    return _clipper.Util_is_null(*args)
Util_is_null = _clipper.Util_is_null

def Util_is_nan(*args):
    return _clipper.Util_is_nan(*args)
Util_is_nan = _clipper.Util_is_nan

def Util_isnan(*args):
    return _clipper.Util_isnan(*args)
Util_isnan = _clipper.Util_isnan

def Util_sim(x):
    return _clipper.Util_sim(x)
Util_sim = _clipper.Util_sim

def Util_invsim(x):
    return _clipper.Util_invsim(x)
Util_invsim = _clipper.Util_invsim

def Util_sim_integ(x):
    return _clipper.Util_sim_integ(x)
Util_sim_integ = _clipper.Util_sim_integ

def Util_sim_deriv(x):
    return _clipper.Util_sim_deriv(x)
Util_sim_deriv = _clipper.Util_sim_deriv

def Util_sim_deriv_recur(x):
    return _clipper.Util_sim_deriv_recur(x)
Util_sim_deriv_recur = _clipper.Util_sim_deriv_recur

def Util_atanh(x):
    return _clipper.Util_atanh(x)
Util_atanh = _clipper.Util_atanh

def Util_bessel_i0(x):
    return _clipper.Util_bessel_i0(x)
Util_bessel_i0 = _clipper.Util_bessel_i0

def Util_u2b(x):
    return _clipper.Util_u2b(x)
Util_u2b = _clipper.Util_u2b

def Util_b2u(x):
    return _clipper.Util_b2u(x)
Util_b2u = _clipper.Util_b2u

def Util_intf(a):
    return _clipper.Util_intf(a)
Util_intf = _clipper.Util_intf

def Util_intc(a):
    return _clipper.Util_intc(a)
Util_intc = _clipper.Util_intc

def Util_intr(a):
    return _clipper.Util_intr(a)
Util_intr = _clipper.Util_intr

def Util_mod(*args):
    return _clipper.Util_mod(*args)
Util_mod = _clipper.Util_mod

def Util_pi():
    return _clipper.Util_pi()
Util_pi = _clipper.Util_pi

def Util_twopi():
    return _clipper.Util_twopi()
Util_twopi = _clipper.Util_twopi

def Util_twopi2():
    return _clipper.Util_twopi2()
Util_twopi2 = _clipper.Util_twopi2

def Util_eightpi2():
    return _clipper.Util_eightpi2()
Util_eightpi2 = _clipper.Util_eightpi2

def Util_d2rad(x):
    return _clipper.Util_d2rad(x)
Util_d2rad = _clipper.Util_d2rad

def Util_rad2d(x):
    return _clipper.Util_rad2d(x)
Util_rad2d = _clipper.Util_rad2d

class String(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, String, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, String, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_String(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def split(self, sep):
        return _clipper.String_split(self, sep)

    def trim(self):
        return _clipper.String_trim(self)

    def tail(self):
        return _clipper.String_tail(self)

    def head(self):
        return _clipper.String_head(self)

    def nohead(self):
        return _clipper.String_nohead(self)

    def notail(self):
        return _clipper.String_notail(self)

    def i(self):
        return _clipper.String_i(self)

    def l(self):
        return _clipper.String_l(self)

    def f32(self):
        return _clipper.String_f32(self)

    def f64(self):
        return _clipper.String_f64(self)

    def f(self):
        return _clipper.String_f(self)

    def rational(self, *args):
        return _clipper.String_rational(self, *args)

    def __str__(self):
        return _clipper.String___str__(self)
    __swig_destroy__ = _clipper.delete_String
    __del__ = lambda self: None
String_swigregister = _clipper.String_swigregister
String_swigregister(String)

class vec3_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vec3_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vec3_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_vec3_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def equals(self, v, tol):
        return _clipper.vec3_float_equals(self, v, tol)

    def unit(self):
        return _clipper.vec3_float_unit(self)
    __swig_getmethods__["zero"] = lambda x: _clipper.vec3_float_zero
    if _newclass:
        zero = staticmethod(_clipper.vec3_float_zero)
    __swig_getmethods__["null"] = lambda x: _clipper.vec3_float_null
    if _newclass:
        null = staticmethod(_clipper.vec3_float_null)

    def is_null(self):
        return _clipper.vec3_float_is_null(self)
    __swig_getmethods__["dot"] = lambda x: _clipper.vec3_float_dot
    if _newclass:
        dot = staticmethod(_clipper.vec3_float_dot)
    __swig_getmethods__["cross"] = lambda x: _clipper.vec3_float_cross
    if _newclass:
        cross = staticmethod(_clipper.vec3_float_cross)

    def format(self):
        return _clipper.vec3_float_format(self)

    def __iadd__(self, v):
        return _clipper.vec3_float___iadd__(self, v)

    def __isub__(self, v):
        return _clipper.vec3_float___isub__(self, v)

    def __getitem__(self, i):
        return _clipper.vec3_float___getitem__(self, i)

    def __setitem__(self, i, value):
        return _clipper.vec3_float___setitem__(self, i, value)
    __swig_destroy__ = _clipper.delete_vec3_float
    __del__ = lambda self: None
vec3_float_swigregister = _clipper.vec3_float_swigregister
vec3_float_swigregister(vec3_float)

def vec3_float_zero():
    return _clipper.vec3_float_zero()
vec3_float_zero = _clipper.vec3_float_zero

def vec3_float_null():
    return _clipper.vec3_float_null()
vec3_float_null = _clipper.vec3_float_null

def vec3_float_dot(v1, v2):
    return _clipper.vec3_float_dot(v1, v2)
vec3_float_dot = _clipper.vec3_float_dot

def vec3_float_cross(v1, v2):
    return _clipper.vec3_float_cross(v1, v2)
vec3_float_cross = _clipper.vec3_float_cross

class vec3_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vec3_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vec3_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_vec3_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def equals(self, v, tol):
        return _clipper.vec3_double_equals(self, v, tol)

    def unit(self):
        return _clipper.vec3_double_unit(self)
    __swig_getmethods__["zero"] = lambda x: _clipper.vec3_double_zero
    if _newclass:
        zero = staticmethod(_clipper.vec3_double_zero)
    __swig_getmethods__["null"] = lambda x: _clipper.vec3_double_null
    if _newclass:
        null = staticmethod(_clipper.vec3_double_null)

    def is_null(self):
        return _clipper.vec3_double_is_null(self)
    __swig_getmethods__["dot"] = lambda x: _clipper.vec3_double_dot
    if _newclass:
        dot = staticmethod(_clipper.vec3_double_dot)
    __swig_getmethods__["cross"] = lambda x: _clipper.vec3_double_cross
    if _newclass:
        cross = staticmethod(_clipper.vec3_double_cross)

    def format(self):
        return _clipper.vec3_double_format(self)

    def __iadd__(self, v):
        return _clipper.vec3_double___iadd__(self, v)

    def __isub__(self, v):
        return _clipper.vec3_double___isub__(self, v)
    __swig_destroy__ = _clipper.delete_vec3_double
    __del__ = lambda self: None
vec3_double_swigregister = _clipper.vec3_double_swigregister
vec3_double_swigregister(vec3_double)

def vec3_double_zero():
    return _clipper.vec3_double_zero()
vec3_double_zero = _clipper.vec3_double_zero

def vec3_double_null():
    return _clipper.vec3_double_null()
vec3_double_null = _clipper.vec3_double_null

def vec3_double_dot(v1, v2):
    return _clipper.vec3_double_dot(v1, v2)
vec3_double_dot = _clipper.vec3_double_dot

def vec3_double_cross(v1, v2):
    return _clipper.vec3_double_cross(v1, v2)
vec3_double_cross = _clipper.vec3_double_cross

class matrixRowClipper(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrixRowClipper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrixRowClipper, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mat"] = _clipper.matrixRowClipper_mat_set
    __swig_getmethods__["mat"] = _clipper.matrixRowClipper_mat_get
    if _newclass:
        mat = _swig_property(_clipper.matrixRowClipper_mat_get, _clipper.matrixRowClipper_mat_set)
    __swig_setmethods__["row"] = _clipper.matrixRowClipper_row_set
    __swig_getmethods__["row"] = _clipper.matrixRowClipper_row_get
    if _newclass:
        row = _swig_property(_clipper.matrixRowClipper_row_get, _clipper.matrixRowClipper_row_set)

    def __getitem__(self, i):
        return _clipper.matrixRowClipper___getitem__(self, i)

    def __setitem__(self, i, val):
        return _clipper.matrixRowClipper___setitem__(self, i, val)

    def __init__(self):
        this = _clipper.new_matrixRowClipper()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_matrixRowClipper
    __del__ = lambda self: None
matrixRowClipper_swigregister = _clipper.matrixRowClipper_swigregister
matrixRowClipper_swigregister(matrixRowClipper)

class mat33_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mat33_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mat33_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_mat33_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def det(self):
        return _clipper.mat33_float_det(self)

    def inverse(self):
        return _clipper.mat33_float_inverse(self)

    def transpose(self):
        return _clipper.mat33_float_transpose(self)

    def equals(self, m, tol):
        return _clipper.mat33_float_equals(self, m, tol)

    def __call__(self, *args):
        return _clipper.mat33_float___call__(self, *args)

    def format(self):
        return _clipper.mat33_float_format(self)
    __swig_getmethods__["identity"] = lambda x: _clipper.mat33_float_identity
    if _newclass:
        identity = staticmethod(_clipper.mat33_float_identity)
    __swig_getmethods__["null"] = lambda x: _clipper.mat33_float_null
    if _newclass:
        null = staticmethod(_clipper.mat33_float_null)

    def is_null(self):
        return _clipper.mat33_float_is_null(self)

    def __getitem__(self, i):
        return _clipper.mat33_float___getitem__(self, i)

    def __neg__(self):
        return _clipper.mat33_float___neg__(self)

    def __mul__(self, *args):
        return _clipper.mat33_float___mul__(self, *args)

    def __sub__(self, m):
        return _clipper.mat33_float___sub__(self, m)

    def __add__(self, m):
        return _clipper.mat33_float___add__(self, m)
    __swig_destroy__ = _clipper.delete_mat33_float
    __del__ = lambda self: None
mat33_float_swigregister = _clipper.mat33_float_swigregister
mat33_float_swigregister(mat33_float)

def mat33_float_identity():
    return _clipper.mat33_float_identity()
mat33_float_identity = _clipper.mat33_float_identity

def mat33_float_null():
    return _clipper.mat33_float_null()
mat33_float_null = _clipper.mat33_float_null

class mat33_ftype(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mat33_ftype, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mat33_ftype, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_mat33_ftype(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def det(self):
        return _clipper.mat33_ftype_det(self)

    def inverse(self):
        return _clipper.mat33_ftype_inverse(self)

    def transpose(self):
        return _clipper.mat33_ftype_transpose(self)

    def equals(self, m, tol):
        return _clipper.mat33_ftype_equals(self, m, tol)

    def __call__(self, *args):
        return _clipper.mat33_ftype___call__(self, *args)

    def format(self):
        return _clipper.mat33_ftype_format(self)
    __swig_getmethods__["identity"] = lambda x: _clipper.mat33_ftype_identity
    if _newclass:
        identity = staticmethod(_clipper.mat33_ftype_identity)
    __swig_getmethods__["null"] = lambda x: _clipper.mat33_ftype_null
    if _newclass:
        null = staticmethod(_clipper.mat33_ftype_null)

    def is_null(self):
        return _clipper.mat33_ftype_is_null(self)
    __swig_destroy__ = _clipper.delete_mat33_ftype
    __del__ = lambda self: None
mat33_ftype_swigregister = _clipper.mat33_ftype_swigregister
mat33_ftype_swigregister(mat33_ftype)

def mat33_ftype_identity():
    return _clipper.mat33_ftype_identity()
mat33_ftype_identity = _clipper.mat33_ftype_identity

def mat33_ftype_null():
    return _clipper.mat33_ftype_null()
mat33_ftype_null = _clipper.mat33_ftype_null

class RTop_frac(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RTop_frac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RTop_frac, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_RTop_frac(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rtop_orth(self, cell):
        return _clipper.RTop_frac_rtop_orth(self, cell)

    def inverse(self):
        return _clipper.RTop_frac_inverse(self)
    __swig_getmethods__["identity"] = lambda x: _clipper.RTop_frac_identity
    if _newclass:
        identity = staticmethod(_clipper.RTop_frac_identity)
    __swig_getmethods__["null"] = lambda x: _clipper.RTop_frac_null
    if _newclass:
        null = staticmethod(_clipper.RTop_frac_null)
    __swig_destroy__ = _clipper.delete_RTop_frac
    __del__ = lambda self: None
RTop_frac_swigregister = _clipper.RTop_frac_swigregister
RTop_frac_swigregister(RTop_frac)

def RTop_frac_identity():
    return _clipper.RTop_frac_identity()
RTop_frac_identity = _clipper.RTop_frac_identity

def RTop_frac_null():
    return _clipper.RTop_frac_null()
RTop_frac_null = _clipper.RTop_frac_null

class Symop(RTop_frac):
    __swig_setmethods__ = {}
    for _s in [RTop_frac]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Symop, name, value)
    __swig_getmethods__ = {}
    for _s in [RTop_frac]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Symop, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Symop(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def format(self):
        return _clipper.Symop_format(self)
    __swig_destroy__ = _clipper.delete_Symop
    __del__ = lambda self: None
Symop_swigregister = _clipper.Symop_swigregister
Symop_swigregister(Symop)

class Isymop(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Isymop, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Isymop, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Isymop(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Isymop
    __del__ = lambda self: None
Isymop_swigregister = _clipper.Isymop_swigregister
Isymop_swigregister(Isymop)

class Symop_code(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Symop_code, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Symop_code, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Symop_code(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, op):
        return _clipper.Symop_code_init(self, op)

    def code_rot(self):
        return _clipper.Symop_code_code_rot(self)

    def code_trn(self):
        return _clipper.Symop_code_code_trn(self)

    def symop(self):
        return _clipper.Symop_code_symop(self)

    def isymop(self):
        return _clipper.Symop_code_isymop(self)
    __swig_getmethods__["identity"] = lambda x: _clipper.Symop_code_identity
    if _newclass:
        identity = staticmethod(_clipper.Symop_code_identity)
    __swig_destroy__ = _clipper.delete_Symop_code
    __del__ = lambda self: None
Symop_code_swigregister = _clipper.Symop_code_swigregister
Symop_code_swigregister(Symop_code)

def Symop_code_identity():
    return _clipper.Symop_code_identity()
Symop_code_identity = _clipper.Symop_code_identity

class SGdata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SGdata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SGdata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["sghash"] = _clipper.SGdata_sghash_set
    __swig_getmethods__["sghash"] = _clipper.SGdata_sghash_get
    if _newclass:
        sghash = _swig_property(_clipper.SGdata_sghash_get, _clipper.SGdata_sghash_set)
    __swig_getmethods__["hall"] = _clipper.SGdata_hall_get
    if _newclass:
        hall = _swig_property(_clipper.SGdata_hall_get)
    __swig_getmethods__["hm"] = _clipper.SGdata_hm_get
    if _newclass:
        hm = _swig_property(_clipper.SGdata_hm_get)
    __swig_setmethods__["ext"] = _clipper.SGdata_ext_set
    __swig_getmethods__["ext"] = _clipper.SGdata_ext_get
    if _newclass:
        ext = _swig_property(_clipper.SGdata_ext_get, _clipper.SGdata_ext_set)
    __swig_setmethods__["num"] = _clipper.SGdata_num_set
    __swig_getmethods__["num"] = _clipper.SGdata_num_get
    if _newclass:
        num = _swig_property(_clipper.SGdata_num_get, _clipper.SGdata_num_set)

    def __init__(self):
        this = _clipper.new_SGdata()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_SGdata
    __del__ = lambda self: None
SGdata_swigregister = _clipper.SGdata_swigregister
SGdata_swigregister(SGdata)

class LGdata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LGdata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LGdata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lghash"] = _clipper.LGdata_lghash_set
    __swig_getmethods__["lghash"] = _clipper.LGdata_lghash_get
    if _newclass:
        lghash = _swig_property(_clipper.LGdata_lghash_get, _clipper.LGdata_lghash_set)
    __swig_setmethods__["asufn"] = _clipper.LGdata_asufn_set
    __swig_getmethods__["asufn"] = _clipper.LGdata_asufn_get
    if _newclass:
        asufn = _swig_property(_clipper.LGdata_asufn_get, _clipper.LGdata_asufn_set)
    __swig_getmethods__["lgname"] = _clipper.LGdata_lgname_get
    if _newclass:
        lgname = _swig_property(_clipper.LGdata_lgname_get)

    def __init__(self):
        this = _clipper.new_LGdata()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_LGdata
    __del__ = lambda self: None
LGdata_swigregister = _clipper.LGdata_swigregister
LGdata_swigregister(LGdata)

class Spgr_descr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spgr_descr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Spgr_descr, name)
    __repr__ = _swig_repr
    Hall = _clipper.Spgr_descr_Hall
    HM = _clipper.Spgr_descr_HM
    XHM = _clipper.Spgr_descr_XHM
    Symops = _clipper.Spgr_descr_Symops
    Number = _clipper.Spgr_descr_Number
    Unknown = _clipper.Spgr_descr_Unknown

    def spacegroup_number(self):
        return _clipper.Spgr_descr_spacegroup_number(self)

    def symbol_hall(self):
        return _clipper.Spgr_descr_symbol_hall(self)

    def symbol_hm(self):
        return _clipper.Spgr_descr_symbol_hm(self)

    def symbol_xhm(self):
        return _clipper.Spgr_descr_symbol_xhm(self)

    def symbol_hm_ext(self):
        return _clipper.Spgr_descr_symbol_hm_ext(self)
    __swig_getmethods__["set_preferred"] = lambda x: _clipper.Spgr_descr_set_preferred
    if _newclass:
        set_preferred = staticmethod(_clipper.Spgr_descr_set_preferred)

    def __init__(self, *args):
        this = _clipper.new_Spgr_descr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def generator_ops(self):
        return _clipper.Spgr_descr_generator_ops(self)

    def hash(self):
        return _clipper.Spgr_descr_hash(self)
    __swig_destroy__ = _clipper.delete_Spgr_descr
    __del__ = lambda self: None
Spgr_descr_swigregister = _clipper.Spgr_descr_swigregister
Spgr_descr_swigregister(Spgr_descr)
cvar = _clipper.cvar

def Spgr_descr_set_preferred(c):
    return _clipper.Spgr_descr_set_preferred(c)
Spgr_descr_set_preferred = _clipper.Spgr_descr_set_preferred

class Symop_codes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Symop_codes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Symop_codes, name)
    __repr__ = _swig_repr

    def init_hall(self, symb):
        return _clipper.Symop_codes_init_hall(self, symb)

    def init_symops(self, symb):
        return _clipper.Symop_codes_init_symops(self, symb)

    def expand(self):
        return _clipper.Symop_codes_expand(self)

    def primitive_noninversion_ops(self):
        return _clipper.Symop_codes_primitive_noninversion_ops(self)

    def inversion_ops(self):
        return _clipper.Symop_codes_inversion_ops(self)

    def primitive_ops(self):
        return _clipper.Symop_codes_primitive_ops(self)

    def centering_ops(self):
        return _clipper.Symop_codes_centering_ops(self)

    def laue_ops(self):
        return _clipper.Symop_codes_laue_ops(self)

    def pgrp_ops(self):
        return _clipper.Symop_codes_pgrp_ops(self)

    def patterson_ops(self):
        return _clipper.Symop_codes_patterson_ops(self)

    def generator_ops(self):
        return _clipper.Symop_codes_generator_ops(self)

    def product(self, ops2):
        return _clipper.Symop_codes_product(self, ops2)

    def hash(self):
        return _clipper.Symop_codes_hash(self)

    def __init__(self):
        this = _clipper.new_Symop_codes()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Symop_codes
    __del__ = lambda self: None
Symop_codes_swigregister = _clipper.Symop_codes_swigregister
Symop_codes_swigregister(Symop_codes)

class Spgr_cacheobj(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spgr_cacheobj, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Spgr_cacheobj, name)
    __repr__ = _swig_repr

    def __init__(self, spgr_cachekey):
        this = _clipper.new_Spgr_cacheobj(spgr_cachekey)
        try:
            self.this.append(this)
        except:
            self.this = this

    def matches(self, spgr_cachekey):
        return _clipper.Spgr_cacheobj_matches(self, spgr_cachekey)

    def format(self):
        return _clipper.Spgr_cacheobj_format(self)
    __swig_setmethods__["spgr_cachekey_"] = _clipper.Spgr_cacheobj_spgr_cachekey__set
    __swig_getmethods__["spgr_cachekey_"] = _clipper.Spgr_cacheobj_spgr_cachekey__get
    if _newclass:
        spgr_cachekey_ = _swig_property(_clipper.Spgr_cacheobj_spgr_cachekey__get, _clipper.Spgr_cacheobj_spgr_cachekey__set)
    __swig_setmethods__["nsym"] = _clipper.Spgr_cacheobj_nsym_set
    __swig_getmethods__["nsym"] = _clipper.Spgr_cacheobj_nsym_get
    if _newclass:
        nsym = _swig_property(_clipper.Spgr_cacheobj_nsym_get, _clipper.Spgr_cacheobj_nsym_set)
    __swig_setmethods__["nsymn"] = _clipper.Spgr_cacheobj_nsymn_set
    __swig_getmethods__["nsymn"] = _clipper.Spgr_cacheobj_nsymn_get
    if _newclass:
        nsymn = _swig_property(_clipper.Spgr_cacheobj_nsymn_get, _clipper.Spgr_cacheobj_nsymn_set)
    __swig_setmethods__["nsymi"] = _clipper.Spgr_cacheobj_nsymi_set
    __swig_getmethods__["nsymi"] = _clipper.Spgr_cacheobj_nsymi_get
    if _newclass:
        nsymi = _swig_property(_clipper.Spgr_cacheobj_nsymi_get, _clipper.Spgr_cacheobj_nsymi_set)
    __swig_setmethods__["nsymc"] = _clipper.Spgr_cacheobj_nsymc_set
    __swig_getmethods__["nsymc"] = _clipper.Spgr_cacheobj_nsymc_get
    if _newclass:
        nsymc = _swig_property(_clipper.Spgr_cacheobj_nsymc_get, _clipper.Spgr_cacheobj_nsymc_set)
    __swig_setmethods__["nsymp"] = _clipper.Spgr_cacheobj_nsymp_set
    __swig_getmethods__["nsymp"] = _clipper.Spgr_cacheobj_nsymp_get
    if _newclass:
        nsymp = _swig_property(_clipper.Spgr_cacheobj_nsymp_get, _clipper.Spgr_cacheobj_nsymp_set)
    __swig_setmethods__["lgrp"] = _clipper.Spgr_cacheobj_lgrp_set
    __swig_getmethods__["lgrp"] = _clipper.Spgr_cacheobj_lgrp_get
    if _newclass:
        lgrp = _swig_property(_clipper.Spgr_cacheobj_lgrp_get, _clipper.Spgr_cacheobj_lgrp_set)
    __swig_setmethods__["symops"] = _clipper.Spgr_cacheobj_symops_set
    __swig_getmethods__["symops"] = _clipper.Spgr_cacheobj_symops_get
    if _newclass:
        symops = _swig_property(_clipper.Spgr_cacheobj_symops_get, _clipper.Spgr_cacheobj_symops_set)
    __swig_setmethods__["isymops"] = _clipper.Spgr_cacheobj_isymops_set
    __swig_getmethods__["isymops"] = _clipper.Spgr_cacheobj_isymops_get
    if _newclass:
        isymops = _swig_property(_clipper.Spgr_cacheobj_isymops_get, _clipper.Spgr_cacheobj_isymops_set)
    __swig_setmethods__["asu_min_"] = _clipper.Spgr_cacheobj_asu_min__set
    __swig_getmethods__["asu_min_"] = _clipper.Spgr_cacheobj_asu_min__get
    if _newclass:
        asu_min_ = _swig_property(_clipper.Spgr_cacheobj_asu_min__get, _clipper.Spgr_cacheobj_asu_min__set)
    __swig_setmethods__["asu_max_"] = _clipper.Spgr_cacheobj_asu_max__set
    __swig_getmethods__["asu_max_"] = _clipper.Spgr_cacheobj_asu_max__get
    if _newclass:
        asu_max_ = _swig_property(_clipper.Spgr_cacheobj_asu_max__get, _clipper.Spgr_cacheobj_asu_max__set)
    __swig_setmethods__["mutex"] = _clipper.Spgr_cacheobj_mutex_set
    __swig_getmethods__["mutex"] = _clipper.Spgr_cacheobj_mutex_get
    if _newclass:
        mutex = _swig_property(_clipper.Spgr_cacheobj_mutex_get, _clipper.Spgr_cacheobj_mutex_set)
    __swig_destroy__ = _clipper.delete_Spgr_cacheobj
    __del__ = lambda self: None
Spgr_cacheobj_swigregister = _clipper.Spgr_cacheobj_swigregister
Spgr_cacheobj_swigregister(Spgr_cacheobj)

class Spacegroup(Spgr_descr):
    __swig_setmethods__ = {}
    for _s in [Spgr_descr]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spacegroup, name, value)
    __swig_getmethods__ = {}
    for _s in [Spgr_descr]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Spacegroup, name)
    __repr__ = _swig_repr
    Null = _clipper.Spacegroup_Null
    P1 = _clipper.Spacegroup_P1
    A = _clipper.Spacegroup_A
    B = _clipper.Spacegroup_B
    C = _clipper.Spacegroup_C

    def __init__(self, *args):
        this = _clipper.new_Spacegroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spgr_descr):
        return _clipper.Spacegroup_init(self, spgr_descr)

    def is_null(self):
        return _clipper.Spacegroup_is_null(self)

    def descr(self):
        return _clipper.Spacegroup_descr(self)

    def num_symops(self):
        return _clipper.Spacegroup_num_symops(self)

    def num_primops(self):
        return _clipper.Spacegroup_num_primops(self)

    def num_primitive_symops(self):
        return _clipper.Spacegroup_num_primitive_symops(self)

    def num_centering_symops(self):
        return _clipper.Spacegroup_num_centering_symops(self)

    def num_inversion_symops(self):
        return _clipper.Spacegroup_num_inversion_symops(self)

    def num_primitive_noninversion_symops(self):
        return _clipper.Spacegroup_num_primitive_noninversion_symops(self)

    def symop(self, sym_no):
        return _clipper.Spacegroup_symop(self, sym_no)

    def primitive_symop(self, sym_no):
        return _clipper.Spacegroup_primitive_symop(self, sym_no)

    def inversion_symop(self, sym_no):
        return _clipper.Spacegroup_inversion_symop(self, sym_no)

    def centering_symop(self, sym_no):
        return _clipper.Spacegroup_centering_symop(self, sym_no)

    def order_of_symmetry_about_axis(self, axis):
        return _clipper.Spacegroup_order_of_symmetry_about_axis(self, axis)

    def hkl_class(self, hkl):
        return _clipper.Spacegroup_hkl_class(self, hkl)

    def recip_asu(self, hkl):
        return _clipper.Spacegroup_recip_asu(self, hkl)

    def product_op(self, s1, s2):
        return _clipper.Spacegroup_product_op(self, s1, s2)

    def inverse_op(self, s):
        return _clipper.Spacegroup_inverse_op(self, s)

    def asu_max(self):
        return _clipper.Spacegroup_asu_max(self)

    def asu_min(self):
        return _clipper.Spacegroup_asu_min(self)

    def invariant_under_change_of_hand(self):
        return _clipper.Spacegroup_invariant_under_change_of_hand(self)

    def symbol_laue(self):
        return _clipper.Spacegroup_symbol_laue(self)
    __swig_getmethods__["p1"] = lambda x: _clipper.Spacegroup_p1
    if _newclass:
        p1 = staticmethod(_clipper.Spacegroup_p1)
    __swig_getmethods__["null"] = lambda x: _clipper.Spacegroup_null
    if _newclass:
        null = staticmethod(_clipper.Spacegroup_null)

    def debug(self):
        return _clipper.Spacegroup_debug(self)
    __swig_destroy__ = _clipper.delete_Spacegroup
    __del__ = lambda self: None
Spacegroup_swigregister = _clipper.Spacegroup_swigregister
Spacegroup_swigregister(Spacegroup)

def Spacegroup_p1():
    return _clipper.Spacegroup_p1()
Spacegroup_p1 = _clipper.Spacegroup_p1

def Spacegroup_null():
    return _clipper.Spacegroup_null()
Spacegroup_null = _clipper.Spacegroup_null

class Metric_tensor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Metric_tensor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Metric_tensor, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Metric_tensor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def lengthsq(self, *args):
        return _clipper.Metric_tensor_lengthsq(self, *args)

    def format(self):
        return _clipper.Metric_tensor_format(self)
    __swig_destroy__ = _clipper.delete_Metric_tensor
    __del__ = lambda self: None
Metric_tensor_swigregister = _clipper.Metric_tensor_swigregister
Metric_tensor_swigregister(Metric_tensor)

class Cell_descr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cell_descr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cell_descr, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Cell_descr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def a(self):
        return _clipper.Cell_descr_a(self)

    def b(self):
        return _clipper.Cell_descr_b(self)

    def c(self):
        return _clipper.Cell_descr_c(self)

    def alpha(self):
        return _clipper.Cell_descr_alpha(self)

    def beta(self):
        return _clipper.Cell_descr_beta(self)

    def gamma(self):
        return _clipper.Cell_descr_gamma(self)

    def alpha_deg(self):
        return _clipper.Cell_descr_alpha_deg(self)

    def beta_deg(self):
        return _clipper.Cell_descr_beta_deg(self)

    def gamma_deg(self):
        return _clipper.Cell_descr_gamma_deg(self)

    def format(self):
        return _clipper.Cell_descr_format(self)
    __swig_destroy__ = _clipper.delete_Cell_descr
    __del__ = lambda self: None
Cell_descr_swigregister = _clipper.Cell_descr_swigregister
Cell_descr_swigregister(Cell_descr)

class Cell(Cell_descr):
    __swig_setmethods__ = {}
    for _s in [Cell_descr]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cell, name, value)
    __swig_getmethods__ = {}
    for _s in [Cell_descr]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cell, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Cell(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, cell_):
        return _clipper.Cell_init(self, cell_)

    def is_null(self):
        return _clipper.Cell_is_null(self)

    def a_star(self):
        return _clipper.Cell_a_star(self)

    def b_star(self):
        return _clipper.Cell_b_star(self)

    def c_star(self):
        return _clipper.Cell_c_star(self)

    def alpha_star(self):
        return _clipper.Cell_alpha_star(self)

    def beta_star(self):
        return _clipper.Cell_beta_star(self)

    def gamma_star(self):
        return _clipper.Cell_gamma_star(self)

    def volume(self):
        return _clipper.Cell_volume(self)

    def equals(self, other, tol=1.0):
        return _clipper.Cell_equals(self, other, tol)

    def metric_real(self):
        return _clipper.Cell_metric_real(self)

    def metric_reci(self):
        return _clipper.Cell_metric_reci(self)

    def debug(self):
        return _clipper.Cell_debug(self)

    def matrix_orth(self):
        return _clipper.Cell_matrix_orth(self)

    def matrix_frac(self):
        return _clipper.Cell_matrix_frac(self)
    __swig_destroy__ = _clipper.delete_Cell
    __del__ = lambda self: None
Cell_swigregister = _clipper.Cell_swigregister
Cell_swigregister(Cell)

class Resolution(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Resolution, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Resolution, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Resolution(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, resol_):
        return _clipper.Resolution_init(self, resol_)

    def limit(self):
        return _clipper.Resolution_limit(self)

    def invresolsq_limit(self):
        return _clipper.Resolution_invresolsq_limit(self)

    def is_null(self):
        return _clipper.Resolution_is_null(self)
    __swig_destroy__ = _clipper.delete_Resolution
    __del__ = lambda self: None
Resolution_swigregister = _clipper.Resolution_swigregister
Resolution_swigregister(Resolution)

class HKL_class(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_class, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_class, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_class(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def epsilon(self):
        return _clipper.HKL_class_epsilon(self)

    def epsilonc(self):
        return _clipper.HKL_class_epsilonc(self)

    def allowed(self):
        return _clipper.HKL_class_allowed(self)

    def centric(self):
        return _clipper.HKL_class_centric(self)

    def sys_abs(self):
        return _clipper.HKL_class_sys_abs(self)
    __swig_destroy__ = _clipper.delete_HKL_class
    __del__ = lambda self: None
HKL_class_swigregister = _clipper.HKL_class_swigregister
HKL_class_swigregister(HKL_class)

class RTop_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RTop_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RTop_orth, name)
    __repr__ = _swig_repr

    def rtop_frac(self, cell):
        return _clipper.RTop_orth_rtop_frac(self, cell)

    def inverse(self):
        return _clipper.RTop_orth_inverse(self)

    def axis_coordinate_near(self, centre):
        return _clipper.RTop_orth_axis_coordinate_near(self, centre)

    def screw_translation(self):
        return _clipper.RTop_orth_screw_translation(self)
    __swig_getmethods__["identity"] = lambda x: _clipper.RTop_orth_identity
    if _newclass:
        identity = staticmethod(_clipper.RTop_orth_identity)
    __swig_getmethods__["null"] = lambda x: _clipper.RTop_orth_null
    if _newclass:
        null = staticmethod(_clipper.RTop_orth_null)

    def __init__(self, *args):
        this = _clipper.new_RTop_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_RTop_orth
    __del__ = lambda self: None
RTop_orth_swigregister = _clipper.RTop_orth_swigregister
RTop_orth_swigregister(RTop_orth)

def RTop_orth_identity():
    return _clipper.RTop_orth_identity()
RTop_orth_identity = _clipper.RTop_orth_identity

def RTop_orth_null():
    return _clipper.RTop_orth_null()
RTop_orth_null = _clipper.RTop_orth_null

class HKL(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def h(self, *args):
        return _clipper.HKL_h(self, *args)

    def k(self, *args):
        return _clipper.HKL_k(self, *args)

    def l(self, *args):
        return _clipper.HKL_l(self, *args)

    def invresolsq(self, cell):
        return _clipper.HKL_invresolsq(self, cell)

    def coord_reci_frac(self):
        return _clipper.HKL_coord_reci_frac(self)

    def coord_reci_orth(self, cell):
        return _clipper.HKL_coord_reci_orth(self, cell)

    def transform(self, *args):
        return _clipper.HKL_transform(self, *args)

    def sym_phase_shift(self, op):
        return _clipper.HKL_sym_phase_shift(self, op)

    def format(self):
        return _clipper.HKL_format(self)

    def __add__(self, h2):
        return _clipper.HKL___add__(self, h2)

    def __sub__(self, h2):
        return _clipper.HKL___sub__(self, h2)

    def __neg__(self):
        return _clipper.HKL___neg__(self)
    __swig_destroy__ = _clipper.delete_HKL
    __del__ = lambda self: None
HKL_swigregister = _clipper.HKL_swigregister
HKL_swigregister(HKL)

def neg_HKL(h1):
    return _clipper.neg_HKL(h1)
neg_HKL = _clipper.neg_HKL

def add_HKL(h1, h2):
    return _clipper.add_HKL(h1, h2)
add_HKL = _clipper.add_HKL

def subs_HKL(h1, h2):
    return _clipper.subs_HKL(h1, h2)
subs_HKL = _clipper.subs_HKL

def product_HKL(s, h1):
    return _clipper.product_HKL(s, h1)
product_HKL = _clipper.product_HKL

def transf_HKL(op, h1):
    return _clipper.transf_HKL(op, h1)
transf_HKL = _clipper.transf_HKL

class Coord_reci_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_reci_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_reci_orth, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_reci_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def xs(self):
        return _clipper.Coord_reci_orth_xs(self)

    def ys(self):
        return _clipper.Coord_reci_orth_ys(self)

    def zs(self):
        return _clipper.Coord_reci_orth_zs(self)

    def invresolsq(self):
        return _clipper.Coord_reci_orth_invresolsq(self)

    def coord_reci_frac(self, cell):
        return _clipper.Coord_reci_orth_coord_reci_frac(self, cell)

    def transform(self, op):
        return _clipper.Coord_reci_orth_transform(self, op)

    def format(self):
        return _clipper.Coord_reci_orth_format(self)
    __swig_destroy__ = _clipper.delete_Coord_reci_orth
    __del__ = lambda self: None
Coord_reci_orth_swigregister = _clipper.Coord_reci_orth_swigregister
Coord_reci_orth_swigregister(Coord_reci_orth)

class Coord_reci_frac(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_reci_frac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_reci_frac, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_reci_frac(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def hkl(self):
        return _clipper.Coord_reci_frac_hkl(self)

    def invresolsq(self, cell):
        return _clipper.Coord_reci_frac_invresolsq(self, cell)

    def us(self):
        return _clipper.Coord_reci_frac_us(self)

    def vs(self):
        return _clipper.Coord_reci_frac_vs(self)

    def ws(self):
        return _clipper.Coord_reci_frac_ws(self)

    def coord_reci_orth(self, cell):
        return _clipper.Coord_reci_frac_coord_reci_orth(self, cell)

    def transform(self, op):
        return _clipper.Coord_reci_frac_transform(self, op)

    def format(self):
        return _clipper.Coord_reci_frac_format(self)
    __swig_destroy__ = _clipper.delete_Coord_reci_frac
    __del__ = lambda self: None
Coord_reci_frac_swigregister = _clipper.Coord_reci_frac_swigregister
Coord_reci_frac_swigregister(Coord_reci_frac)

class Coord_grid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_grid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_grid, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_grid(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def u(self, *args):
        return _clipper.Coord_grid_u(self, *args)

    def v(self, *args):
        return _clipper.Coord_grid_v(self, *args)

    def w(self, *args):
        return _clipper.Coord_grid_w(self, *args)

    def coord_map(self):
        return _clipper.Coord_grid_coord_map(self)

    def coord_frac(self, g):
        return _clipper.Coord_grid_coord_frac(self, g)

    def transform(self, op):
        return _clipper.Coord_grid_transform(self, op)

    def unit(self, g):
        return _clipper.Coord_grid_unit(self, g)

    def next(self, *args):
        return _clipper.Coord_grid_next(self, *args)

    def last(self, *args):
        return _clipper.Coord_grid_last(self, *args)

    def index(self, g):
        return _clipper.Coord_grid_index(self, g)

    def deindex(self, g, index):
        return _clipper.Coord_grid_deindex(self, g, index)

    def format(self):
        return _clipper.Coord_grid_format(self)

    def __cmp__(self, g2):
        return _clipper.Coord_grid___cmp__(self, g2)

    def __ne__(self, g2):
        return _clipper.Coord_grid___ne__(self, g2)

    def __add__(self, g2):
        return _clipper.Coord_grid___add__(self, g2)

    def __neg__(self):
        return _clipper.Coord_grid___neg__(self)

    def __sub__(self, g2):
        return _clipper.Coord_grid___sub__(self, g2)
    __swig_destroy__ = _clipper.delete_Coord_grid
    __del__ = lambda self: None
Coord_grid_swigregister = _clipper.Coord_grid_swigregister
Coord_grid_swigregister(Coord_grid)

def neg_Coord_grid(r1):
    return _clipper.neg_Coord_grid(r1)
neg_Coord_grid = _clipper.neg_Coord_grid

def add_Coord_grid(r1, r2):
    return _clipper.add_Coord_grid(r1, r2)
add_Coord_grid = _clipper.add_Coord_grid

def subs_Coord_grid(r1, r2):
    return _clipper.subs_Coord_grid(r1, r2)
subs_Coord_grid = _clipper.subs_Coord_grid

def product_Coord_grid(s, r1):
    return _clipper.product_Coord_grid(s, r1)
product_Coord_grid = _clipper.product_Coord_grid

def equals_Coord_grid(r1, r2):
    return _clipper.equals_Coord_grid(r1, r2)
equals_Coord_grid = _clipper.equals_Coord_grid

def notequals_Coord_grid(r1, r2):
    return _clipper.notequals_Coord_grid(r1, r2)
notequals_Coord_grid = _clipper.notequals_Coord_grid

def transf_Coord_grid(op, r1):
    return _clipper.transf_Coord_grid(op, r1)
transf_Coord_grid = _clipper.transf_Coord_grid

class Coord_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_orth, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def x(self):
        return _clipper.Coord_orth_x(self)

    def y(self):
        return _clipper.Coord_orth_y(self)

    def z(self):
        return _clipper.Coord_orth_z(self)

    def lengthsq(self):
        return _clipper.Coord_orth_lengthsq(self)

    def coord_frac(self, cell):
        return _clipper.Coord_orth_coord_frac(self, cell)

    def transform(self, op):
        return _clipper.Coord_orth_transform(self, op)

    def format(self):
        return _clipper.Coord_orth_format(self)
    __swig_getmethods__["length"] = lambda x: _clipper.Coord_orth_length
    if _newclass:
        length = staticmethod(_clipper.Coord_orth_length)
    __swig_getmethods__["angle"] = lambda x: _clipper.Coord_orth_angle
    if _newclass:
        angle = staticmethod(_clipper.Coord_orth_angle)
    __swig_getmethods__["torsion"] = lambda x: _clipper.Coord_orth_torsion
    if _newclass:
        torsion = staticmethod(_clipper.Coord_orth_torsion)

    def __add__(self, h2):
        return _clipper.Coord_orth___add__(self, h2)

    def __sub__(self, h2):
        return _clipper.Coord_orth___sub__(self, h2)

    def __neg__(self):
        return _clipper.Coord_orth___neg__(self)

    def __mul__(self, *args):
        return _clipper.Coord_orth___mul__(self, *args)
    __swig_destroy__ = _clipper.delete_Coord_orth
    __del__ = lambda self: None
Coord_orth_swigregister = _clipper.Coord_orth_swigregister
Coord_orth_swigregister(Coord_orth)

def Coord_orth_length(x1, x2):
    return _clipper.Coord_orth_length(x1, x2)
Coord_orth_length = _clipper.Coord_orth_length

def Coord_orth_angle(x1, x2, x3):
    return _clipper.Coord_orth_angle(x1, x2, x3)
Coord_orth_angle = _clipper.Coord_orth_angle

def Coord_orth_torsion(x1, x2, x3, x4):
    return _clipper.Coord_orth_torsion(x1, x2, x3, x4)
Coord_orth_torsion = _clipper.Coord_orth_torsion

def neg_Coord_orth(x1):
    return _clipper.neg_Coord_orth(x1)
neg_Coord_orth = _clipper.neg_Coord_orth

def add_Coord_orth(x1, x2):
    return _clipper.add_Coord_orth(x1, x2)
add_Coord_orth = _clipper.add_Coord_orth

def subs_Coord_orth(x1, x2):
    return _clipper.subs_Coord_orth(x1, x2)
subs_Coord_orth = _clipper.subs_Coord_orth

def product_Coord_orth(s, x1):
    return _clipper.product_Coord_orth(s, x1)
product_Coord_orth = _clipper.product_Coord_orth

def transf_Coord_orth(op, x1):
    return _clipper.transf_Coord_orth(op, x1)
transf_Coord_orth = _clipper.transf_Coord_orth

class Coord_frac(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_frac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_frac, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_frac(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def u(self):
        return _clipper.Coord_frac_u(self)

    def v(self):
        return _clipper.Coord_frac_v(self)

    def w(self):
        return _clipper.Coord_frac_w(self)

    def lengthsq(self, cell):
        return _clipper.Coord_frac_lengthsq(self, cell)

    def coord_orth(self, cell):
        return _clipper.Coord_frac_coord_orth(self, cell)

    def coord_map(self, g):
        return _clipper.Coord_frac_coord_map(self, g)

    def coord_grid(self, g):
        return _clipper.Coord_frac_coord_grid(self, g)

    def transform(self, op):
        return _clipper.Coord_frac_transform(self, op)

    def lattice_copy_zero(self):
        return _clipper.Coord_frac_lattice_copy_zero(self)

    def lattice_copy_unit(self):
        return _clipper.Coord_frac_lattice_copy_unit(self)

    def lattice_copy_near(self, n):
        return _clipper.Coord_frac_lattice_copy_near(self, n)

    def symmetry_copy_near(self, spgr, cell, n):
        return _clipper.Coord_frac_symmetry_copy_near(self, spgr, cell, n)

    def format(self):
        return _clipper.Coord_frac_format(self)

    def __add__(self, h2):
        return _clipper.Coord_frac___add__(self, h2)

    def __sub__(self, h2):
        return _clipper.Coord_frac___sub__(self, h2)

    def __neg__(self):
        return _clipper.Coord_frac___neg__(self)

    def __mul__(self, *args):
        return _clipper.Coord_frac___mul__(self, *args)
    __swig_destroy__ = _clipper.delete_Coord_frac
    __del__ = lambda self: None
Coord_frac_swigregister = _clipper.Coord_frac_swigregister
Coord_frac_swigregister(Coord_frac)

def neg_Coord_frac(u1):
    return _clipper.neg_Coord_frac(u1)
neg_Coord_frac = _clipper.neg_Coord_frac

def add_Coord_frac(u1, u2):
    return _clipper.add_Coord_frac(u1, u2)
add_Coord_frac = _clipper.add_Coord_frac

def subs_Coord_frac(u1, u2):
    return _clipper.subs_Coord_frac(u1, u2)
subs_Coord_frac = _clipper.subs_Coord_frac

def product_Coord_frac(s, u1):
    return _clipper.product_Coord_frac(s, u1)
product_Coord_frac = _clipper.product_Coord_frac

def transf_Coord_frac(op, x1):
    return _clipper.transf_Coord_frac(op, x1)
transf_Coord_frac = _clipper.transf_Coord_frac

class Coord_map(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coord_map, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coord_map, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Coord_map(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def coord_frac(self, g):
        return _clipper.Coord_map_coord_frac(self, g)

    def coord_grid(self):
        return _clipper.Coord_map_coord_grid(self)

    def floor(self):
        return _clipper.Coord_map_floor(self)

    def ceil(self):
        return _clipper.Coord_map_ceil(self)

    def u(self):
        return _clipper.Coord_map_u(self)

    def v(self):
        return _clipper.Coord_map_v(self)

    def w(self):
        return _clipper.Coord_map_w(self)

    def format(self):
        return _clipper.Coord_map_format(self)
    __swig_destroy__ = _clipper.delete_Coord_map
    __del__ = lambda self: None
Coord_map_swigregister = _clipper.Coord_map_swigregister
Coord_map_swigregister(Coord_map)

def neg_Coord_map(u1):
    return _clipper.neg_Coord_map(u1)
neg_Coord_map = _clipper.neg_Coord_map

def add_Coord_map(u1, u2):
    return _clipper.add_Coord_map(u1, u2)
add_Coord_map = _clipper.add_Coord_map

def subs_Coord_map(u1, u2):
    return _clipper.subs_Coord_map(u1, u2)
subs_Coord_map = _clipper.subs_Coord_map

def product_Coord_map(s, u1):
    return _clipper.product_Coord_map(s, u1)
product_Coord_map = _clipper.product_Coord_map

class U_aniso_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, U_aniso_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, U_aniso_orth, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_U_aniso_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def u_iso(self):
        return _clipper.U_aniso_orth_u_iso(self)

    def u_aniso_frac(self, cell):
        return _clipper.U_aniso_orth_u_aniso_frac(self, cell)

    def transform(self, op):
        return _clipper.U_aniso_orth_transform(self, op)

    def __str__(self):
        return _clipper.U_aniso_orth___str__(self)
    __swig_destroy__ = _clipper.delete_U_aniso_orth
    __del__ = lambda self: None
U_aniso_orth_swigregister = _clipper.U_aniso_orth_swigregister
U_aniso_orth_swigregister(U_aniso_orth)

def add_U_aniso_orth(u1, u2):
    return _clipper.add_U_aniso_orth(u1, u2)
add_U_aniso_orth = _clipper.add_U_aniso_orth

def neg_U_aniso_orth(u):
    return _clipper.neg_U_aniso_orth(u)
neg_U_aniso_orth = _clipper.neg_U_aniso_orth

def product_U_aniso_orth(s, u):
    return _clipper.product_U_aniso_orth(s, u)
product_U_aniso_orth = _clipper.product_U_aniso_orth

class U_aniso_frac(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, U_aniso_frac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, U_aniso_frac, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_U_aniso_frac(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def u_aniso_orth(self, cell):
        return _clipper.U_aniso_frac_u_aniso_orth(self, cell)

    def transform(self, op):
        return _clipper.U_aniso_frac_transform(self, op)
    __swig_destroy__ = _clipper.delete_U_aniso_frac
    __del__ = lambda self: None
U_aniso_frac_swigregister = _clipper.U_aniso_frac_swigregister
U_aniso_frac_swigregister(U_aniso_frac)

def add_U_aniso_frac(u1, u2):
    return _clipper.add_U_aniso_frac(u1, u2)
add_U_aniso_frac = _clipper.add_U_aniso_frac

def neg_U_aniso_frac(u):
    return _clipper.neg_U_aniso_frac(u)
neg_U_aniso_frac = _clipper.neg_U_aniso_frac

def product_U_aniso_frac(s, u):
    return _clipper.product_U_aniso_frac(s, u)
product_U_aniso_frac = _clipper.product_U_aniso_frac

class Grid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Grid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Grid, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Grid(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def nu(self):
        return _clipper.Grid_nu(self)

    def nv(self):
        return _clipper.Grid_nv(self)

    def nw(self):
        return _clipper.Grid_nw(self)

    def size(self):
        return _clipper.Grid_size(self)

    def in_grid(self, g):
        return _clipper.Grid_in_grid(self, g)

    def index(self, c):
        return _clipper.Grid_index(self, c)

    def deindex(self, index):
        return _clipper.Grid_deindex(self, index)

    def format(self):
        return _clipper.Grid_format(self)

    def debug(self):
        return _clipper.Grid_debug(self)
    __swig_destroy__ = _clipper.delete_Grid
    __del__ = lambda self: None
Grid_swigregister = _clipper.Grid_swigregister
Grid_swigregister(Grid)

class Grid_sampling(Grid):
    __swig_setmethods__ = {}
    for _s in [Grid]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Grid_sampling, name, value)
    __swig_getmethods__ = {}
    for _s in [Grid]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Grid_sampling, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Grid_sampling(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell, resol, rate=1.5):
        return _clipper.Grid_sampling_init(self, spacegroup, cell, resol, rate)

    def matrix_grid_frac(self):
        return _clipper.Grid_sampling_matrix_grid_frac(self)

    def matrix_frac_grid(self):
        return _clipper.Grid_sampling_matrix_frac_grid(self)

    def is_null(self):
        return _clipper.Grid_sampling_is_null(self)
    __swig_destroy__ = _clipper.delete_Grid_sampling
    __del__ = lambda self: None
Grid_sampling_swigregister = _clipper.Grid_sampling_swigregister
Grid_sampling_swigregister(Grid_sampling)

class HKL_sampling(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_sampling, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_sampling, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_sampling(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def hkl_limit(self):
        return _clipper.HKL_sampling_hkl_limit(self)

    def resolution(self, cell):
        return _clipper.HKL_sampling_resolution(self, cell)

    def in_resolution(self, h):
        return _clipper.HKL_sampling_in_resolution(self, h)

    def is_null(self):
        return _clipper.HKL_sampling_is_null(self)

    def format(self):
        return _clipper.HKL_sampling_format(self)
    __swig_destroy__ = _clipper.delete_HKL_sampling
    __del__ = lambda self: None
HKL_sampling_swigregister = _clipper.HKL_sampling_swigregister
HKL_sampling_swigregister(HKL_sampling)

def equals_HKL_samp(h1, h2):
    return _clipper.equals_HKL_samp(h1, h2)
equals_HKL_samp = _clipper.equals_HKL_samp

class Grid_range(Grid):
    __swig_setmethods__ = {}
    for _s in [Grid]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Grid_range, name, value)
    __swig_getmethods__ = {}
    for _s in [Grid]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Grid_range, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Grid_range(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def min(self):
        return _clipper.Grid_range_min(self)

    def max(self):
        return _clipper.Grid_range_max(self)

    def add_border(self, b):
        return _clipper.Grid_range_add_border(self, b)

    def in_grid(self, g):
        return _clipper.Grid_range_in_grid(self, g)

    def index(self, c):
        return _clipper.Grid_range_index(self, c)

    def deindex(self, index):
        return _clipper.Grid_range_deindex(self, index)
    __swig_destroy__ = _clipper.delete_Grid_range
    __del__ = lambda self: None
Grid_range_swigregister = _clipper.Grid_range_swigregister
Grid_range_swigregister(Grid_range)

class Atom(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Atom, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_Atom()
        try:
            self.this.append(this)
        except:
            self.this = this

    def element(self):
        return _clipper.Atom_element(self)

    def coord_orth(self):
        return _clipper.Atom_coord_orth(self)

    def occupancy(self):
        return _clipper.Atom_occupancy(self)

    def u_iso(self):
        return _clipper.Atom_u_iso(self)

    def u_aniso_orth(self):
        return _clipper.Atom_u_aniso_orth(self)

    def set_element(self, s):
        return _clipper.Atom_set_element(self, s)

    def set_coord_orth(self, s):
        return _clipper.Atom_set_coord_orth(self, s)

    def set_occupancy(self, s):
        return _clipper.Atom_set_occupancy(self, s)

    def set_u_iso(self, s):
        return _clipper.Atom_set_u_iso(self, s)

    def set_u_aniso_orth(self, s):
        return _clipper.Atom_set_u_aniso_orth(self, s)

    def transform(self, rt):
        return _clipper.Atom_transform(self, rt)

    def is_null(self):
        return _clipper.Atom_is_null(self)
    __swig_getmethods__["null"] = lambda x: _clipper.Atom_null
    if _newclass:
        null = staticmethod(_clipper.Atom_null)
    __swig_destroy__ = _clipper.delete_Atom
    __del__ = lambda self: None
Atom_swigregister = _clipper.Atom_swigregister
Atom_swigregister(Atom)

def Atom_null():
    return _clipper.Atom_null()
Atom_null = _clipper.Atom_null

class Atom_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atom_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Atom_list, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Atom_list(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __getitem__(self, i):
        return _clipper.Atom_list___getitem__(self, i)

    def __setitem__(self, i, atom):
        return _clipper.Atom_list___setitem__(self, i, atom)

    def __len__(self):
        return _clipper.Atom_list___len__(self)
    __swig_destroy__ = _clipper.delete_Atom_list
    __del__ = lambda self: None
Atom_list_swigregister = _clipper.Atom_list_swigregister
Atom_list_swigregister(Atom_list)

class HKL_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_info, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_info(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_info_init(self, *args)

    def is_null(self):
        return _clipper.HKL_info_is_null(self)

    def cell(self):
        return _clipper.HKL_info_cell(self)

    def spacegroup(self):
        return _clipper.HKL_info_spacegroup(self)

    def hkl_sampling(self):
        return _clipper.HKL_info_hkl_sampling(self)

    def resolution(self):
        return _clipper.HKL_info_resolution(self)

    def generate_hkl_list(self):
        return _clipper.HKL_info_generate_hkl_list(self)

    def add_hkl_list(self, add):
        return _clipper.HKL_info_add_hkl_list(self, add)

    def num_reflections(self):
        return _clipper.HKL_info_num_reflections(self)

    def hkl_of(self, index):
        return _clipper.HKL_info_hkl_of(self, index)

    def index_of(self, rfl):
        return _clipper.HKL_info_index_of(self, rfl)

    def invresolsq(self, index):
        return _clipper.HKL_info_invresolsq(self, index)

    def invresolsq_range(self):
        return _clipper.HKL_info_invresolsq_range(self)

    def hkl_class(self, index):
        return _clipper.HKL_info_hkl_class(self, index)

    def find_sym(self, rfl, sym, friedel):
        return _clipper.HKL_info_find_sym(self, rfl, sym, friedel)

    def first(self):
        return _clipper.HKL_info_first(self)

    def debug(self):
        return _clipper.HKL_info_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_info
    __del__ = lambda self: None
HKL_info_swigregister = _clipper.HKL_info_swigregister
HKL_info_swigregister(HKL_info)

class HKL_data_cacheobj(HKL_info):
    __swig_setmethods__ = {}
    for _s in [HKL_info]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_cacheobj, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_info]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_cacheobj, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data_cachekey):
        this = _clipper.new_HKL_data_cacheobj(hkl_data_cachekey)
        try:
            self.this.append(this)
        except:
            self.this = this

    def matches(self, hkl_data_cachekey):
        return _clipper.HKL_data_cacheobj_matches(self, hkl_data_cachekey)

    def format(self):
        return _clipper.HKL_data_cacheobj_format(self)
    __swig_setmethods__["mutex"] = _clipper.HKL_data_cacheobj_mutex_set
    __swig_getmethods__["mutex"] = _clipper.HKL_data_cacheobj_mutex_get
    if _newclass:
        mutex = _swig_property(_clipper.HKL_data_cacheobj_mutex_get, _clipper.HKL_data_cacheobj_mutex_set)
    __swig_destroy__ = _clipper.delete_HKL_data_cacheobj
    __del__ = lambda self: None
HKL_data_cacheobj_swigregister = _clipper.HKL_data_cacheobj_swigregister
HKL_data_cacheobj_swigregister(HKL_data_cacheobj)

class Datatype_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Datatype_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Datatype_base, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_Datatype_base()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Datatype_base
    __del__ = lambda self: None
Datatype_base_swigregister = _clipper.Datatype_base_swigregister
Datatype_base_swigregister(Datatype_base)

class HKL_data_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_base, name)
    __repr__ = _swig_repr

    def init(self, *args):
        return _clipper.HKL_data_base_init(self, *args)

    def is_null(self):
        return _clipper.HKL_data_base_is_null(self)

    def base_hkl_info(self):
        return _clipper.HKL_data_base_base_hkl_info(self)

    def base_cell(self):
        return _clipper.HKL_data_base_base_cell(self)

    def spacegroup(self):
        return _clipper.HKL_data_base_spacegroup(self)

    def cell(self):
        return _clipper.HKL_data_base_cell(self)

    def resolution(self):
        return _clipper.HKL_data_base_resolution(self)

    def hkl_sampling(self):
        return _clipper.HKL_data_base_hkl_sampling(self)

    def hkl_info(self):
        return _clipper.HKL_data_base_hkl_info(self)

    def invresolsq(self, index):
        return _clipper.HKL_data_base_invresolsq(self, index)

    def invresolsq_range(self):
        return _clipper.HKL_data_base_invresolsq_range(self)

    def num_obs(self):
        return _clipper.HKL_data_base_num_obs(self)

    def update(self):
        return _clipper.HKL_data_base_update(self)

    def type(self):
        return _clipper.HKL_data_base_type(self)

    def missing(self, index):
        return _clipper.HKL_data_base_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_base_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_base_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_base_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_base_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_base_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_base_mask(self, mask)

    def first(self):
        return _clipper.HKL_data_base_first(self)

    def first_data(self):
        return _clipper.HKL_data_base_first_data(self)

    def next_data(self, ih):
        return _clipper.HKL_data_base_next_data(self, ih)

    def debug(self):
        return _clipper.HKL_data_base_debug(self)

    def __init__(self):
        if self.__class__ == HKL_data_base:
            _self = None
        else:
            _self = self
        this = _clipper.new_HKL_data_base(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_HKL_data_base(self)
        return weakref_proxy(self)
HKL_data_base_swigregister = _clipper.HKL_data_base_swigregister
HKL_data_base_swigregister(HKL_data_base)

class HKL_reference_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_reference_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_reference_base, name)
    __repr__ = _swig_repr

    def base_hkl_info(self):
        return _clipper.HKL_reference_base_base_hkl_info(self)

    def index(self):
        return _clipper.HKL_reference_base_index(self)

    def invresolsq(self, *args):
        return _clipper.HKL_reference_base_invresolsq(self, *args)

    def last(self):
        return _clipper.HKL_reference_base_last(self)

    def __init__(self):
        this = _clipper.new_HKL_reference_base()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_HKL_reference_base
    __del__ = lambda self: None
HKL_reference_base_swigregister = _clipper.HKL_reference_base_swigregister
HKL_reference_base_swigregister(HKL_reference_base)

class HKL_reference_index(HKL_reference_base):
    __swig_setmethods__ = {}
    for _s in [HKL_reference_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_reference_index, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_reference_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_reference_index, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_reference_index(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def hkl(self):
        return _clipper.HKL_reference_index_hkl(self)

    def hkl_class(self):
        return _clipper.HKL_reference_index_hkl_class(self)

    def next(self):
        return _clipper.HKL_reference_index_next(self)
    __swig_destroy__ = _clipper.delete_HKL_reference_index
    __del__ = lambda self: None
HKL_reference_index_swigregister = _clipper.HKL_reference_index_swigregister
HKL_reference_index_swigregister(HKL_reference_index)

class Xmap_cacheobj(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Xmap_cacheobj, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Xmap_cacheobj, name)
    __repr__ = _swig_repr

    def __init__(self, xmap_cachekey):
        this = _clipper.new_Xmap_cacheobj(xmap_cachekey)
        try:
            self.this.append(this)
        except:
            self.this = this

    def matches(self, xmap_cachekey):
        return _clipper.Xmap_cacheobj_matches(self, xmap_cachekey)

    def format(self):
        return _clipper.Xmap_cacheobj_format(self)
    __swig_setmethods__["key"] = _clipper.Xmap_cacheobj_key_set
    __swig_getmethods__["key"] = _clipper.Xmap_cacheobj_key_get
    if _newclass:
        key = _swig_property(_clipper.Xmap_cacheobj_key_get, _clipper.Xmap_cacheobj_key_set)
    __swig_setmethods__["xtl_grid"] = _clipper.Xmap_cacheobj_xtl_grid_set
    __swig_getmethods__["xtl_grid"] = _clipper.Xmap_cacheobj_xtl_grid_get
    if _newclass:
        xtl_grid = _swig_property(_clipper.Xmap_cacheobj_xtl_grid_get, _clipper.Xmap_cacheobj_xtl_grid_set)
    __swig_setmethods__["asu_grid"] = _clipper.Xmap_cacheobj_asu_grid_set
    __swig_getmethods__["asu_grid"] = _clipper.Xmap_cacheobj_asu_grid_get
    if _newclass:
        asu_grid = _swig_property(_clipper.Xmap_cacheobj_asu_grid_get, _clipper.Xmap_cacheobj_asu_grid_set)
    __swig_setmethods__["map_grid"] = _clipper.Xmap_cacheobj_map_grid_set
    __swig_getmethods__["map_grid"] = _clipper.Xmap_cacheobj_map_grid_get
    if _newclass:
        map_grid = _swig_property(_clipper.Xmap_cacheobj_map_grid_get, _clipper.Xmap_cacheobj_map_grid_set)
    __swig_setmethods__["nsym"] = _clipper.Xmap_cacheobj_nsym_set
    __swig_getmethods__["nsym"] = _clipper.Xmap_cacheobj_nsym_get
    if _newclass:
        nsym = _swig_property(_clipper.Xmap_cacheobj_nsym_get, _clipper.Xmap_cacheobj_nsym_set)
    __swig_setmethods__["asu"] = _clipper.Xmap_cacheobj_asu_set
    __swig_getmethods__["asu"] = _clipper.Xmap_cacheobj_asu_get
    if _newclass:
        asu = _swig_property(_clipper.Xmap_cacheobj_asu_get, _clipper.Xmap_cacheobj_asu_set)
    __swig_setmethods__["isymop"] = _clipper.Xmap_cacheobj_isymop_set
    __swig_getmethods__["isymop"] = _clipper.Xmap_cacheobj_isymop_get
    if _newclass:
        isymop = _swig_property(_clipper.Xmap_cacheobj_isymop_get, _clipper.Xmap_cacheobj_isymop_set)
    __swig_setmethods__["du"] = _clipper.Xmap_cacheobj_du_set
    __swig_getmethods__["du"] = _clipper.Xmap_cacheobj_du_get
    if _newclass:
        du = _swig_property(_clipper.Xmap_cacheobj_du_get, _clipper.Xmap_cacheobj_du_set)
    __swig_setmethods__["dv"] = _clipper.Xmap_cacheobj_dv_set
    __swig_getmethods__["dv"] = _clipper.Xmap_cacheobj_dv_get
    if _newclass:
        dv = _swig_property(_clipper.Xmap_cacheobj_dv_get, _clipper.Xmap_cacheobj_dv_set)
    __swig_setmethods__["dw"] = _clipper.Xmap_cacheobj_dw_set
    __swig_getmethods__["dw"] = _clipper.Xmap_cacheobj_dw_get
    if _newclass:
        dw = _swig_property(_clipper.Xmap_cacheobj_dw_get, _clipper.Xmap_cacheobj_dw_set)
    __swig_setmethods__["symperm"] = _clipper.Xmap_cacheobj_symperm_set
    __swig_getmethods__["symperm"] = _clipper.Xmap_cacheobj_symperm_get
    if _newclass:
        symperm = _swig_property(_clipper.Xmap_cacheobj_symperm_get, _clipper.Xmap_cacheobj_symperm_set)
    __swig_setmethods__["mat_grid_orth"] = _clipper.Xmap_cacheobj_mat_grid_orth_set
    __swig_getmethods__["mat_grid_orth"] = _clipper.Xmap_cacheobj_mat_grid_orth_get
    if _newclass:
        mat_grid_orth = _swig_property(_clipper.Xmap_cacheobj_mat_grid_orth_get, _clipper.Xmap_cacheobj_mat_grid_orth_set)
    __swig_setmethods__["mutex"] = _clipper.Xmap_cacheobj_mutex_set
    __swig_getmethods__["mutex"] = _clipper.Xmap_cacheobj_mutex_get
    if _newclass:
        mutex = _swig_property(_clipper.Xmap_cacheobj_mutex_get, _clipper.Xmap_cacheobj_mutex_set)
    __swig_destroy__ = _clipper.delete_Xmap_cacheobj
    __del__ = lambda self: None
Xmap_cacheobj_swigregister = _clipper.Xmap_cacheobj_swigregister
Xmap_cacheobj_swigregister(Xmap_cacheobj)

class Xmap_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Xmap_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Xmap_base, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Default = _clipper.Xmap_base_Default
    Normal = _clipper.Xmap_base_Normal
    Sparse = _clipper.Xmap_base_Sparse

    def is_null(self):
        return _clipper.Xmap_base_is_null(self)

    def cell(self):
        return _clipper.Xmap_base_cell(self)

    def spacegroup(self):
        return _clipper.Xmap_base_spacegroup(self)

    def grid_sampling(self):
        return _clipper.Xmap_base_grid_sampling(self)

    def grid_asu(self):
        return _clipper.Xmap_base_grid_asu(self)

    def coord_of(self, index):
        return _clipper.Xmap_base_coord_of(self, index)

    def index_of(self, coord):
        return _clipper.Xmap_base_index_of(self, coord)

    def to_map_unit(self, pos):
        return _clipper.Xmap_base_to_map_unit(self, pos)

    def operator_orth_grid(self):
        return _clipper.Xmap_base_operator_orth_grid(self)

    def operator_grid_orth(self):
        return _clipper.Xmap_base_operator_grid_orth(self)

    def coord_orth(self, cm):
        return _clipper.Xmap_base_coord_orth(self, cm)

    def coord_map(self, co):
        return _clipper.Xmap_base_coord_map(self, co)

    def in_map(self, arg2):
        return _clipper.Xmap_base_in_map(self, arg2)

    def multiplicity(self, pos):
        return _clipper.Xmap_base_multiplicity(self, pos)

    def first(self):
        return _clipper.Xmap_base_first(self)

    def first_coord(self):
        return _clipper.Xmap_base_first_coord(self)
    __swig_getmethods__["default_type"] = lambda x: _clipper.Xmap_base_default_type
    if _newclass:
        default_type = staticmethod(_clipper.Xmap_base_default_type)
    __swig_destroy__ = _clipper.delete_Xmap_base
    __del__ = lambda self: None
Xmap_base_swigregister = _clipper.Xmap_base_swigregister
Xmap_base_swigregister(Xmap_base)

def Xmap_base_default_type():
    return _clipper.Xmap_base_default_type()
Xmap_base_default_type = _clipper.Xmap_base_default_type

class NXmap_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NXmap_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NXmap_base, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def is_null(self):
        return _clipper.NXmap_base_is_null(self)

    def grid(self):
        return _clipper.NXmap_base_grid(self)

    def operator_orth_grid(self):
        return _clipper.NXmap_base_operator_orth_grid(self)

    def operator_grid_orth(self):
        return _clipper.NXmap_base_operator_grid_orth(self)

    def coord_orth(self, cm):
        return _clipper.NXmap_base_coord_orth(self, cm)

    def coord_map(self, co):
        return _clipper.NXmap_base_coord_map(self, co)

    def in_map(self, pos):
        return _clipper.NXmap_base_in_map(self, pos)

    def multiplicity(self, arg2):
        return _clipper.NXmap_base_multiplicity(self, arg2)

    def first(self):
        return _clipper.NXmap_base_first(self)

    def first_coord(self):
        return _clipper.NXmap_base_first_coord(self)
    __swig_destroy__ = _clipper.delete_NXmap_base
    __del__ = lambda self: None
NXmap_base_swigregister = _clipper.NXmap_base_swigregister
NXmap_base_swigregister(NXmap_base)

class Xmap_float(Xmap_base):
    __swig_setmethods__ = {}
    for _s in [Xmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Xmap_float, name, value)
    __swig_getmethods__ = {}
    for _s in [Xmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Xmap_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Xmap_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell, grid_sam):
        return _clipper.Xmap_float_init(self, spacegroup, cell, grid_sam)

    def get_data(self, *args):
        return _clipper.Xmap_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.Xmap_float_set_data(self, *args)

    def __iadd__(self, other):
        return _clipper.Xmap_float___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.Xmap_float___isub__(self, other)

    def fft_from_float(self, fb):
        return _clipper.Xmap_float_fft_from_float(self, fb)
    __swig_destroy__ = _clipper.delete_Xmap_float
    __del__ = lambda self: None
Xmap_float_swigregister = _clipper.Xmap_float_swigregister
Xmap_float_swigregister(Xmap_float)

class Xmap_double(Xmap_base):
    __swig_setmethods__ = {}
    for _s in [Xmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Xmap_double, name, value)
    __swig_getmethods__ = {}
    for _s in [Xmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Xmap_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Xmap_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell, grid_sam):
        return _clipper.Xmap_double_init(self, spacegroup, cell, grid_sam)

    def get_data(self, *args):
        return _clipper.Xmap_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.Xmap_double_set_data(self, *args)

    def __iadd__(self, other):
        return _clipper.Xmap_double___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.Xmap_double___isub__(self, other)

    def fft_from_double(self, fb):
        return _clipper.Xmap_double_fft_from_double(self, fb)
    __swig_destroy__ = _clipper.delete_Xmap_double
    __del__ = lambda self: None
Xmap_double_swigregister = _clipper.Xmap_double_swigregister
Xmap_double_swigregister(Xmap_double)

class Xmap_int(Xmap_base):
    __swig_setmethods__ = {}
    for _s in [Xmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Xmap_int, name, value)
    __swig_getmethods__ = {}
    for _s in [Xmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Xmap_int, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Xmap_int(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell, grid_sam):
        return _clipper.Xmap_int_init(self, spacegroup, cell, grid_sam)

    def get_data(self, *args):
        return _clipper.Xmap_int_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.Xmap_int_set_data(self, *args)

    def __iadd__(self, other):
        return _clipper.Xmap_int___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.Xmap_int___isub__(self, other)
    __swig_destroy__ = _clipper.delete_Xmap_int
    __del__ = lambda self: None
Xmap_int_swigregister = _clipper.Xmap_int_swigregister
Xmap_int_swigregister(Xmap_int)

class NXmap_float(NXmap_base):
    __swig_setmethods__ = {}
    for _s in [NXmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NXmap_float, name, value)
    __swig_getmethods__ = {}
    for _s in [NXmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NXmap_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_NXmap_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.NXmap_float_init(self, *args)

    def get_data(self, pos):
        return _clipper.NXmap_float_get_data(self, pos)

    def set_data(self, pos, val):
        return _clipper.NXmap_float_set_data(self, pos, val)

    def __iadd__(self, other):
        return _clipper.NXmap_float___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.NXmap_float___isub__(self, other)
    __swig_destroy__ = _clipper.delete_NXmap_float
    __del__ = lambda self: None
NXmap_float_swigregister = _clipper.NXmap_float_swigregister
NXmap_float_swigregister(NXmap_float)

class NXmap_double(NXmap_base):
    __swig_setmethods__ = {}
    for _s in [NXmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NXmap_double, name, value)
    __swig_getmethods__ = {}
    for _s in [NXmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NXmap_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_NXmap_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.NXmap_double_init(self, *args)

    def get_data(self, pos):
        return _clipper.NXmap_double_get_data(self, pos)

    def set_data(self, pos, val):
        return _clipper.NXmap_double_set_data(self, pos, val)

    def __iadd__(self, other):
        return _clipper.NXmap_double___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.NXmap_double___isub__(self, other)
    __swig_destroy__ = _clipper.delete_NXmap_double
    __del__ = lambda self: None
NXmap_double_swigregister = _clipper.NXmap_double_swigregister
NXmap_double_swigregister(NXmap_double)

class NXmap_int(NXmap_base):
    __swig_setmethods__ = {}
    for _s in [NXmap_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NXmap_int, name, value)
    __swig_getmethods__ = {}
    for _s in [NXmap_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NXmap_int, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_NXmap_int(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.NXmap_int_init(self, *args)

    def get_data(self, pos):
        return _clipper.NXmap_int_get_data(self, pos)

    def set_data(self, pos, val):
        return _clipper.NXmap_int_set_data(self, pos, val)

    def __iadd__(self, other):
        return _clipper.NXmap_int___iadd__(self, other)

    def __isub__(self, other):
        return _clipper.NXmap_int___isub__(self, other)
    __swig_destroy__ = _clipper.delete_NXmap_int
    __del__ = lambda self: None
NXmap_int_swigregister = _clipper.NXmap_int_swigregister
NXmap_int_swigregister(NXmap_int)

class CCP4MAPfile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4MAPfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4MAPfile, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_CCP4MAPfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CCP4MAPfile
    __del__ = lambda self: None

    def open_read(self, filename_in):
        return _clipper.CCP4MAPfile_open_read(self, filename_in)

    def close_read(self):
        return _clipper.CCP4MAPfile_close_read(self)

    def open_write(self, filename_out):
        return _clipper.CCP4MAPfile_open_write(self, filename_out)

    def close_write(self):
        return _clipper.CCP4MAPfile_close_write(self)

    def set_cell(self, cell):
        return _clipper.CCP4MAPfile_set_cell(self, cell)

    def spacegroup(self):
        return _clipper.CCP4MAPfile_spacegroup(self)

    def cell(self):
        return _clipper.CCP4MAPfile_cell(self)

    def grid_sampling(self):
        return _clipper.CCP4MAPfile_grid_sampling(self)
    ASUCORRECT = _clipper.CCP4MAPfile_ASUCORRECT
    ASUINCOMPLETE = _clipper.CCP4MAPfile_ASUINCOMPLETE
    ASUINCONSISTENT = _clipper.CCP4MAPfile_ASUINCONSISTENT

    def import_xmap_float(self, xmap):
        return _clipper.CCP4MAPfile_import_xmap_float(self, xmap)

    def import_xmap_double(self, xmap):
        return _clipper.CCP4MAPfile_import_xmap_double(self, xmap)

    def export_xmap_float(self, xmap):
        return _clipper.CCP4MAPfile_export_xmap_float(self, xmap)

    def export_xmap_double(self, xmap):
        return _clipper.CCP4MAPfile_export_xmap_double(self, xmap)

    def import_nxmap_float(self, nxmap):
        return _clipper.CCP4MAPfile_import_nxmap_float(self, nxmap)

    def import_nxmap_double(self, nxmap):
        return _clipper.CCP4MAPfile_import_nxmap_double(self, nxmap)

    def export_nxmap_float(self, nxmap):
        return _clipper.CCP4MAPfile_export_nxmap_float(self, nxmap)

    def export_nxmap_double(self, nxmap):
        return _clipper.CCP4MAPfile_export_nxmap_double(self, nxmap)
CCP4MAPfile_swigregister = _clipper.CCP4MAPfile_swigregister
CCP4MAPfile_swigregister(CCP4MAPfile)

class MTZcrystal(Cell):
    __swig_setmethods__ = {}
    for _s in [Cell]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MTZcrystal, name, value)
    __swig_getmethods__ = {}
    for _s in [Cell]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MTZcrystal, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MTZcrystal(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def crystal_name(self):
        return _clipper.MTZcrystal_crystal_name(self)

    def project_name(self):
        return _clipper.MTZcrystal_project_name(self)
    __swig_destroy__ = _clipper.delete_MTZcrystal
    __del__ = lambda self: None
MTZcrystal_swigregister = _clipper.MTZcrystal_swigregister
MTZcrystal_swigregister(MTZcrystal)

class MTZdataset(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MTZdataset, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MTZdataset, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MTZdataset(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def dataset_name(self):
        return _clipper.MTZdataset_dataset_name(self)

    def wavelength(self):
        return _clipper.MTZdataset_wavelength(self)
    __swig_destroy__ = _clipper.delete_MTZdataset
    __del__ = lambda self: None
MTZdataset_swigregister = _clipper.MTZdataset_swigregister
MTZdataset_swigregister(MTZdataset)

class CMTZcrystal(MTZcrystal):
    __swig_setmethods__ = {}
    for _s in [MTZcrystal]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMTZcrystal, name, value)
    __swig_getmethods__ = {}
    for _s in [MTZcrystal]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CMTZcrystal, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_CMTZcrystal(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CMTZcrystal
    __del__ = lambda self: None
CMTZcrystal_swigregister = _clipper.CMTZcrystal_swigregister
CMTZcrystal_swigregister(CMTZcrystal)

class CMTZdataset(MTZdataset):
    __swig_setmethods__ = {}
    for _s in [MTZdataset]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMTZdataset, name, value)
    __swig_getmethods__ = {}
    for _s in [MTZdataset]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CMTZdataset, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_CMTZdataset(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CMTZdataset
    __del__ = lambda self: None
CMTZdataset_swigregister = _clipper.CMTZdataset_swigregister
CMTZdataset_swigregister(CMTZdataset)

class CCP4MTZ_type_registry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4MTZ_type_registry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4MTZ_type_registry, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_CCP4MTZ_type_registry()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_getmethods__["add_type"] = lambda x: _clipper.CCP4MTZ_type_registry_add_type
    if _newclass:
        add_type = staticmethod(_clipper.CCP4MTZ_type_registry_add_type)
    __swig_getmethods__["type"] = lambda x: _clipper.CCP4MTZ_type_registry_type
    if _newclass:
        type = staticmethod(_clipper.CCP4MTZ_type_registry_type)
    __swig_getmethods__["scale"] = lambda x: _clipper.CCP4MTZ_type_registry_scale
    if _newclass:
        scale = staticmethod(_clipper.CCP4MTZ_type_registry_scale)
    __swig_getmethods__["add_group"] = lambda x: _clipper.CCP4MTZ_type_registry_add_group
    if _newclass:
        add_group = staticmethod(_clipper.CCP4MTZ_type_registry_add_group)
    __swig_getmethods__["group_type"] = lambda x: _clipper.CCP4MTZ_type_registry_group_type
    if _newclass:
        group_type = staticmethod(_clipper.CCP4MTZ_type_registry_group_type)
    __swig_destroy__ = _clipper.delete_CCP4MTZ_type_registry
    __del__ = lambda self: None
CCP4MTZ_type_registry_swigregister = _clipper.CCP4MTZ_type_registry_swigregister
CCP4MTZ_type_registry_swigregister(CCP4MTZ_type_registry)

def CCP4MTZ_type_registry_add_type(name, type, scale):
    return _clipper.CCP4MTZ_type_registry_add_type(name, type, scale)
CCP4MTZ_type_registry_add_type = _clipper.CCP4MTZ_type_registry_add_type

def CCP4MTZ_type_registry_type(name):
    return _clipper.CCP4MTZ_type_registry_type(name)
CCP4MTZ_type_registry_type = _clipper.CCP4MTZ_type_registry_type

def CCP4MTZ_type_registry_scale(name):
    return _clipper.CCP4MTZ_type_registry_scale(name)
CCP4MTZ_type_registry_scale = _clipper.CCP4MTZ_type_registry_scale

def CCP4MTZ_type_registry_add_group(name, type):
    return _clipper.CCP4MTZ_type_registry_add_group(name, type)
CCP4MTZ_type_registry_add_group = _clipper.CCP4MTZ_type_registry_add_group

def CCP4MTZ_type_registry_group_type(name):
    return _clipper.CCP4MTZ_type_registry_group_type(name)
CCP4MTZ_type_registry_group_type = _clipper.CCP4MTZ_type_registry_group_type

class CCP4MTZfile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4MTZfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4MTZfile, name)
    __repr__ = _swig_repr
    Default = _clipper.CCP4MTZfile_Default
    Normal = _clipper.CCP4MTZfile_Normal
    Legacy = _clipper.CCP4MTZfile_Legacy

    def __init__(self):
        this = _clipper.new_CCP4MTZfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CCP4MTZfile
    __del__ = lambda self: None

    def open_read(self, filename_in):
        return _clipper.CCP4MTZfile_open_read(self, filename_in)

    def close_read(self):
        return _clipper.CCP4MTZfile_close_read(self)

    def open_append(self, filename_in, filename_out):
        return _clipper.CCP4MTZfile_open_append(self, filename_in, filename_out)

    def close_append(self):
        return _clipper.CCP4MTZfile_close_append(self)

    def open_write(self, filename_out):
        return _clipper.CCP4MTZfile_open_write(self, filename_out)

    def close_write(self):
        return _clipper.CCP4MTZfile_close_write(self)

    def spacegroup(self):
        return _clipper.CCP4MTZfile_spacegroup(self)

    def cell(self):
        return _clipper.CCP4MTZfile_cell(self)

    def resolution(self):
        return _clipper.CCP4MTZfile_resolution(self)

    def hkl_sampling(self):
        return _clipper.CCP4MTZfile_hkl_sampling(self)

    def import_hkl_list(self, target):
        return _clipper.CCP4MTZfile_import_hkl_list(self, target)

    def import_hkl_info(self, target, generate=True):
        return _clipper.CCP4MTZfile_import_hkl_info(self, target, generate)

    def import_crystal(self, cxtl, mtzpath):
        return _clipper.CCP4MTZfile_import_crystal(self, cxtl, mtzpath)

    def import_dataset(self, cset, mtzpath):
        return _clipper.CCP4MTZfile_import_dataset(self, cset, mtzpath)

    def export_hkl_info(self, target):
        return _clipper.CCP4MTZfile_export_hkl_info(self, target)

    def export_crystal(self, cxtl, mtzpath):
        return _clipper.CCP4MTZfile_export_crystal(self, cxtl, mtzpath)

    def export_dataset(self, cset, mtzpath):
        return _clipper.CCP4MTZfile_export_dataset(self, cset, mtzpath)

    def import_chkl_data(self, *args):
        return _clipper.CCP4MTZfile_import_chkl_data(self, *args)

    def export_chkl_data(self, target, mtzpath):
        return _clipper.CCP4MTZfile_export_chkl_data(self, target, mtzpath)

    def column_paths(self):
        return _clipper.CCP4MTZfile_column_paths(self)

    def title(self):
        return _clipper.CCP4MTZfile_title(self)

    def set_title(self, title):
        return _clipper.CCP4MTZfile_set_title(self, title)

    def history(self):
        return _clipper.CCP4MTZfile_history(self)

    def set_history(self, history):
        return _clipper.CCP4MTZfile_set_history(self, history)

    def num_reflections(self):
        return _clipper.CCP4MTZfile_num_reflections(self)

    def sort_order(self):
        return _clipper.CCP4MTZfile_sort_order(self)

    def low_res_limit(self):
        return _clipper.CCP4MTZfile_low_res_limit(self)

    def high_res_limit(self):
        return _clipper.CCP4MTZfile_high_res_limit(self)

    def ccp4_spacegroup_number(self):
        return _clipper.CCP4MTZfile_ccp4_spacegroup_number(self)

    def spacegroup_confidence(self):
        return _clipper.CCP4MTZfile_spacegroup_confidence(self)

    def set_spacegroup_confidence(self, spg_confidence):
        return _clipper.CCP4MTZfile_set_spacegroup_confidence(self, spg_confidence)

    def set_column_label_mode(self, mode):
        return _clipper.CCP4MTZfile_set_column_label_mode(self, mode)

    def set_verbose(self, verbose):
        return _clipper.CCP4MTZfile_set_verbose(self, verbose)

    def column_labels(self):
        return _clipper.CCP4MTZfile_column_labels(self)

    def import_hkl_data(self, *args):
        return _clipper.CCP4MTZfile_import_hkl_data(self, *args)

    def export_hkl_data(self, *args):
        return _clipper.CCP4MTZfile_export_hkl_data(self, *args)
CCP4MTZfile_swigregister = _clipper.CCP4MTZfile_swigregister
CCP4MTZfile_swigregister(CCP4MTZfile)

class CCP4CommandInput(StringVector):
    __swig_setmethods__ = {}
    for _s in [StringVector]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4CommandInput, name, value)
    __swig_getmethods__ = {}
    for _s in [StringVector]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4CommandInput, name)
    __repr__ = _swig_repr

    def __init__(self, argc, argv, echo=False):
        this = _clipper.new_CCP4CommandInput(argc, argv, echo)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CCP4CommandInput
    __del__ = lambda self: None
CCP4CommandInput_swigregister = _clipper.CCP4CommandInput_swigregister
CCP4CommandInput_swigregister(CCP4CommandInput)

class CCP4Program(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CCP4Program, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CCP4Program, name)
    __repr__ = _swig_repr

    def __init__(self, name, vers, rcsdate):
        this = _clipper.new_CCP4Program(name, vers, rcsdate)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CCP4Program
    __del__ = lambda self: None

    def summary_beg(self):
        return _clipper.CCP4Program_summary_beg(self)

    def summary_end(self):
        return _clipper.CCP4Program_summary_end(self)

    def set_termination_message(self, msg):
        return _clipper.CCP4Program_set_termination_message(self, msg)
CCP4Program_swigregister = _clipper.CCP4Program_swigregister
CCP4Program_swigregister(CCP4Program)

class Range_sampling(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Range_sampling, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Range_sampling, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Range_sampling(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def indexf(self, x):
        return _clipper.Range_sampling_indexf(self, x)

    def index(self, x):
        return _clipper.Range_sampling_index(self, x)

    def index_bounded(self, x):
        return _clipper.Range_sampling_index_bounded(self, x)

    def x(self, *args):
        return _clipper.Range_sampling_x(self, *args)

    def x_min(self, i):
        return _clipper.Range_sampling_x_min(self, i)

    def x_max(self, i):
        return _clipper.Range_sampling_x_max(self, i)

    def size(self):
        return _clipper.Range_sampling_size(self)
    __swig_destroy__ = _clipper.delete_Range_sampling
    __del__ = lambda self: None
Range_sampling_swigregister = _clipper.Range_sampling_swigregister
Range_sampling_swigregister(Range_sampling)

class Histogram(Range_sampling):
    __swig_setmethods__ = {}
    for _s in [Range_sampling]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Histogram, name, value)
    __swig_getmethods__ = {}
    for _s in [Range_sampling]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Histogram, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Histogram(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def accumulate(self, *args):
        return _clipper.Histogram_accumulate(self, *args)

    def sum(self):
        return _clipper.Histogram_sum(self)

    def y(self, *args):
        return _clipper.Histogram_y(self, *args)

    def __iadd__(self, h):
        return _clipper.Histogram___iadd__(self, h)
    __swig_destroy__ = _clipper.delete_Histogram
    __del__ = lambda self: None
Histogram_swigregister = _clipper.Histogram_swigregister
Histogram_swigregister(Histogram)

class Generic_ordinal(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Generic_ordinal, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Generic_ordinal, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Generic_ordinal(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ordinal(self, value):
        return _clipper.Generic_ordinal_ordinal(self, value)

    def accumulate(self, *args):
        return _clipper.Generic_ordinal_accumulate(self, *args)

    def prep_ordinal(self):
        return _clipper.Generic_ordinal_prep_ordinal(self)

    def invert(self):
        return _clipper.Generic_ordinal_invert(self)

    def init(self, *args):
        return _clipper.Generic_ordinal_init(self, *args)

    def add_pass_1(self, value):
        return _clipper.Generic_ordinal_add_pass_1(self, value)

    def add_pass_2(self, value):
        return _clipper.Generic_ordinal_add_pass_2(self, value)
    __swig_destroy__ = _clipper.delete_Generic_ordinal
    __del__ = lambda self: None
Generic_ordinal_swigregister = _clipper.Generic_ordinal_swigregister
Generic_ordinal_swigregister(Generic_ordinal)

class Range_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Range_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Range_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Range_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def min(self):
        return _clipper.Range_float_min(self)

    def max(self):
        return _clipper.Range_float_max(self)

    def range(self):
        return _clipper.Range_float_range(self)

    def include(self, datum):
        return _clipper.Range_float_include(self, datum)

    def contains(self, datum):
        return _clipper.Range_float_contains(self, datum)

    def truncate(self, datum):
        return _clipper.Range_float_truncate(self, datum)
    __swig_destroy__ = _clipper.delete_Range_float
    __del__ = lambda self: None
Range_float_swigregister = _clipper.Range_float_swigregister
Range_float_swigregister(Range_float)

class Range_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Range_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Range_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Range_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def min(self):
        return _clipper.Range_double_min(self)

    def max(self):
        return _clipper.Range_double_max(self)

    def range(self):
        return _clipper.Range_double_range(self)

    def include(self, datum):
        return _clipper.Range_double_include(self, datum)

    def contains(self, datum):
        return _clipper.Range_double_contains(self, datum)

    def truncate(self, datum):
        return _clipper.Range_double_truncate(self, datum)
    __swig_destroy__ = _clipper.delete_Range_double
    __del__ = lambda self: None
Range_double_swigregister = _clipper.Range_double_swigregister
Range_double_swigregister(Range_double)

class Map_stats(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_stats, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_stats, name)
    __repr__ = _swig_repr

    def mean(self):
        return _clipper.Map_stats_mean(self)

    def std_dev(self):
        return _clipper.Map_stats_std_dev(self)

    def min(self):
        return _clipper.Map_stats_min(self)

    def max(self):
        return _clipper.Map_stats_max(self)

    def range(self):
        return _clipper.Map_stats_range(self)

    def __init__(self, *args):
        this = _clipper.new_Map_stats(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def range_double(self):
        return _clipper.Map_stats_range_double(self)

    def range_float(self):
        return _clipper.Map_stats_range_float(self)
    __swig_destroy__ = _clipper.delete_Map_stats
    __del__ = lambda self: None
Map_stats_swigregister = _clipper.Map_stats_swigregister
Map_stats_swigregister(Map_stats)

class Map_index_sort(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map_index_sort, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Map_index_sort, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_Map_index_sort()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Map_index_sort
    __del__ = lambda self: None
Map_index_sort_swigregister = _clipper.Map_index_sort_swigregister
Map_index_sort_swigregister(Map_index_sort)

class Sig_Coord_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sig_Coord_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Sig_Coord_orth, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Sig_Coord_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def sigx(self):
        return _clipper.Sig_Coord_orth_sigx(self)

    def sigy(self):
        return _clipper.Sig_Coord_orth_sigy(self)

    def sigz(self):
        return _clipper.Sig_Coord_orth_sigz(self)
    __swig_destroy__ = _clipper.delete_Sig_Coord_orth
    __del__ = lambda self: None
Sig_Coord_orth_swigregister = _clipper.Sig_Coord_orth_swigregister
Sig_Coord_orth_swigregister(Sig_Coord_orth)

class Sig_U_aniso_orth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sig_U_aniso_orth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Sig_U_aniso_orth, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Sig_U_aniso_orth(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Sig_U_aniso_orth
    __del__ = lambda self: None
Sig_U_aniso_orth_swigregister = _clipper.Sig_U_aniso_orth_swigregister
Sig_U_aniso_orth_swigregister(Sig_U_aniso_orth)

class MMDBAtom(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBAtom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBAtom, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MMDBAtom(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _clipper.MMDBAtom_id(self)

    def element(self):
        return _clipper.MMDBAtom_element(self)

    def coord_orth(self):
        return _clipper.MMDBAtom_coord_orth(self)

    def occupancy(self):
        return _clipper.MMDBAtom_occupancy(self)

    def u_iso(self):
        return _clipper.MMDBAtom_u_iso(self)

    def u_aniso_orth(self):
        return _clipper.MMDBAtom_u_aniso_orth(self)

    def set_id(self, n):
        return _clipper.MMDBAtom_set_id(self, n)

    def set_element(self, n):
        return _clipper.MMDBAtom_set_element(self, n)

    def set_coord_orth(self, v):
        return _clipper.MMDBAtom_set_coord_orth(self, v)

    def set_occupancy(self, v):
        return _clipper.MMDBAtom_set_occupancy(self, v)

    def set_u_iso(self, v):
        return _clipper.MMDBAtom_set_u_iso(self, v)

    def set_u_aniso_orth(self, v):
        return _clipper.MMDBAtom_set_u_aniso_orth(self, v)

    def sig_coord_orth(self):
        return _clipper.MMDBAtom_sig_coord_orth(self)

    def sig_occupancy(self):
        return _clipper.MMDBAtom_sig_occupancy(self)

    def sig_u_iso(self):
        return _clipper.MMDBAtom_sig_u_iso(self)

    def sig_u_aniso_orth(self):
        return _clipper.MMDBAtom_sig_u_aniso_orth(self)

    def set_sig_coord_orth(self, s):
        return _clipper.MMDBAtom_set_sig_coord_orth(self, s)

    def set_sig_occupancy(self, s):
        return _clipper.MMDBAtom_set_sig_occupancy(self, s)

    def set_sig_u_iso(self, s):
        return _clipper.MMDBAtom_set_sig_u_iso(self, s)

    def set_sig_u_aniso_orth(self, s):
        return _clipper.MMDBAtom_set_sig_u_aniso_orth(self, s)

    def altconf(self):
        return _clipper.MMDBAtom_altconf(self)

    def serial_num(self):
        return _clipper.MMDBAtom_serial_num(self)

    def charge(self):
        return _clipper.MMDBAtom_charge(self)
    __swig_destroy__ = _clipper.delete_MMDBAtom
    __del__ = lambda self: None
MMDBAtom_swigregister = _clipper.MMDBAtom_swigregister
MMDBAtom_swigregister(MMDBAtom)

class MMDBResidue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBResidue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBResidue, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MMDBResidue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def type(self):
        return _clipper.MMDBResidue_type(self)

    def seqnum(self):
        return _clipper.MMDBResidue_seqnum(self)

    def inscode(self):
        return _clipper.MMDBResidue_inscode(self)

    def set_type(self, n):
        return _clipper.MMDBResidue_set_type(self, n)

    def set_seqnum(self, n):
        return _clipper.MMDBResidue_set_seqnum(self, n)

    def set_inscode(self, n):
        return _clipper.MMDBResidue_set_inscode(self, n)
    __swig_destroy__ = _clipper.delete_MMDBResidue
    __del__ = lambda self: None
MMDBResidue_swigregister = _clipper.MMDBResidue_swigregister
MMDBResidue_swigregister(MMDBResidue)

class MMDBChain(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBChain, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBChain, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MMDBChain(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _clipper.MMDBChain_id(self)

    def set_id(self, n):
        return _clipper.MMDBChain_set_id(self, n)
    __swig_destroy__ = _clipper.delete_MMDBChain
    __del__ = lambda self: None
MMDBChain_swigregister = _clipper.MMDBChain_swigregister
MMDBChain_swigregister(MMDBChain)

class MMDBModel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBModel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBModel, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MMDBModel(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _clipper.MMDBModel_id(self)

    def set_id(self, n):
        return _clipper.MMDBModel_set_id(self, n)
    __swig_destroy__ = _clipper.delete_MMDBModel
    __del__ = lambda self: None
MMDBModel_swigregister = _clipper.MMDBModel_swigregister
MMDBModel_swigregister(MMDBModel)

class MMDBManager(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBManager, name)
    __repr__ = _swig_repr
    Default = _clipper.MMDBManager_Default
    PDB = _clipper.MMDBManager_PDB
    CIF = _clipper.MMDBManager_CIF
    Binary = _clipper.MMDBManager_Binary

    def __init__(self):
        this = _clipper.new_MMDBManager()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MMDBManager
    __del__ = lambda self: None

    def spacegroup(self):
        return _clipper.MMDBManager_spacegroup(self)

    def cell(self):
        return _clipper.MMDBManager_cell(self)

    def set_spacegroup(self, spacegroup):
        return _clipper.MMDBManager_set_spacegroup(self, spacegroup)

    def set_cell(self, cell):
        return _clipper.MMDBManager_set_cell(self, cell)
MMDBManager_swigregister = _clipper.MMDBManager_swigregister
MMDBManager_swigregister(MMDBManager)

class MMDBAtom_list(Atom_list):
    __swig_setmethods__ = {}
    for _s in [Atom_list]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBAtom_list, name, value)
    __swig_getmethods__ = {}
    for _s in [Atom_list]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBAtom_list, name)
    __repr__ = _swig_repr

    def __init__(self, ppcatom, natom):
        this = _clipper.new_MMDBAtom_list(ppcatom, natom)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MMDBAtom_list
    __del__ = lambda self: None
MMDBAtom_list_swigregister = _clipper.MMDBAtom_list_swigregister
MMDBAtom_list_swigregister(MMDBAtom_list)


_clipper.UNIQUE_swigconstant(_clipper)
UNIQUE = _clipper.UNIQUE

_clipper.ANY_swigconstant(_clipper)
ANY = _clipper.ANY

_clipper.COPY_NONE_swigconstant(_clipper)
COPY_NONE = _clipper.COPY_NONE

_clipper.COPY_M_swigconstant(_clipper)
COPY_M = _clipper.COPY_M

_clipper.COPY_P_swigconstant(_clipper)
COPY_P = _clipper.COPY_P

_clipper.COPY_MP_swigconstant(_clipper)
COPY_MP = _clipper.COPY_MP

_clipper.COPY_C_swigconstant(_clipper)
COPY_C = _clipper.COPY_C

_clipper.COPY_MC_swigconstant(_clipper)
COPY_MC = _clipper.COPY_MC

_clipper.COPY_PC_swigconstant(_clipper)
COPY_PC = _clipper.COPY_PC

_clipper.COPY_MPC_swigconstant(_clipper)
COPY_MPC = _clipper.COPY_MPC

_clipper.MEMBERS_swigconstant(_clipper)
MEMBERS = _clipper.MEMBERS

_clipper.PROPERTIES_swigconstant(_clipper)
PROPERTIES = _clipper.PROPERTIES

_clipper.CHILDREN_swigconstant(_clipper)
CHILDREN = _clipper.CHILDREN
class MAtom(Atom):
    __swig_setmethods__ = {}
    for _s in [Atom]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [Atom]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MAtom, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MAtom(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _clipper.MAtom_id(self)

    def set_id(self, s):
        return _clipper.MAtom_set_id(self, s)

    def name(self):
        return _clipper.MAtom_name(self)

    def set_name(self, *args):
        return _clipper.MAtom_set_name(self, *args)

    def atom(self, *args):
        return _clipper.MAtom_atom(self, *args)

    def copy(self, other, mode):
        return _clipper.MAtom_copy(self, other, mode)
    __swig_getmethods__["id_tidy"] = lambda x: _clipper.MAtom_id_tidy
    if _newclass:
        id_tidy = staticmethod(_clipper.MAtom_id_tidy)
    __swig_getmethods__["id_match"] = lambda x: _clipper.MAtom_id_match
    if _newclass:
        id_match = staticmethod(_clipper.MAtom_id_match)

    def __str__(self):
        return _clipper.MAtom___str__(self)
    __swig_destroy__ = _clipper.delete_MAtom
    __del__ = lambda self: None
MAtom_swigregister = _clipper.MAtom_swigregister
MAtom_swigregister(MAtom)

def MAtom_id_tidy(id):
    return _clipper.MAtom_id_tidy(id)
MAtom_id_tidy = _clipper.MAtom_id_tidy

def MAtom_id_match(id1, id2, mode):
    return _clipper.MAtom_id_match(id1, id2, mode)
MAtom_id_match = _clipper.MAtom_id_match

class MMonomer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMonomer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMonomer, name)
    __repr__ = _swig_repr

    def id(self):
        return _clipper.MMonomer_id(self)

    def set_id(self, s):
        return _clipper.MMonomer_set_id(self, s)

    def type(self):
        return _clipper.MMonomer_type(self)

    def set_type(self, s):
        return _clipper.MMonomer_set_type(self, s)

    def seqnum(self):
        return _clipper.MMonomer_seqnum(self)

    def set_seqnum(self, *args):
        return _clipper.MMonomer_set_seqnum(self, *args)

    def atom_list(self):
        return _clipper.MMonomer_atom_list(self)

    def transform(self, rt):
        return _clipper.MMonomer_transform(self, rt)

    def size(self):
        return _clipper.MMonomer_size(self)

    def find(self, *args):
        return _clipper.MMonomer_find(self, *args)

    def select(self, *args):
        return _clipper.MMonomer_select(self, *args)

    def select_index(self, *args):
        return _clipper.MMonomer_select_index(self, *args)

    def lookup(self, str, mode):
        return _clipper.MMonomer_lookup(self, str, mode)

    def insert(self, add, pos=-1):
        return _clipper.MMonomer_insert(self, add, pos)

    def copy(self, other, mode):
        return _clipper.MMonomer_copy(self, other, mode)
    __swig_getmethods__["id_tidy"] = lambda x: _clipper.MMonomer_id_tidy
    if _newclass:
        id_tidy = staticmethod(_clipper.MMonomer_id_tidy)
    __swig_getmethods__["id_match"] = lambda x: _clipper.MMonomer_id_match
    if _newclass:
        id_match = staticmethod(_clipper.MMonomer_id_match)
    Default = _clipper.MMonomer_Default
    Dunbrack = _clipper.MMonomer_Dunbrack
    Richardson = _clipper.MMonomer_Richardson

    def protein_mainchain_build_carbonyl_oxygen(self, *args):
        return _clipper.MMonomer_protein_mainchain_build_carbonyl_oxygen(self, *args)

    def protein_sidechain_number_of_rotamers(self, *args):
        return _clipper.MMonomer_protein_sidechain_number_of_rotamers(self, *args)

    def protein_sidechain_number_of_rotomers(self):
        return _clipper.MMonomer_protein_sidechain_number_of_rotomers(self)

    def protein_sidechain_build_rotamer(self, *args):
        return _clipper.MMonomer_protein_sidechain_build_rotamer(self, *args)

    def protein_sidechain_build_rotomer(self, n):
        return _clipper.MMonomer_protein_sidechain_build_rotomer(self, n)
    __swig_getmethods__["protein_peptide_bond"] = lambda x: _clipper.MMonomer_protein_peptide_bond
    if _newclass:
        protein_peptide_bond = staticmethod(_clipper.MMonomer_protein_peptide_bond)
    __swig_getmethods__["protein_ramachandran_phi"] = lambda x: _clipper.MMonomer_protein_ramachandran_phi
    if _newclass:
        protein_ramachandran_phi = staticmethod(_clipper.MMonomer_protein_ramachandran_phi)
    __swig_getmethods__["protein_ramachandran_psi"] = lambda x: _clipper.MMonomer_protein_ramachandran_psi
    if _newclass:
        protein_ramachandran_psi = staticmethod(_clipper.MMonomer_protein_ramachandran_psi)
    __swig_getmethods__["default_type"] = lambda x: _clipper.MMonomer_default_type
    if _newclass:
        default_type = staticmethod(_clipper.MMonomer_default_type)

    def __getitem__(self, i):
        return _clipper.MMonomer___getitem__(self, i)

    def __setitem__(self, i, atom):
        return _clipper.MMonomer___setitem__(self, i, atom)

    def __len__(self):
        return _clipper.MMonomer___len__(self)

    def __init__(self):
        this = _clipper.new_MMonomer()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MMonomer
    __del__ = lambda self: None
MMonomer_swigregister = _clipper.MMonomer_swigregister
MMonomer_swigregister(MMonomer)

def and_MMonomer(m1, m2):
    return _clipper.and_MMonomer(m1, m2)
and_MMonomer = _clipper.and_MMonomer

def or_MMonomer(m1, m2):
    return _clipper.or_MMonomer(m1, m2)
or_MMonomer = _clipper.or_MMonomer

def MMonomer_id_tidy(id):
    return _clipper.MMonomer_id_tidy(id)
MMonomer_id_tidy = _clipper.MMonomer_id_tidy

def MMonomer_id_match(id1, id2, mode):
    return _clipper.MMonomer_id_match(id1, id2, mode)
MMonomer_id_match = _clipper.MMonomer_id_match

def MMonomer_protein_peptide_bond(m1, m2, r=1.5):
    return _clipper.MMonomer_protein_peptide_bond(m1, m2, r)
MMonomer_protein_peptide_bond = _clipper.MMonomer_protein_peptide_bond

def MMonomer_protein_ramachandran_phi(m1, m2):
    return _clipper.MMonomer_protein_ramachandran_phi(m1, m2)
MMonomer_protein_ramachandran_phi = _clipper.MMonomer_protein_ramachandran_phi

def MMonomer_protein_ramachandran_psi(m1, m2):
    return _clipper.MMonomer_protein_ramachandran_psi(m1, m2)
MMonomer_protein_ramachandran_psi = _clipper.MMonomer_protein_ramachandran_psi

def MMonomer_default_type():
    return _clipper.MMonomer_default_type()
MMonomer_default_type = _clipper.MMonomer_default_type

class MPolymer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MPolymer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MPolymer, name)
    __repr__ = _swig_repr

    def id(self):
        return _clipper.MPolymer_id(self)

    def set_id(self, s):
        return _clipper.MPolymer_set_id(self, s)

    def atom_list(self):
        return _clipper.MPolymer_atom_list(self)

    def transform(self, rt):
        return _clipper.MPolymer_transform(self, rt)

    def size(self):
        return _clipper.MPolymer_size(self)

    def find(self, *args):
        return _clipper.MPolymer_find(self, *args)

    def select(self, *args):
        return _clipper.MPolymer_select(self, *args)

    def select_index(self, *args):
        return _clipper.MPolymer_select_index(self, *args)

    def lookup(self, str, mode):
        return _clipper.MPolymer_lookup(self, str, mode)

    def insert(self, add, pos=-1):
        return _clipper.MPolymer_insert(self, add, pos)

    def copy(self, other, mode):
        return _clipper.MPolymer_copy(self, other, mode)
    __swig_getmethods__["id_tidy"] = lambda x: _clipper.MPolymer_id_tidy
    if _newclass:
        id_tidy = staticmethod(_clipper.MPolymer_id_tidy)
    __swig_getmethods__["id_match"] = lambda x: _clipper.MPolymer_id_match
    if _newclass:
        id_match = staticmethod(_clipper.MPolymer_id_match)

    def __getitem__(self, i):
        return _clipper.MPolymer___getitem__(self, i)

    def __setitem__(self, i, mmon):
        return _clipper.MPolymer___setitem__(self, i, mmon)

    def __len__(self):
        return _clipper.MPolymer___len__(self)

    def __init__(self):
        this = _clipper.new_MPolymer()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MPolymer
    __del__ = lambda self: None
MPolymer_swigregister = _clipper.MPolymer_swigregister
MPolymer_swigregister(MPolymer)

def and_MPolymer(m1, m2):
    return _clipper.and_MPolymer(m1, m2)
and_MPolymer = _clipper.and_MPolymer

def or_MPolymer(m1, m2):
    return _clipper.or_MPolymer(m1, m2)
or_MPolymer = _clipper.or_MPolymer

def MPolymer_id_tidy(id):
    return _clipper.MPolymer_id_tidy(id)
MPolymer_id_tidy = _clipper.MPolymer_id_tidy

def MPolymer_id_match(id1, id2, mode):
    return _clipper.MPolymer_id_match(id1, id2, mode)
MPolymer_id_match = _clipper.MPolymer_id_match

class MModel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MModel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MModel, name)
    __repr__ = _swig_repr

    def atom_list(self):
        return _clipper.MModel_atom_list(self)

    def transform(self, rt):
        return _clipper.MModel_transform(self, rt)

    def size(self):
        return _clipper.MModel_size(self)

    def find(self, *args):
        return _clipper.MModel_find(self, *args)

    def select(self, *args):
        return _clipper.MModel_select(self, *args)

    def select_index(self, *args):
        return _clipper.MModel_select_index(self, *args)

    def lookup(self, str, mode):
        return _clipper.MModel_lookup(self, str, mode)

    def insert(self, add, pos=-1):
        return _clipper.MModel_insert(self, add, pos)

    def copy(self, other, mode):
        return _clipper.MModel_copy(self, other, mode)

    def atom(self, *args):
        return _clipper.MModel_atom(self, *args)

    def select_atom_index(self, *args):
        return _clipper.MModel_select_atom_index(self, *args)

    def __getitem__(self, i):
        return _clipper.MModel___getitem__(self, i)

    def __setitem__(self, i, mpol):
        return _clipper.MModel___setitem__(self, i, mpol)

    def __len__(self):
        return _clipper.MModel___len__(self)

    def __init__(self):
        this = _clipper.new_MModel()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MModel
    __del__ = lambda self: None
MModel_swigregister = _clipper.MModel_swigregister
MModel_swigregister(MModel)

def and_MModel(m1, m2):
    return _clipper.and_MModel(m1, m2)
and_MModel = _clipper.and_MModel

def or_MModel(m1, m2):
    return _clipper.or_MModel(m1, m2)
or_MModel = _clipper.or_MModel

class MiniMol(MModel):
    __swig_setmethods__ = {}
    for _s in [MModel]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MiniMol, name, value)
    __swig_getmethods__ = {}
    for _s in [MModel]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MiniMol, name)
    __repr__ = _swig_repr
    UNIQUE = _clipper.MiniMol_UNIQUE
    ANY = _clipper.MiniMol_ANY

    def __init__(self, *args):
        this = _clipper.new_MiniMol(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, spacegroup, cell):
        return _clipper.MiniMol_init(self, spacegroup, cell)

    def cell(self):
        return _clipper.MiniMol_cell(self)

    def spacegroup(self):
        return _clipper.MiniMol_spacegroup(self)

    def model(self, *args):
        return _clipper.MiniMol_model(self, *args)

    def symmetry_atom(self, index):
        return _clipper.MiniMol_symmetry_atom(self, index)

    def is_null(self):
        return _clipper.MiniMol_is_null(self)
    __swig_destroy__ = _clipper.delete_MiniMol
    __del__ = lambda self: None
MiniMol_swigregister = _clipper.MiniMol_swigregister
MiniMol_swigregister(MiniMol)

class MMDBfile(MMDBManager):
    __swig_setmethods__ = {}
    for _s in [MMDBManager]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMDBfile, name, value)
    __swig_getmethods__ = {}
    for _s in [MMDBManager]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MMDBfile, name)
    __repr__ = _swig_repr

    def read_file(self, file):
        return _clipper.MMDBfile_read_file(self, file)

    def write_file(self, *args):
        return _clipper.MMDBfile_write_file(self, *args)

    def import_minimol(self, minimol, hnd=-1):
        return _clipper.MMDBfile_import_minimol(self, minimol, hnd)

    def export_minimol(self, minimol):
        return _clipper.MMDBfile_export_minimol(self, minimol)

    def __init__(self):
        this = _clipper.new_MMDBfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MMDBfile
    __del__ = lambda self: None
MMDBfile_swigregister = _clipper.MMDBfile_swigregister
MMDBfile_swigregister(MMDBfile)

class SEQfile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SEQfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SEQfile, name)
    __repr__ = _swig_repr

    def read_file(self, file):
        return _clipper.SEQfile_read_file(self, file)

    def import_polymer_sequence(self, target):
        return _clipper.SEQfile_import_polymer_sequence(self, target)

    def import_molecule_sequence(self, target):
        return _clipper.SEQfile_import_molecule_sequence(self, target)

    def __init__(self):
        this = _clipper.new_SEQfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_SEQfile
    __del__ = lambda self: None
SEQfile_swigregister = _clipper.SEQfile_swigregister
SEQfile_swigregister(SEQfile)

class MPolymerSequence(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MPolymerSequence, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MPolymerSequence, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_MPolymerSequence()
        try:
            self.this.append(this)
        except:
            self.this = this

    def id(self):
        return _clipper.MPolymerSequence_id(self)

    def set_id(self, s):
        return _clipper.MPolymerSequence_set_id(self, s)

    def sequence(self):
        return _clipper.MPolymerSequence_sequence(self)

    def set_sequence(self, s):
        return _clipper.MPolymerSequence_set_sequence(self, s)
    __swig_getmethods__["id_tidy"] = lambda x: _clipper.MPolymerSequence_id_tidy
    if _newclass:
        id_tidy = staticmethod(_clipper.MPolymerSequence_id_tidy)
    __swig_getmethods__["id_match"] = lambda x: _clipper.MPolymerSequence_id_match
    if _newclass:
        id_match = staticmethod(_clipper.MPolymerSequence_id_match)
    __swig_destroy__ = _clipper.delete_MPolymerSequence
    __del__ = lambda self: None
MPolymerSequence_swigregister = _clipper.MPolymerSequence_swigregister
MPolymerSequence_swigregister(MPolymerSequence)

def MPolymerSequence_id_tidy(id):
    return _clipper.MPolymerSequence_id_tidy(id)
MPolymerSequence_id_tidy = _clipper.MPolymerSequence_id_tidy

def MPolymerSequence_id_match(id1, id2, mode):
    return _clipper.MPolymerSequence_id_match(id1, id2, mode)
MPolymerSequence_id_match = _clipper.MPolymerSequence_id_match

class MMoleculeSequence(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMoleculeSequence, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMoleculeSequence, name)
    __repr__ = _swig_repr

    def size(self):
        return _clipper.MMoleculeSequence_size(self)

    def find(self, *args):
        return _clipper.MMoleculeSequence_find(self, *args)

    def lookup(self, str, mode):
        return _clipper.MMoleculeSequence_lookup(self, str, mode)

    def insert(self, add, pos=-1):
        return _clipper.MMoleculeSequence_insert(self, add, pos)

    def is_null(self):
        return _clipper.MMoleculeSequence_is_null(self)

    def __init__(self):
        this = _clipper.new_MMoleculeSequence()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_MMoleculeSequence
    __del__ = lambda self: None
MMoleculeSequence_swigregister = _clipper.MMoleculeSequence_swigregister
MMoleculeSequence_swigregister(MMoleculeSequence)

class MSequenceAlign(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MSequenceAlign, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MSequenceAlign, name)
    __repr__ = _swig_repr
    GLOBAL = _clipper.MSequenceAlign_GLOBAL
    LOCAL = _clipper.MSequenceAlign_LOCAL

    def __init__(self, *args):
        this = _clipper.new_MSequenceAlign(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, seq1, seq2):
        return _clipper.MSequenceAlign___call__(self, seq1, seq2)
    __swig_destroy__ = _clipper.delete_MSequenceAlign
    __del__ = lambda self: None
MSequenceAlign_swigregister = _clipper.MSequenceAlign_swigregister
MSequenceAlign_swigregister(MSequenceAlign)

class Flag(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Flag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Flag, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Flag(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.Flag_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.Flag_type
    if _newclass:
        type = staticmethod(_clipper.Flag_type)

    def friedel(self):
        return _clipper.Flag_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.Flag_shift_phase(self, arg2)

    def missing(self):
        return _clipper.Flag_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.Flag_data_size
    if _newclass:
        data_size = staticmethod(_clipper.Flag_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.Flag_data_names
    if _newclass:
        data_names = staticmethod(_clipper.Flag_data_names)

    def data_export(self, array):
        return _clipper.Flag_data_export(self, array)

    def data_import(self, array):
        return _clipper.Flag_data_import(self, array)

    def flag(self, *args):
        return _clipper.Flag_flag(self, *args)

    def get_flag(self):
        return _clipper.Flag_get_flag(self)

    def set_flag(self, theFlag):
        return _clipper.Flag_set_flag(self, theFlag)

    def copy(self):
        return _clipper.Flag_copy(self)
    __swig_destroy__ = _clipper.delete_Flag
    __del__ = lambda self: None
Flag_swigregister = _clipper.Flag_swigregister
Flag_swigregister(Flag)

def Flag_type():
    return _clipper.Flag_type()
Flag_type = _clipper.Flag_type

def Flag_data_size():
    return _clipper.Flag_data_size()
Flag_data_size = _clipper.Flag_data_size

def Flag_data_names():
    return _clipper.Flag_data_names()
Flag_data_names = _clipper.Flag_data_names

class Flag_bool(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Flag_bool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Flag_bool, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_Flag_bool()
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.Flag_bool_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.Flag_bool_type
    if _newclass:
        type = staticmethod(_clipper.Flag_bool_type)

    def friedel(self):
        return _clipper.Flag_bool_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.Flag_bool_shift_phase(self, arg2)

    def missing(self):
        return _clipper.Flag_bool_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.Flag_bool_data_size
    if _newclass:
        data_size = staticmethod(_clipper.Flag_bool_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.Flag_bool_data_names
    if _newclass:
        data_names = staticmethod(_clipper.Flag_bool_data_names)

    def data_export(self, array):
        return _clipper.Flag_bool_data_export(self, array)

    def data_import(self, array):
        return _clipper.Flag_bool_data_import(self, array)

    def flag(self, *args):
        return _clipper.Flag_bool_flag(self, *args)

    def get_flag(self):
        return _clipper.Flag_bool_get_flag(self)

    def set_flag(self, theFlag):
        return _clipper.Flag_bool_set_flag(self, theFlag)

    def copy(self):
        return _clipper.Flag_bool_copy(self)
    __swig_destroy__ = _clipper.delete_Flag_bool
    __del__ = lambda self: None
Flag_bool_swigregister = _clipper.Flag_bool_swigregister
Flag_bool_swigregister(Flag_bool)

def Flag_bool_type():
    return _clipper.Flag_bool_type()
Flag_bool_type = _clipper.Flag_bool_type

def Flag_bool_data_size():
    return _clipper.Flag_bool_data_size()
Flag_bool_data_size = _clipper.Flag_bool_data_size

def Flag_bool_data_names():
    return _clipper.Flag_bool_data_names()
Flag_bool_data_names = _clipper.Flag_bool_data_names

class F_sigF_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_sigF_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_sigF_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_F_sigF_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.F_sigF_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_sigF_float_type
    if _newclass:
        type = staticmethod(_clipper.F_sigF_float_type)

    def friedel(self):
        return _clipper.F_sigF_float_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.F_sigF_float_shift_phase(self, arg2)

    def missing(self):
        return _clipper.F_sigF_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_sigF_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_sigF_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_sigF_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_sigF_float_data_names)

    def data_export(self, array):
        return _clipper.F_sigF_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.F_sigF_float_data_import(self, array)

    def scale(self, s):
        return _clipper.F_sigF_float_scale(self, s)

    def f(self, *args):
        return _clipper.F_sigF_float_f(self, *args)

    def sigf(self, *args):
        return _clipper.F_sigF_float_sigf(self, *args)

    def f_pl(self):
        return _clipper.F_sigF_float_f_pl(self)

    def sigf_pl(self):
        return _clipper.F_sigF_float_sigf_pl(self)

    def f_mi(self):
        return _clipper.F_sigF_float_f_mi(self)

    def sigf_mi(self):
        return _clipper.F_sigF_float_sigf_mi(self)

    def cov(self):
        return _clipper.F_sigF_float_cov(self)

    def copy(self):
        return _clipper.F_sigF_float_copy(self)
    __swig_destroy__ = _clipper.delete_F_sigF_float
    __del__ = lambda self: None
F_sigF_float_swigregister = _clipper.F_sigF_float_swigregister
F_sigF_float_swigregister(F_sigF_float)

def F_sigF_float_type():
    return _clipper.F_sigF_float_type()
F_sigF_float_type = _clipper.F_sigF_float_type

def F_sigF_float_data_size():
    return _clipper.F_sigF_float_data_size()
F_sigF_float_data_size = _clipper.F_sigF_float_data_size

def F_sigF_float_data_names():
    return _clipper.F_sigF_float_data_names()
F_sigF_float_data_names = _clipper.F_sigF_float_data_names

class F_sigF_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_sigF_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_sigF_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_F_sigF_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.F_sigF_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_sigF_double_type
    if _newclass:
        type = staticmethod(_clipper.F_sigF_double_type)

    def friedel(self):
        return _clipper.F_sigF_double_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.F_sigF_double_shift_phase(self, arg2)

    def missing(self):
        return _clipper.F_sigF_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_sigF_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_sigF_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_sigF_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_sigF_double_data_names)

    def data_export(self, array):
        return _clipper.F_sigF_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.F_sigF_double_data_import(self, array)

    def scale(self, s):
        return _clipper.F_sigF_double_scale(self, s)

    def f(self, *args):
        return _clipper.F_sigF_double_f(self, *args)

    def sigf(self, *args):
        return _clipper.F_sigF_double_sigf(self, *args)

    def f_pl(self):
        return _clipper.F_sigF_double_f_pl(self)

    def sigf_pl(self):
        return _clipper.F_sigF_double_sigf_pl(self)

    def f_mi(self):
        return _clipper.F_sigF_double_f_mi(self)

    def sigf_mi(self):
        return _clipper.F_sigF_double_sigf_mi(self)

    def cov(self):
        return _clipper.F_sigF_double_cov(self)
    __swig_destroy__ = _clipper.delete_F_sigF_double
    __del__ = lambda self: None
F_sigF_double_swigregister = _clipper.F_sigF_double_swigregister
F_sigF_double_swigregister(F_sigF_double)

def F_sigF_double_type():
    return _clipper.F_sigF_double_type()
F_sigF_double_type = _clipper.F_sigF_double_type

def F_sigF_double_data_size():
    return _clipper.F_sigF_double_data_size()
F_sigF_double_data_size = _clipper.F_sigF_double_data_size

def F_sigF_double_data_names():
    return _clipper.F_sigF_double_data_names()
F_sigF_double_data_names = _clipper.F_sigF_double_data_names

class HKL_data_F_sigF_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_sigF_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_sigF_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_sigF_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_sigF_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_sigF_float_update(self)

    def type(self):
        return _clipper.HKL_data_F_sigF_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_sigF_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_sigF_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_sigF_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_sigF_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_sigF_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_sigF_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_sigF_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_sigF_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_sigF_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_sigF_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_F_sigF_float_not_(self)

    def __or__(self, *args):
        return _clipper.HKL_data_F_sigF_float___or__(self, *args)

    def __xor__(self, *args):
        return _clipper.HKL_data_F_sigF_float___xor__(self, *args)

    def __and__(self, *args):
        return _clipper.HKL_data_F_sigF_float___and__(self, *args)

    def getDataNumpy(self, test_numpy_a):
        return _clipper.HKL_data_F_sigF_float_getDataNumpy(self, test_numpy_a)

    def getData(self):
        return _clipper.HKL_data_F_sigF_float_getData(self)

    def __getitem__(self, i):
        return _clipper.HKL_data_F_sigF_float___getitem__(self, i)

    def __len__(self):
        return _clipper.HKL_data_F_sigF_float___len__(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_sigF_float
    __del__ = lambda self: None
HKL_data_F_sigF_float_swigregister = _clipper.HKL_data_F_sigF_float_swigregister
HKL_data_F_sigF_float_swigregister(HKL_data_F_sigF_float)

class HKL_data_F_sigF_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_sigF_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_sigF_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_sigF_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_sigF_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_sigF_double_update(self)

    def type(self):
        return _clipper.HKL_data_F_sigF_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_sigF_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_sigF_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_sigF_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_sigF_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_sigF_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_sigF_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_sigF_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_sigF_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_sigF_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_sigF_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_sigF_double
    __del__ = lambda self: None
HKL_data_F_sigF_double_swigregister = _clipper.HKL_data_F_sigF_double_swigregister
HKL_data_F_sigF_double_swigregister(HKL_data_F_sigF_double)

class F_sigF_ano_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_sigF_ano_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_sigF_ano_float, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_F_sigF_ano_float()
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.F_sigF_ano_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_sigF_ano_float_type
    if _newclass:
        type = staticmethod(_clipper.F_sigF_ano_float_type)

    def friedel(self):
        return _clipper.F_sigF_ano_float_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.F_sigF_ano_float_shift_phase(self, arg2)

    def missing(self):
        return _clipper.F_sigF_ano_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_sigF_ano_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_sigF_ano_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_sigF_ano_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_sigF_ano_float_data_names)

    def data_export(self, a):
        return _clipper.F_sigF_ano_float_data_export(self, a)

    def data_import(self, a):
        return _clipper.F_sigF_ano_float_data_import(self, a)

    def scale(self, s):
        return _clipper.F_sigF_ano_float_scale(self, s)

    def f_pl(self, *args):
        return _clipper.F_sigF_ano_float_f_pl(self, *args)

    def sigf_pl(self, *args):
        return _clipper.F_sigF_ano_float_sigf_pl(self, *args)

    def f_mi(self, *args):
        return _clipper.F_sigF_ano_float_f_mi(self, *args)

    def sigf_mi(self, *args):
        return _clipper.F_sigF_ano_float_sigf_mi(self, *args)

    def cov(self, *args):
        return _clipper.F_sigF_ano_float_cov(self, *args)

    def f(self):
        return _clipper.F_sigF_ano_float_f(self)

    def sigf(self):
        return _clipper.F_sigF_ano_float_sigf(self)

    def copy(self):
        return _clipper.F_sigF_ano_float_copy(self)
    __swig_destroy__ = _clipper.delete_F_sigF_ano_float
    __del__ = lambda self: None
F_sigF_ano_float_swigregister = _clipper.F_sigF_ano_float_swigregister
F_sigF_ano_float_swigregister(F_sigF_ano_float)

def F_sigF_ano_float_type():
    return _clipper.F_sigF_ano_float_type()
F_sigF_ano_float_type = _clipper.F_sigF_ano_float_type

def F_sigF_ano_float_data_size():
    return _clipper.F_sigF_ano_float_data_size()
F_sigF_ano_float_data_size = _clipper.F_sigF_ano_float_data_size

def F_sigF_ano_float_data_names():
    return _clipper.F_sigF_ano_float_data_names()
F_sigF_ano_float_data_names = _clipper.F_sigF_ano_float_data_names

class F_sigF_ano_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_sigF_ano_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_sigF_ano_double, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_F_sigF_ano_double()
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.F_sigF_ano_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_sigF_ano_double_type
    if _newclass:
        type = staticmethod(_clipper.F_sigF_ano_double_type)

    def friedel(self):
        return _clipper.F_sigF_ano_double_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.F_sigF_ano_double_shift_phase(self, arg2)

    def missing(self):
        return _clipper.F_sigF_ano_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_sigF_ano_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_sigF_ano_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_sigF_ano_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_sigF_ano_double_data_names)

    def data_export(self, a):
        return _clipper.F_sigF_ano_double_data_export(self, a)

    def data_import(self, a):
        return _clipper.F_sigF_ano_double_data_import(self, a)

    def scale(self, s):
        return _clipper.F_sigF_ano_double_scale(self, s)

    def f_pl(self, *args):
        return _clipper.F_sigF_ano_double_f_pl(self, *args)

    def sigf_pl(self, *args):
        return _clipper.F_sigF_ano_double_sigf_pl(self, *args)

    def f_mi(self, *args):
        return _clipper.F_sigF_ano_double_f_mi(self, *args)

    def sigf_mi(self, *args):
        return _clipper.F_sigF_ano_double_sigf_mi(self, *args)

    def cov(self, *args):
        return _clipper.F_sigF_ano_double_cov(self, *args)

    def f(self):
        return _clipper.F_sigF_ano_double_f(self)

    def sigf(self):
        return _clipper.F_sigF_ano_double_sigf(self)
    __swig_destroy__ = _clipper.delete_F_sigF_ano_double
    __del__ = lambda self: None
F_sigF_ano_double_swigregister = _clipper.F_sigF_ano_double_swigregister
F_sigF_ano_double_swigregister(F_sigF_ano_double)

def F_sigF_ano_double_type():
    return _clipper.F_sigF_ano_double_type()
F_sigF_ano_double_type = _clipper.F_sigF_ano_double_type

def F_sigF_ano_double_data_size():
    return _clipper.F_sigF_ano_double_data_size()
F_sigF_ano_double_data_size = _clipper.F_sigF_ano_double_data_size

def F_sigF_ano_double_data_names():
    return _clipper.F_sigF_ano_double_data_names()
F_sigF_ano_double_data_names = _clipper.F_sigF_ano_double_data_names

class HKL_data_F_sigF_ano_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_sigF_ano_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_sigF_ano_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_sigF_ano_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_sigF_ano_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_sigF_ano_float_update(self)

    def type(self):
        return _clipper.HKL_data_F_sigF_ano_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_sigF_ano_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_sigF_ano_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_sigF_ano_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_sigF_ano_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_sigF_ano_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_sigF_ano_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_sigF_ano_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_sigF_ano_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_sigF_ano_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_sigF_ano_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_F_sigF_ano_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_F_sigF_ano_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_F_sigF_ano_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_F_sigF_ano_float___and__(self, d1)

    def compute_scale_u_iso_fsigfano(self, scale, u_value, fsigfano):
        return _clipper.HKL_data_F_sigF_ano_float_compute_scale_u_iso_fsigfano(self, scale, u_value, fsigfano)

    def compute_scale_u_aniso_fsigfano(self, scale, u_value, fsigfano):
        return _clipper.HKL_data_F_sigF_ano_float_compute_scale_u_aniso_fsigfano(self, scale, u_value, fsigfano)

    def copy(self):
        return _clipper.HKL_data_F_sigF_ano_float_copy(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_sigF_ano_float
    __del__ = lambda self: None
HKL_data_F_sigF_ano_float_swigregister = _clipper.HKL_data_F_sigF_ano_float_swigregister
HKL_data_F_sigF_ano_float_swigregister(HKL_data_F_sigF_ano_float)

class HKL_data_F_sigF_ano_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_sigF_ano_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_sigF_ano_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_sigF_ano_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_sigF_ano_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_sigF_ano_double_update(self)

    def type(self):
        return _clipper.HKL_data_F_sigF_ano_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_sigF_ano_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_sigF_ano_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_sigF_ano_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_sigF_ano_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_sigF_ano_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_sigF_ano_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_sigF_ano_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_sigF_ano_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_sigF_ano_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_sigF_ano_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_sigF_ano_double
    __del__ = lambda self: None
HKL_data_F_sigF_ano_double_swigregister = _clipper.HKL_data_F_sigF_ano_double_swigregister
HKL_data_F_sigF_ano_double_swigregister(HKL_data_F_sigF_ano_double)

class I_sigI_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, I_sigI_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, I_sigI_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_I_sigI_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.I_sigI_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.I_sigI_float_type
    if _newclass:
        type = staticmethod(_clipper.I_sigI_float_type)

    def friedel(self):
        return _clipper.I_sigI_float_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.I_sigI_float_shift_phase(self, arg2)

    def missing(self):
        return _clipper.I_sigI_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.I_sigI_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.I_sigI_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.I_sigI_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.I_sigI_float_data_names)

    def data_export(self, array):
        return _clipper.I_sigI_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.I_sigI_float_data_import(self, array)

    def scale(self, s):
        return _clipper.I_sigI_float_scale(self, s)

    def I(self, *args):
        return _clipper.I_sigI_float_I(self, *args)

    def sigI(self, *args):
        return _clipper.I_sigI_float_sigI(self, *args)

    def I_pl(self):
        return _clipper.I_sigI_float_I_pl(self)

    def sigI_pl(self):
        return _clipper.I_sigI_float_sigI_pl(self)

    def I_mi(self):
        return _clipper.I_sigI_float_I_mi(self)

    def sigI_mi(self):
        return _clipper.I_sigI_float_sigI_mi(self)

    def cov(self):
        return _clipper.I_sigI_float_cov(self)

    def copy(self):
        return _clipper.I_sigI_float_copy(self)
    __swig_destroy__ = _clipper.delete_I_sigI_float
    __del__ = lambda self: None
I_sigI_float_swigregister = _clipper.I_sigI_float_swigregister
I_sigI_float_swigregister(I_sigI_float)

def I_sigI_float_type():
    return _clipper.I_sigI_float_type()
I_sigI_float_type = _clipper.I_sigI_float_type

def I_sigI_float_data_size():
    return _clipper.I_sigI_float_data_size()
I_sigI_float_data_size = _clipper.I_sigI_float_data_size

def I_sigI_float_data_names():
    return _clipper.I_sigI_float_data_names()
I_sigI_float_data_names = _clipper.I_sigI_float_data_names

class I_sigI_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, I_sigI_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, I_sigI_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_I_sigI_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.I_sigI_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.I_sigI_double_type
    if _newclass:
        type = staticmethod(_clipper.I_sigI_double_type)

    def friedel(self):
        return _clipper.I_sigI_double_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.I_sigI_double_shift_phase(self, arg2)

    def missing(self):
        return _clipper.I_sigI_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.I_sigI_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.I_sigI_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.I_sigI_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.I_sigI_double_data_names)

    def data_export(self, array):
        return _clipper.I_sigI_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.I_sigI_double_data_import(self, array)

    def scale(self, s):
        return _clipper.I_sigI_double_scale(self, s)

    def I(self, *args):
        return _clipper.I_sigI_double_I(self, *args)

    def sigI(self, *args):
        return _clipper.I_sigI_double_sigI(self, *args)

    def I_pl(self):
        return _clipper.I_sigI_double_I_pl(self)

    def sigI_pl(self):
        return _clipper.I_sigI_double_sigI_pl(self)

    def I_mi(self):
        return _clipper.I_sigI_double_I_mi(self)

    def sigI_mi(self):
        return _clipper.I_sigI_double_sigI_mi(self)

    def cov(self):
        return _clipper.I_sigI_double_cov(self)
    __swig_destroy__ = _clipper.delete_I_sigI_double
    __del__ = lambda self: None
I_sigI_double_swigregister = _clipper.I_sigI_double_swigregister
I_sigI_double_swigregister(I_sigI_double)

def I_sigI_double_type():
    return _clipper.I_sigI_double_type()
I_sigI_double_type = _clipper.I_sigI_double_type

def I_sigI_double_data_size():
    return _clipper.I_sigI_double_data_size()
I_sigI_double_data_size = _clipper.I_sigI_double_data_size

def I_sigI_double_data_names():
    return _clipper.I_sigI_double_data_names()
I_sigI_double_data_names = _clipper.I_sigI_double_data_names

class HKL_data_I_sigI_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_I_sigI_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_I_sigI_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_I_sigI_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_I_sigI_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_I_sigI_float_update(self)

    def type(self):
        return _clipper.HKL_data_I_sigI_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_I_sigI_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_I_sigI_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_I_sigI_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_I_sigI_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_I_sigI_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_I_sigI_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_I_sigI_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_I_sigI_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_I_sigI_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_I_sigI_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_I_sigI_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_I_sigI_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_I_sigI_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_I_sigI_float___and__(self, d1)

    def compute_scale_u_iso_isigi(self, scale, u_value, isigi):
        return _clipper.HKL_data_I_sigI_float_compute_scale_u_iso_isigi(self, scale, u_value, isigi)

    def compute_scale_u_aniso_isigi(self, scale, u_value, isigi):
        return _clipper.HKL_data_I_sigI_float_compute_scale_u_aniso_isigi(self, scale, u_value, isigi)

    def copy(self):
        return _clipper.HKL_data_I_sigI_float_copy(self)
    __swig_destroy__ = _clipper.delete_HKL_data_I_sigI_float
    __del__ = lambda self: None
HKL_data_I_sigI_float_swigregister = _clipper.HKL_data_I_sigI_float_swigregister
HKL_data_I_sigI_float_swigregister(HKL_data_I_sigI_float)

class HKL_data_I_sigI_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_I_sigI_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_I_sigI_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_I_sigI_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_I_sigI_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_I_sigI_double_update(self)

    def type(self):
        return _clipper.HKL_data_I_sigI_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_I_sigI_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_I_sigI_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_I_sigI_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_I_sigI_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_I_sigI_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_I_sigI_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_I_sigI_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_I_sigI_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_I_sigI_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_I_sigI_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_I_sigI_double
    __del__ = lambda self: None
HKL_data_I_sigI_double_swigregister = _clipper.HKL_data_I_sigI_double_swigregister
HKL_data_I_sigI_double_swigregister(HKL_data_I_sigI_double)

class E_sigE_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, E_sigE_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, E_sigE_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_E_sigE_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.E_sigE_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.E_sigE_float_type
    if _newclass:
        type = staticmethod(_clipper.E_sigE_float_type)

    def friedel(self):
        return _clipper.E_sigE_float_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.E_sigE_float_shift_phase(self, arg2)

    def missing(self):
        return _clipper.E_sigE_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.E_sigE_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.E_sigE_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.E_sigE_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.E_sigE_float_data_names)

    def data_export(self, array):
        return _clipper.E_sigE_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.E_sigE_float_data_import(self, array)

    def scale(self, s):
        return _clipper.E_sigE_float_scale(self, s)

    def E(self, *args):
        return _clipper.E_sigE_float_E(self, *args)

    def sigE(self, *args):
        return _clipper.E_sigE_float_sigE(self, *args)

    def E_pl(self):
        return _clipper.E_sigE_float_E_pl(self)

    def sigE_pl(self):
        return _clipper.E_sigE_float_sigE_pl(self)

    def E_mi(self):
        return _clipper.E_sigE_float_E_mi(self)

    def sigE_mi(self):
        return _clipper.E_sigE_float_sigE_mi(self)

    def cov(self):
        return _clipper.E_sigE_float_cov(self)

    def copy(self):
        return _clipper.E_sigE_float_copy(self)
    __swig_destroy__ = _clipper.delete_E_sigE_float
    __del__ = lambda self: None
E_sigE_float_swigregister = _clipper.E_sigE_float_swigregister
E_sigE_float_swigregister(E_sigE_float)

def E_sigE_float_type():
    return _clipper.E_sigE_float_type()
E_sigE_float_type = _clipper.E_sigE_float_type

def E_sigE_float_data_size():
    return _clipper.E_sigE_float_data_size()
E_sigE_float_data_size = _clipper.E_sigE_float_data_size

def E_sigE_float_data_names():
    return _clipper.E_sigE_float_data_names()
E_sigE_float_data_names = _clipper.E_sigE_float_data_names

class E_sigE_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, E_sigE_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, E_sigE_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_E_sigE_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.E_sigE_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.E_sigE_double_type
    if _newclass:
        type = staticmethod(_clipper.E_sigE_double_type)

    def friedel(self):
        return _clipper.E_sigE_double_friedel(self)

    def shift_phase(self, arg2):
        return _clipper.E_sigE_double_shift_phase(self, arg2)

    def missing(self):
        return _clipper.E_sigE_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.E_sigE_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.E_sigE_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.E_sigE_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.E_sigE_double_data_names)

    def data_export(self, array):
        return _clipper.E_sigE_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.E_sigE_double_data_import(self, array)

    def scale(self, s):
        return _clipper.E_sigE_double_scale(self, s)

    def E(self, *args):
        return _clipper.E_sigE_double_E(self, *args)

    def sigE(self, *args):
        return _clipper.E_sigE_double_sigE(self, *args)

    def E_pl(self):
        return _clipper.E_sigE_double_E_pl(self)

    def sigE_pl(self):
        return _clipper.E_sigE_double_sigE_pl(self)

    def E_mi(self):
        return _clipper.E_sigE_double_E_mi(self)

    def sigE_mi(self):
        return _clipper.E_sigE_double_sigE_mi(self)

    def cov(self):
        return _clipper.E_sigE_double_cov(self)
    __swig_destroy__ = _clipper.delete_E_sigE_double
    __del__ = lambda self: None
E_sigE_double_swigregister = _clipper.E_sigE_double_swigregister
E_sigE_double_swigregister(E_sigE_double)

def E_sigE_double_type():
    return _clipper.E_sigE_double_type()
E_sigE_double_type = _clipper.E_sigE_double_type

def E_sigE_double_data_size():
    return _clipper.E_sigE_double_data_size()
E_sigE_double_data_size = _clipper.E_sigE_double_data_size

def E_sigE_double_data_names():
    return _clipper.E_sigE_double_data_names()
E_sigE_double_data_names = _clipper.E_sigE_double_data_names

class HKL_data_E_sigE_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_E_sigE_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_E_sigE_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_E_sigE_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_E_sigE_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_E_sigE_float_update(self)

    def type(self):
        return _clipper.HKL_data_E_sigE_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_E_sigE_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_E_sigE_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_E_sigE_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_E_sigE_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_E_sigE_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_E_sigE_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_E_sigE_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_E_sigE_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_E_sigE_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_E_sigE_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_E_sigE_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_E_sigE_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_E_sigE_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_E_sigE_float___and__(self, d1)

    def scaleBySqrtResolution(self, escale):
        return _clipper.HKL_data_E_sigE_float_scaleBySqrtResolution(self, escale)

    def scaleByResolution(self, escale):
        return _clipper.HKL_data_E_sigE_float_scaleByResolution(self, escale)

    def copy(self):
        return _clipper.HKL_data_E_sigE_float_copy(self)

    def compute_from_fsigf(self, fsigf):
        return _clipper.HKL_data_E_sigE_float_compute_from_fsigf(self, fsigf)
    __swig_destroy__ = _clipper.delete_HKL_data_E_sigE_float
    __del__ = lambda self: None
HKL_data_E_sigE_float_swigregister = _clipper.HKL_data_E_sigE_float_swigregister
HKL_data_E_sigE_float_swigregister(HKL_data_E_sigE_float)

class HKL_data_E_sigE_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_E_sigE_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_E_sigE_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_E_sigE_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_E_sigE_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_E_sigE_double_update(self)

    def type(self):
        return _clipper.HKL_data_E_sigE_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_E_sigE_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_E_sigE_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_E_sigE_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_E_sigE_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_E_sigE_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_E_sigE_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_E_sigE_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_E_sigE_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_E_sigE_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_E_sigE_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_E_sigE_double
    __del__ = lambda self: None
HKL_data_E_sigE_double_swigregister = _clipper.HKL_data_E_sigE_double_swigregister
HKL_data_E_sigE_double_swigregister(HKL_data_E_sigE_double)

class ABCD_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ABCD_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ABCD_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_ABCD_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.ABCD_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.ABCD_float_type
    if _newclass:
        type = staticmethod(_clipper.ABCD_float_type)

    def friedel(self):
        return _clipper.ABCD_float_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.ABCD_float_shift_phase(self, dphi)

    def missing(self):
        return _clipper.ABCD_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.ABCD_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.ABCD_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.ABCD_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.ABCD_float_data_names)

    def data_export(self, array):
        return _clipper.ABCD_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.ABCD_float_data_import(self, array)

    def a(self, *args):
        return _clipper.ABCD_float_a(self, *args)

    def b(self, *args):
        return _clipper.ABCD_float_b(self, *args)

    def c(self, *args):
        return _clipper.ABCD_float_c(self, *args)

    def d(self, *args):
        return _clipper.ABCD_float_d(self, *args)

    def __add__(self, h2):
        return _clipper.ABCD_float___add__(self, h2)

    def copy(self):
        return _clipper.ABCD_float_copy(self)
    __swig_destroy__ = _clipper.delete_ABCD_float
    __del__ = lambda self: None
ABCD_float_swigregister = _clipper.ABCD_float_swigregister
ABCD_float_swigregister(ABCD_float)

def ABCD_float_type():
    return _clipper.ABCD_float_type()
ABCD_float_type = _clipper.ABCD_float_type

def ABCD_float_data_size():
    return _clipper.ABCD_float_data_size()
ABCD_float_data_size = _clipper.ABCD_float_data_size

def ABCD_float_data_names():
    return _clipper.ABCD_float_data_names()
ABCD_float_data_names = _clipper.ABCD_float_data_names

class ABCD_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ABCD_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ABCD_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_ABCD_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.ABCD_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.ABCD_double_type
    if _newclass:
        type = staticmethod(_clipper.ABCD_double_type)

    def friedel(self):
        return _clipper.ABCD_double_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.ABCD_double_shift_phase(self, dphi)

    def missing(self):
        return _clipper.ABCD_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.ABCD_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.ABCD_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.ABCD_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.ABCD_double_data_names)

    def data_export(self, array):
        return _clipper.ABCD_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.ABCD_double_data_import(self, array)

    def a(self, *args):
        return _clipper.ABCD_double_a(self, *args)

    def b(self, *args):
        return _clipper.ABCD_double_b(self, *args)

    def c(self, *args):
        return _clipper.ABCD_double_c(self, *args)

    def d(self, *args):
        return _clipper.ABCD_double_d(self, *args)
    __swig_destroy__ = _clipper.delete_ABCD_double
    __del__ = lambda self: None
ABCD_double_swigregister = _clipper.ABCD_double_swigregister
ABCD_double_swigregister(ABCD_double)

def ABCD_double_type():
    return _clipper.ABCD_double_type()
ABCD_double_type = _clipper.ABCD_double_type

def ABCD_double_data_size():
    return _clipper.ABCD_double_data_size()
ABCD_double_data_size = _clipper.ABCD_double_data_size

def ABCD_double_data_names():
    return _clipper.ABCD_double_data_names()
ABCD_double_data_names = _clipper.ABCD_double_data_names

class HKL_data_ABCD_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_ABCD_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_ABCD_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_ABCD_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_ABCD_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_ABCD_float_update(self)

    def type(self):
        return _clipper.HKL_data_ABCD_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_ABCD_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_ABCD_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_ABCD_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_ABCD_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_ABCD_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_ABCD_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_ABCD_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_ABCD_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_ABCD_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_ABCD_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_ABCD_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_ABCD_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_ABCD_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_ABCD_float___and__(self, d1)

    def __add__(self, h2):
        return _clipper.HKL_data_ABCD_float___add__(self, h2)

    def copy(self):
        return _clipper.HKL_data_ABCD_float_copy(self)

    def compute_from_phi_fom(self, phiw):
        return _clipper.HKL_data_ABCD_float_compute_from_phi_fom(self, phiw)

    def compute_add_abcd(self, abcd1, abcd2):
        return _clipper.HKL_data_ABCD_float_compute_add_abcd(self, abcd1, abcd2)
    __swig_destroy__ = _clipper.delete_HKL_data_ABCD_float
    __del__ = lambda self: None
HKL_data_ABCD_float_swigregister = _clipper.HKL_data_ABCD_float_swigregister
HKL_data_ABCD_float_swigregister(HKL_data_ABCD_float)

class HKL_data_ABCD_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_ABCD_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_ABCD_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_ABCD_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_ABCD_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_ABCD_double_update(self)

    def type(self):
        return _clipper.HKL_data_ABCD_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_ABCD_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_ABCD_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_ABCD_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_ABCD_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_ABCD_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_ABCD_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_ABCD_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_ABCD_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_ABCD_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_ABCD_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_ABCD_double
    __del__ = lambda self: None
HKL_data_ABCD_double_swigregister = _clipper.HKL_data_ABCD_double_swigregister
HKL_data_ABCD_double_swigregister(HKL_data_ABCD_double)

class Phi_fom_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Phi_fom_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Phi_fom_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Phi_fom_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.Phi_fom_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.Phi_fom_float_type
    if _newclass:
        type = staticmethod(_clipper.Phi_fom_float_type)

    def friedel(self):
        return _clipper.Phi_fom_float_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.Phi_fom_float_shift_phase(self, dphi)

    def missing(self):
        return _clipper.Phi_fom_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.Phi_fom_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.Phi_fom_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.Phi_fom_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.Phi_fom_float_data_names)

    def data_export(self, array):
        return _clipper.Phi_fom_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.Phi_fom_float_data_import(self, array)

    def phi(self, *args):
        return _clipper.Phi_fom_float_phi(self, *args)

    def fom(self, *args):
        return _clipper.Phi_fom_float_fom(self, *args)
    __swig_destroy__ = _clipper.delete_Phi_fom_float
    __del__ = lambda self: None
Phi_fom_float_swigregister = _clipper.Phi_fom_float_swigregister
Phi_fom_float_swigregister(Phi_fom_float)

def Phi_fom_float_type():
    return _clipper.Phi_fom_float_type()
Phi_fom_float_type = _clipper.Phi_fom_float_type

def Phi_fom_float_data_size():
    return _clipper.Phi_fom_float_data_size()
Phi_fom_float_data_size = _clipper.Phi_fom_float_data_size

def Phi_fom_float_data_names():
    return _clipper.Phi_fom_float_data_names()
Phi_fom_float_data_names = _clipper.Phi_fom_float_data_names

class Phi_fom_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Phi_fom_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Phi_fom_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Phi_fom_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_null(self):
        return _clipper.Phi_fom_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.Phi_fom_double_type
    if _newclass:
        type = staticmethod(_clipper.Phi_fom_double_type)

    def friedel(self):
        return _clipper.Phi_fom_double_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.Phi_fom_double_shift_phase(self, dphi)

    def missing(self):
        return _clipper.Phi_fom_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.Phi_fom_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.Phi_fom_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.Phi_fom_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.Phi_fom_double_data_names)

    def data_export(self, array):
        return _clipper.Phi_fom_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.Phi_fom_double_data_import(self, array)

    def phi(self, *args):
        return _clipper.Phi_fom_double_phi(self, *args)

    def fom(self, *args):
        return _clipper.Phi_fom_double_fom(self, *args)
    __swig_destroy__ = _clipper.delete_Phi_fom_double
    __del__ = lambda self: None
Phi_fom_double_swigregister = _clipper.Phi_fom_double_swigregister
Phi_fom_double_swigregister(Phi_fom_double)

def Phi_fom_double_type():
    return _clipper.Phi_fom_double_type()
Phi_fom_double_type = _clipper.Phi_fom_double_type

def Phi_fom_double_data_size():
    return _clipper.Phi_fom_double_data_size()
Phi_fom_double_data_size = _clipper.Phi_fom_double_data_size

def Phi_fom_double_data_names():
    return _clipper.Phi_fom_double_data_names()
Phi_fom_double_data_names = _clipper.Phi_fom_double_data_names

class HKL_data_Phi_fom_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_Phi_fom_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_Phi_fom_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_Phi_fom_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_Phi_fom_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_Phi_fom_float_update(self)

    def type(self):
        return _clipper.HKL_data_Phi_fom_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_Phi_fom_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_Phi_fom_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_Phi_fom_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_Phi_fom_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_Phi_fom_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_Phi_fom_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_Phi_fom_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_Phi_fom_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_Phi_fom_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_Phi_fom_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_Phi_fom_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_Phi_fom_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_Phi_fom_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_Phi_fom_float___and__(self, d1)

    def compute_from_abcd(self, abcd):
        return _clipper.HKL_data_Phi_fom_float_compute_from_abcd(self, abcd)

    def copy(self):
        return _clipper.HKL_data_Phi_fom_float_copy(self)
    __swig_destroy__ = _clipper.delete_HKL_data_Phi_fom_float
    __del__ = lambda self: None
HKL_data_Phi_fom_float_swigregister = _clipper.HKL_data_Phi_fom_float_swigregister
HKL_data_Phi_fom_float_swigregister(HKL_data_Phi_fom_float)

class HKL_data_Phi_fom_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_Phi_fom_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_Phi_fom_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_Phi_fom_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_Phi_fom_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_Phi_fom_double_update(self)

    def type(self):
        return _clipper.HKL_data_Phi_fom_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_Phi_fom_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_Phi_fom_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_Phi_fom_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_Phi_fom_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_Phi_fom_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_Phi_fom_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_Phi_fom_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_Phi_fom_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_Phi_fom_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_Phi_fom_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_Phi_fom_double
    __del__ = lambda self: None
HKL_data_Phi_fom_double_swigregister = _clipper.HKL_data_Phi_fom_double_swigregister
HKL_data_Phi_fom_double_swigregister(HKL_data_Phi_fom_double)

class F_phi_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_phi_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_phi_float, name)
    __repr__ = _swig_repr

    def set_null(self):
        return _clipper.F_phi_float_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_phi_float_type
    if _newclass:
        type = staticmethod(_clipper.F_phi_float_type)

    def friedel(self):
        return _clipper.F_phi_float_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.F_phi_float_shift_phase(self, dphi)

    def missing(self):
        return _clipper.F_phi_float_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_phi_float_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_phi_float_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_phi_float_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_phi_float_data_names)

    def data_export(self, array):
        return _clipper.F_phi_float_data_export(self, array)

    def data_import(self, array):
        return _clipper.F_phi_float_data_import(self, array)

    def scale(self, s):
        return _clipper.F_phi_float_scale(self, s)

    def f(self, *args):
        return _clipper.F_phi_float_f(self, *args)

    def phi(self, *args):
        return _clipper.F_phi_float_phi(self, *args)

    def a(self):
        return _clipper.F_phi_float_a(self)

    def b(self):
        return _clipper.F_phi_float_b(self)

    def __init__(self, *args):
        this = _clipper.new_F_phi_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def resolve(self, phi):
        return _clipper.F_phi_float_resolve(self, phi)

    def norm(self):
        return _clipper.F_phi_float_norm(self)

    def __add__(self, h2):
        return _clipper.F_phi_float___add__(self, h2)

    def __sub__(self, h2):
        return _clipper.F_phi_float___sub__(self, h2)

    def __neg__(self):
        return _clipper.F_phi_float___neg__(self)

    def copy(self):
        return _clipper.F_phi_float_copy(self)
    __swig_destroy__ = _clipper.delete_F_phi_float
    __del__ = lambda self: None
F_phi_float_swigregister = _clipper.F_phi_float_swigregister
F_phi_float_swigregister(F_phi_float)

def F_phi_float_type():
    return _clipper.F_phi_float_type()
F_phi_float_type = _clipper.F_phi_float_type

def F_phi_float_data_size():
    return _clipper.F_phi_float_data_size()
F_phi_float_data_size = _clipper.F_phi_float_data_size

def F_phi_float_data_names():
    return _clipper.F_phi_float_data_names()
F_phi_float_data_names = _clipper.F_phi_float_data_names

class F_phi_double(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_phi_double, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_phi_double, name)
    __repr__ = _swig_repr

    def set_null(self):
        return _clipper.F_phi_double_set_null(self)
    __swig_getmethods__["type"] = lambda x: _clipper.F_phi_double_type
    if _newclass:
        type = staticmethod(_clipper.F_phi_double_type)

    def friedel(self):
        return _clipper.F_phi_double_friedel(self)

    def shift_phase(self, dphi):
        return _clipper.F_phi_double_shift_phase(self, dphi)

    def missing(self):
        return _clipper.F_phi_double_missing(self)
    __swig_getmethods__["data_size"] = lambda x: _clipper.F_phi_double_data_size
    if _newclass:
        data_size = staticmethod(_clipper.F_phi_double_data_size)
    __swig_getmethods__["data_names"] = lambda x: _clipper.F_phi_double_data_names
    if _newclass:
        data_names = staticmethod(_clipper.F_phi_double_data_names)

    def data_export(self, array):
        return _clipper.F_phi_double_data_export(self, array)

    def data_import(self, array):
        return _clipper.F_phi_double_data_import(self, array)

    def scale(self, s):
        return _clipper.F_phi_double_scale(self, s)

    def f(self, *args):
        return _clipper.F_phi_double_f(self, *args)

    def phi(self, *args):
        return _clipper.F_phi_double_phi(self, *args)

    def a(self):
        return _clipper.F_phi_double_a(self)

    def b(self):
        return _clipper.F_phi_double_b(self)

    def __init__(self, *args):
        this = _clipper.new_F_phi_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def resolve(self, phi):
        return _clipper.F_phi_double_resolve(self, phi)

    def norm(self):
        return _clipper.F_phi_double_norm(self)
    __swig_destroy__ = _clipper.delete_F_phi_double
    __del__ = lambda self: None
F_phi_double_swigregister = _clipper.F_phi_double_swigregister
F_phi_double_swigregister(F_phi_double)

def F_phi_double_type():
    return _clipper.F_phi_double_type()
F_phi_double_type = _clipper.F_phi_double_type

def F_phi_double_data_size():
    return _clipper.F_phi_double_data_size()
F_phi_double_data_size = _clipper.F_phi_double_data_size

def F_phi_double_data_names():
    return _clipper.F_phi_double_data_names()
F_phi_double_data_names = _clipper.F_phi_double_data_names

class HKL_data_F_phi_float(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_phi_float, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_phi_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_phi_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_phi_float_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_phi_float_update(self)

    def type(self):
        return _clipper.HKL_data_F_phi_float_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_phi_float_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_phi_float_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_phi_float_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_phi_float_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_phi_float_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_phi_float_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_phi_float_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_phi_float_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_phi_float_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_phi_float_debug(self)

    def not_(self):
        return _clipper.HKL_data_F_phi_float_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_F_phi_float___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_F_phi_float___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_F_phi_float___and__(self, d1)

    def copy(self):
        return _clipper.HKL_data_F_phi_float_copy(self)

    def __add__(self, h2):
        return _clipper.HKL_data_F_phi_float___add__(self, h2)

    def __sub__(self, h2):
        return _clipper.HKL_data_F_phi_float___sub__(self, h2)

    def __neg__(self):
        return _clipper.HKL_data_F_phi_float___neg__(self)

    def __mul__(self, s):
        return _clipper.HKL_data_F_phi_float___mul__(self, s)

    def compute_neg(self, fphi):
        return _clipper.HKL_data_F_phi_float_compute_neg(self, fphi)

    def compute_add_fphi(self, fphi1, fphi2):
        return _clipper.HKL_data_F_phi_float_compute_add_fphi(self, fphi1, fphi2)

    def compute_sub_fphi(self, fphi1, fphi2):
        return _clipper.HKL_data_F_phi_float_compute_sub_fphi(self, fphi1, fphi2)

    def compute_from_fsigf_phifom(self, fsigf, phifom):
        return _clipper.HKL_data_F_phi_float_compute_from_fsigf_phifom(self, fsigf, phifom)

    def compute_scale_u_iso_fphi(self, scale, u_value, fphi):
        return _clipper.HKL_data_F_phi_float_compute_scale_u_iso_fphi(self, scale, u_value, fphi)

    def compute_scale_u_aniso_fphi(self, scale, u_value, fphi):
        return _clipper.HKL_data_F_phi_float_compute_scale_u_aniso_fphi(self, scale, u_value, fphi)

    def getDataNumpy(self, test_numpy_a):
        return _clipper.HKL_data_F_phi_float_getDataNumpy(self, test_numpy_a)

    def getData(self):
        return _clipper.HKL_data_F_phi_float_getData(self)

    def __getitem__(self, i):
        return _clipper.HKL_data_F_phi_float___getitem__(self, i)

    def __len__(self):
        return _clipper.HKL_data_F_phi_float___len__(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_phi_float
    __del__ = lambda self: None
HKL_data_F_phi_float_swigregister = _clipper.HKL_data_F_phi_float_swigregister
HKL_data_F_phi_float_swigregister(HKL_data_F_phi_float)

class HKL_data_F_phi_double(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_F_phi_double, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_F_phi_double, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_F_phi_double(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_F_phi_double_init(self, *args)

    def update(self):
        return _clipper.HKL_data_F_phi_double_update(self)

    def type(self):
        return _clipper.HKL_data_F_phi_double_type(self)

    def missing(self, index):
        return _clipper.HKL_data_F_phi_double_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_F_phi_double_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_F_phi_double_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_F_phi_double_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_F_phi_double_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_F_phi_double_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_F_phi_double_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_F_phi_double_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_F_phi_double_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_F_phi_double_debug(self)
    __swig_destroy__ = _clipper.delete_HKL_data_F_phi_double
    __del__ = lambda self: None
HKL_data_F_phi_double_swigregister = _clipper.HKL_data_F_phi_double_swigregister
HKL_data_F_phi_double_swigregister(HKL_data_F_phi_double)

class HKL_data_Flag(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_Flag, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_Flag, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_Flag(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_Flag_init(self, *args)

    def update(self):
        return _clipper.HKL_data_Flag_update(self)

    def type(self):
        return _clipper.HKL_data_Flag_type(self)

    def missing(self, index):
        return _clipper.HKL_data_Flag_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_Flag_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_Flag_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_Flag_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_Flag_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_Flag_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_Flag_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_Flag_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_Flag_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_Flag_debug(self)

    def not_(self):
        return _clipper.HKL_data_Flag_not_(self)

    def __or__(self, d1):
        return _clipper.HKL_data_Flag___or__(self, d1)

    def __xor__(self, d1):
        return _clipper.HKL_data_Flag___xor__(self, d1)

    def __and__(self, d1):
        return _clipper.HKL_data_Flag___and__(self, d1)

    def __eq__(self, n):
        return _clipper.HKL_data_Flag___eq__(self, n)

    def __ne__(self, n):
        return _clipper.HKL_data_Flag___ne__(self, n)

    def __ge__(self, n):
        return _clipper.HKL_data_Flag___ge__(self, n)

    def __le__(self, n):
        return _clipper.HKL_data_Flag___le__(self, n)

    def __gt__(self, n):
        return _clipper.HKL_data_Flag___gt__(self, n)

    def __lt__(self, n):
        return _clipper.HKL_data_Flag___lt__(self, n)

    def copy(self):
        return _clipper.HKL_data_Flag_copy(self)

    def __getitem__(self, i):
        return _clipper.HKL_data_Flag___getitem__(self, i)

    def __len__(self):
        return _clipper.HKL_data_Flag___len__(self)
    __swig_destroy__ = _clipper.delete_HKL_data_Flag
    __del__ = lambda self: None
HKL_data_Flag_swigregister = _clipper.HKL_data_Flag_swigregister
HKL_data_Flag_swigregister(HKL_data_Flag)

class HKL_data_Flag_bool(HKL_data_base):
    __swig_setmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HKL_data_Flag_bool, name, value)
    __swig_getmethods__ = {}
    for _s in [HKL_data_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HKL_data_Flag_bool, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_HKL_data_Flag_bool(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.HKL_data_Flag_bool_init(self, *args)

    def update(self):
        return _clipper.HKL_data_Flag_bool_update(self)

    def type(self):
        return _clipper.HKL_data_Flag_bool_type(self)

    def missing(self, index):
        return _clipper.HKL_data_Flag_bool_missing(self, index)

    def set_null(self, index):
        return _clipper.HKL_data_Flag_bool_set_null(self, index)

    def data_size(self):
        return _clipper.HKL_data_Flag_bool_data_size(self)

    def data_names(self):
        return _clipper.HKL_data_Flag_bool_data_names(self)

    def data_export(self, hkl, array):
        return _clipper.HKL_data_Flag_bool_data_export(self, hkl, array)

    def data_import(self, hkl, array):
        return _clipper.HKL_data_Flag_bool_data_import(self, hkl, array)

    def mask(self, mask):
        return _clipper.HKL_data_Flag_bool_mask(self, mask)

    def get_data(self, *args):
        return _clipper.HKL_data_Flag_bool_get_data(self, *args)

    def set_data(self, *args):
        return _clipper.HKL_data_Flag_bool_set_data(self, *args)

    def debug(self):
        return _clipper.HKL_data_Flag_bool_debug(self)

    def __getitem__(self, i):
        return _clipper.HKL_data_Flag_bool___getitem__(self, i)

    def __len__(self):
        return _clipper.HKL_data_Flag_bool___len__(self)
    __swig_destroy__ = _clipper.delete_HKL_data_Flag_bool
    __del__ = lambda self: None
HKL_data_Flag_bool_swigregister = _clipper.HKL_data_Flag_bool_swigregister
HKL_data_Flag_bool_swigregister(HKL_data_Flag_bool)

class Prob_phi_2d(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Prob_phi_2d, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Prob_phi_2d, name)
    __repr__ = _swig_repr

    def init(self, size):
        return _clipper.Prob_phi_2d_init(self, size)

    def accumulate(self, *args):
        return _clipper.Prob_phi_2d_accumulate(self, *args)

    def normalise(self):
        return _clipper.Prob_phi_2d_normalise(self)

    def probability(self, phi1, phi2):
        return _clipper.Prob_phi_2d_probability(self, phi1, phi2)

    def format(self):
        return _clipper.Prob_phi_2d_format(self)

    def data(self, *args):
        return _clipper.Prob_phi_2d_data(self, *args)

    def __init__(self):
        this = _clipper.new_Prob_phi_2d()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Prob_phi_2d
    __del__ = lambda self: None
Prob_phi_2d_swigregister = _clipper.Prob_phi_2d_swigregister
Prob_phi_2d_swigregister(Prob_phi_2d)

class Ramachandran(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ramachandran, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Ramachandran, name)
    __repr__ = _swig_repr
    Gly = _clipper.Ramachandran_Gly
    Pro = _clipper.Ramachandran_Pro
    NonGlyPro = _clipper.Ramachandran_NonGlyPro
    NonGly = _clipper.Ramachandran_NonGly
    All = _clipper.Ramachandran_All
    Gly5 = _clipper.Ramachandran_Gly5
    Pro5 = _clipper.Ramachandran_Pro5
    NonGlyPro5 = _clipper.Ramachandran_NonGlyPro5
    NonGly5 = _clipper.Ramachandran_NonGly5
    All5 = _clipper.Ramachandran_All5

    def __init__(self, *args):
        this = _clipper.new_Ramachandran(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, type):
        return _clipper.Ramachandran_init(self, type)

    def set_thresholds(self, prob_favored=0.01, prob_allowed=0.0005):
        return _clipper.Ramachandran_set_thresholds(self, prob_favored, prob_allowed)

    def probability(self, phi, psi):
        return _clipper.Ramachandran_probability(self, phi, psi)

    def favored(self, phi, psi):
        return _clipper.Ramachandran_favored(self, phi, psi)

    def allowed(self, phi, psi):
        return _clipper.Ramachandran_allowed(self, phi, psi)
    __swig_destroy__ = _clipper.delete_Ramachandran
    __del__ = lambda self: None
Ramachandran_swigregister = _clipper.Ramachandran_swigregister
Ramachandran_swigregister(Ramachandran)

class CIFfile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIFfile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CIFfile, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_CIFfile()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_CIFfile
    __del__ = lambda self: None

    def open_read(self, filename_in):
        return _clipper.CIFfile_open_read(self, filename_in)

    def close_read(self):
        return _clipper.CIFfile_close_read(self)

    def spacegroup(self):
        return _clipper.CIFfile_spacegroup(self)

    def cell(self):
        return _clipper.CIFfile_cell(self)

    def hkl_sampling(self):
        return _clipper.CIFfile_hkl_sampling(self)

    def resolution(self, *args):
        return _clipper.CIFfile_resolution(self, *args)

    def import_hkl_info(self, target):
        return _clipper.CIFfile_import_hkl_info(self, target)

    def import_hkl_data(self, cdata):
        return _clipper.CIFfile_import_hkl_data(self, cdata)

    def contains_phases_p(self):
        return _clipper.CIFfile_contains_phases_p(self)
CIFfile_swigregister = _clipper.CIFfile_swigregister
CIFfile_swigregister(CIFfile)

class SFcalc_obs_bulk_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_obs_bulk_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_obs_bulk_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFcalc_obs_bulk_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, fphi, fsig, atoms):
        return _clipper.SFcalc_obs_bulk_float___call__(self, fphi, fsig, atoms)

    def bulk_frac(self):
        return _clipper.SFcalc_obs_bulk_float_bulk_frac(self)

    def bulk_scale(self):
        return _clipper.SFcalc_obs_bulk_float_bulk_scale(self)
    __swig_destroy__ = _clipper.delete_SFcalc_obs_bulk_float
    __del__ = lambda self: None
SFcalc_obs_bulk_float_swigregister = _clipper.SFcalc_obs_bulk_float_swigregister
SFcalc_obs_bulk_float_swigregister(SFcalc_obs_bulk_float)

class SFweight_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFweight_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SFweight_base_float, name)
    __repr__ = _swig_repr
    NONE = _clipper.SFweight_base_float_NONE
    SIGMAA = _clipper.SFweight_base_float_SIGMAA
    SCALE = _clipper.SFweight_base_float_SCALE
    BOTH = _clipper.SFweight_base_float_BOTH

    def __call__(self, fb, fd, phiw, fo, fc, usage):
        return _clipper.SFweight_base_float___call__(self, fb, fd, phiw, fo, fc, usage)
    __swig_destroy__ = _clipper.delete_SFweight_base_float
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == SFweight_base_float:
            _self = None
        else:
            _self = self
        this = _clipper.new_SFweight_base_float(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_SFweight_base_float(self)
        return weakref_proxy(self)
SFweight_base_float_swigregister = _clipper.SFweight_base_float_swigregister
SFweight_base_float_swigregister(SFweight_base_float)

class SFcalc_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_base_float, name)
    __repr__ = _swig_repr

    def __call__(self, fphidata, atoms):
        return _clipper.SFcalc_base_float___call__(self, fphidata, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_base_float
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == SFcalc_base_float:
            _self = None
        else:
            _self = self
        this = _clipper.new_SFcalc_base_float(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_SFcalc_base_float(self)
        return weakref_proxy(self)
SFcalc_base_float_swigregister = _clipper.SFcalc_base_float_swigregister
SFcalc_base_float_swigregister(SFcalc_base_float)

class EDcalc_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDcalc_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EDcalc_base_float, name)
    __repr__ = _swig_repr

    def __call__(self, *args):
        return _clipper.EDcalc_base_float___call__(self, *args)
    __swig_destroy__ = _clipper.delete_EDcalc_base_float
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == EDcalc_base_float:
            _self = None
        else:
            _self = self
        this = _clipper.new_EDcalc_base_float(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_EDcalc_base_float(self)
        return weakref_proxy(self)
EDcalc_base_float_swigregister = _clipper.EDcalc_base_float_swigregister
EDcalc_base_float_swigregister(EDcalc_base_float)

class SFcalc_obs_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_obs_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_obs_base_float, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, fphi, fsig, atoms):
        return _clipper.SFcalc_obs_base_float___call__(self, fphi, fsig, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_obs_base_float
    __del__ = lambda self: None
SFcalc_obs_base_float_swigregister = _clipper.SFcalc_obs_base_float_swigregister
SFcalc_obs_base_float_swigregister(SFcalc_obs_base_float)

class SFscale_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFscale_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SFscale_base_float, name)
    __repr__ = _swig_repr

    def __call__(self, *args):
        return _clipper.SFscale_base_float___call__(self, *args)
    __swig_destroy__ = _clipper.delete_SFscale_base_float
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == SFscale_base_float:
            _self = None
        else:
            _self = self
        this = _clipper.new_SFscale_base_float(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_SFscale_base_float(self)
        return weakref_proxy(self)
SFscale_base_float_swigregister = _clipper.SFscale_base_float_swigregister
SFscale_base_float_swigregister(SFscale_base_float)

class MapFilter_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilter_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilter_base_float, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, result, xmap):
        return _clipper.MapFilter_base_float___call__(self, result, xmap)
    __swig_destroy__ = _clipper.delete_MapFilter_base_float
    __del__ = lambda self: None
MapFilter_base_float_swigregister = _clipper.MapFilter_base_float_swigregister
MapFilter_base_float_swigregister(MapFilter_base_float)

class Convolution_search_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Convolution_search_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Convolution_search_base_float, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, result, srchval, nxop):
        return _clipper.Convolution_search_base_float___call__(self, result, srchval, nxop)
    __swig_destroy__ = _clipper.delete_Convolution_search_base_float
    __del__ = lambda self: None
Convolution_search_base_float_swigregister = _clipper.Convolution_search_base_float_swigregister
Convolution_search_base_float_swigregister(Convolution_search_base_float)

class FFFear_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FFFear_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FFFear_base_float, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, result, srchval, srchwgt, nxop):
        return _clipper.FFFear_base_float___call__(self, result, srchval, srchwgt, nxop)
    __swig_destroy__ = _clipper.delete_FFFear_base_float
    __del__ = lambda self: None
FFFear_base_float_swigregister = _clipper.FFFear_base_float_swigregister
FFFear_base_float_swigregister(FFFear_base_float)

class Skeleton_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Skeleton_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Skeleton_base_float, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, xskl, xmap):
        return _clipper.Skeleton_base_float___call__(self, xskl, xmap)
    __swig_destroy__ = _clipper.delete_Skeleton_base_float
    __del__ = lambda self: None
Skeleton_base_float_swigregister = _clipper.Skeleton_base_float_swigregister
Skeleton_base_float_swigregister(Skeleton_base_float)

class OriginMatch_base_float(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OriginMatch_base_float, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OriginMatch_base_float, name)
    __repr__ = _swig_repr

    def __call__(self, invert, shift, fphi1, fphi2):
        return _clipper.OriginMatch_base_float___call__(self, invert, shift, fphi1, fphi2)
    __swig_destroy__ = _clipper.delete_OriginMatch_base_float
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == OriginMatch_base_float:
            _self = None
        else:
            _self = self
        this = _clipper.new_OriginMatch_base_float(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_OriginMatch_base_float(self)
        return weakref_proxy(self)
OriginMatch_base_float_swigregister = _clipper.OriginMatch_base_float_swigregister
OriginMatch_base_float_swigregister(OriginMatch_base_float)

class SFscale_aniso_float(SFscale_base_float):
    __swig_setmethods__ = {}
    for _s in [SFscale_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFscale_aniso_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFscale_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFscale_aniso_float, name)
    __repr__ = _swig_repr
    SFscale_aniso_F_float = _clipper.SFscale_aniso_float_SFscale_aniso_F_float
    SFscale_aniso_I_float = _clipper.SFscale_aniso_float_SFscale_aniso_I_float
    SFscale_aniso_NORMAL_float = _clipper.SFscale_aniso_float_SFscale_aniso_NORMAL_float
    SFscale_aniso_SHARPEN_float = _clipper.SFscale_aniso_float_SFscale_aniso_SHARPEN_float
    SFscale_aniso_UNSHARPEN_float = _clipper.SFscale_aniso_float_SFscale_aniso_UNSHARPEN_float

    def __init__(self, *args):
        this = _clipper.new_SFscale_aniso_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, *args):
        return _clipper.SFscale_aniso_float___call__(self, *args)

    def u_aniso_orth(self, *args):
        return _clipper.SFscale_aniso_float_u_aniso_orth(self, *args)
    __swig_destroy__ = _clipper.delete_SFscale_aniso_float
    __del__ = lambda self: None
SFscale_aniso_float_swigregister = _clipper.SFscale_aniso_float_swigregister
SFscale_aniso_float_swigregister(SFscale_aniso_float)

class SFweight_spline_float(SFweight_base_float):
    __swig_setmethods__ = {}
    for _s in [SFweight_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFweight_spline_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFweight_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFweight_spline_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFweight_spline_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, n_reflns=1000, n_params=20, n_phases=24):
        return _clipper.SFweight_spline_float_init(self, n_reflns, n_params, n_phases)

    def __call__(self, *args):
        return _clipper.SFweight_spline_float___call__(self, *args)

    def params_scale(self):
        return _clipper.SFweight_spline_float_params_scale(self)

    def params_error(self):
        return _clipper.SFweight_spline_float_params_error(self)

    def log_likelihood_work(self):
        return _clipper.SFweight_spline_float_log_likelihood_work(self)

    def log_likelihood_free(self):
        return _clipper.SFweight_spline_float_log_likelihood_free(self)

    def debug(self):
        return _clipper.SFweight_spline_float_debug(self)

    def targetfn(self, cls, fo0, fc0, s, w):
        return _clipper.SFweight_spline_float_targetfn(self, cls, fo0, fc0, s, w)

    def targethl(self, cls, fo0, hl0, fc0, s, w):
        return _clipper.SFweight_spline_float_targethl(self, cls, fo0, hl0, fc0, s, w)
    __swig_destroy__ = _clipper.delete_SFweight_spline_float
    __del__ = lambda self: None
SFweight_spline_float_swigregister = _clipper.SFweight_spline_float_swigregister
SFweight_spline_float_swigregister(SFweight_spline_float)

class SFcalc_iso_sum_float(SFcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_iso_sum_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_iso_sum_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFcalc_iso_sum_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, fphidata, atoms):
        return _clipper.SFcalc_iso_sum_float___call__(self, fphidata, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_iso_sum_float
    __del__ = lambda self: None
SFcalc_iso_sum_float_swigregister = _clipper.SFcalc_iso_sum_float_swigregister
SFcalc_iso_sum_float_swigregister(SFcalc_iso_sum_float)

class SFcalc_aniso_sum_float(SFcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_aniso_sum_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_aniso_sum_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFcalc_aniso_sum_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, fphidata, atoms):
        return _clipper.SFcalc_aniso_sum_float___call__(self, fphidata, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_aniso_sum_float
    __del__ = lambda self: None
SFcalc_aniso_sum_float_swigregister = _clipper.SFcalc_aniso_sum_float_swigregister
SFcalc_aniso_sum_float_swigregister(SFcalc_aniso_sum_float)

class SFcalc_iso_fft_float(SFcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_iso_fft_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_iso_fft_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFcalc_iso_fft_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, fphidata, atoms):
        return _clipper.SFcalc_iso_fft_float___call__(self, fphidata, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_iso_fft_float
    __del__ = lambda self: None
SFcalc_iso_fft_float_swigregister = _clipper.SFcalc_iso_fft_float_swigregister
SFcalc_iso_fft_float_swigregister(SFcalc_iso_fft_float)

class SFcalc_aniso_fft_float(SFcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SFcalc_aniso_fft_float, name, value)
    __swig_getmethods__ = {}
    for _s in [SFcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SFcalc_aniso_fft_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_SFcalc_aniso_fft_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, fphidata, atoms):
        return _clipper.SFcalc_aniso_fft_float___call__(self, fphidata, atoms)
    __swig_destroy__ = _clipper.delete_SFcalc_aniso_fft_float
    __del__ = lambda self: None
SFcalc_aniso_fft_float_swigregister = _clipper.SFcalc_aniso_fft_float_swigregister
SFcalc_aniso_fft_float_swigregister(SFcalc_aniso_fft_float)


def CopyOverHKLInfo(*args):
    return _clipper.CopyOverHKLInfo(*args)
CopyOverHKLInfo = _clipper.CopyOverHKLInfo

def CopyIfF_sigFRefNotMissingF_sigF_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingF_sigF_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingF_sigF_float = _clipper.CopyIfF_sigFRefNotMissingF_sigF_float

def CopyIfF_sigFRefNotMissingF_sigF_ano_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingF_sigF_ano_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingF_sigF_ano_float = _clipper.CopyIfF_sigFRefNotMissingF_sigF_ano_float

def CopyIfF_sigFRefNotMissingE_sigE_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingE_sigE_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingE_sigE_float = _clipper.CopyIfF_sigFRefNotMissingE_sigE_float

def CopyIfF_sigFRefNotMissingABCD_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingABCD_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingABCD_float = _clipper.CopyIfF_sigFRefNotMissingABCD_float

def CopyIfF_sigFRefNotMissingPhi_fom_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingPhi_fom_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingPhi_fom_float = _clipper.CopyIfF_sigFRefNotMissingPhi_fom_float

def CopyIfF_sigFRefNotMissingF_phi_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingF_phi_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingF_phi_float = _clipper.CopyIfF_sigFRefNotMissingF_phi_float

def CopyIfF_sigFRefNotMissingFlag_float(d_in, d_out, d_ref):
    return _clipper.CopyIfF_sigFRefNotMissingFlag_float(d_in, d_out, d_ref)
CopyIfF_sigFRefNotMissingFlag_float = _clipper.CopyIfF_sigFRefNotMissingFlag_float

def PopulateMatchesF_sigF_float(d_ref, d, matched):
    return _clipper.PopulateMatchesF_sigF_float(d_ref, d, matched)
PopulateMatchesF_sigF_float = _clipper.PopulateMatchesF_sigF_float

def PopulateMatchesE_sigE_float(d_ref, d, matched):
    return _clipper.PopulateMatchesE_sigE_float(d_ref, d, matched)
PopulateMatchesE_sigE_float = _clipper.PopulateMatchesE_sigE_float

def PopulateMatchesABCD_float(d_ref, d, matched):
    return _clipper.PopulateMatchesABCD_float(d_ref, d, matched)
PopulateMatchesABCD_float = _clipper.PopulateMatchesABCD_float

def PopulateMatchesPhi_fom_float(d_ref, d, matched):
    return _clipper.PopulateMatchesPhi_fom_float(d_ref, d, matched)
PopulateMatchesPhi_fom_float = _clipper.PopulateMatchesPhi_fom_float

def PopulateMatchesF_phi_float(d_ref, d, matched):
    return _clipper.PopulateMatchesF_phi_float(d_ref, d, matched)
PopulateMatchesF_phi_float = _clipper.PopulateMatchesF_phi_float

def PopulateMatchesFlag_float(d_ref, d, matched):
    return _clipper.PopulateMatchesFlag_float(d_ref, d, matched)
PopulateMatchesFlag_float = _clipper.PopulateMatchesFlag_float

def SetFlagBoth(flag):
    return _clipper.SetFlagBoth(flag)
SetFlagBoth = _clipper.SetFlagBoth

def SetFlagBothIfMissing(flag, myfsigf, status, freeflag):
    return _clipper.SetFlagBothIfMissing(flag, myfsigf, status, freeflag)
SetFlagBothIfMissing = _clipper.SetFlagBothIfMissing

def SetData(F1, F2, CHECK, OPS, ELSE_OPS):
    return _clipper.SetData(F1, F2, CHECK, OPS, ELSE_OPS)
SetData = _clipper.SetData
class EDcalc_mask_float(EDcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDcalc_mask_float, name, value)
    __swig_getmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EDcalc_mask_float, name)
    __repr__ = _swig_repr

    def __init__(self, radius=2.5):
        this = _clipper.new_EDcalc_mask_float(radius)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, *args):
        return _clipper.EDcalc_mask_float___call__(self, *args)

    def compute(self, *args):
        return _clipper.EDcalc_mask_float_compute(self, *args)
    __swig_destroy__ = _clipper.delete_EDcalc_mask_float
    __del__ = lambda self: None
EDcalc_mask_float_swigregister = _clipper.EDcalc_mask_float_swigregister
EDcalc_mask_float_swigregister(EDcalc_mask_float)

class EDcalc_iso_float(EDcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDcalc_iso_float, name, value)
    __swig_getmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EDcalc_iso_float, name)
    __repr__ = _swig_repr

    def __init__(self, radius=2.5):
        this = _clipper.new_EDcalc_iso_float(radius)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, *args):
        return _clipper.EDcalc_iso_float___call__(self, *args)

    def compute(self, *args):
        return _clipper.EDcalc_iso_float_compute(self, *args)
    __swig_destroy__ = _clipper.delete_EDcalc_iso_float
    __del__ = lambda self: None
EDcalc_iso_float_swigregister = _clipper.EDcalc_iso_float_swigregister
EDcalc_iso_float_swigregister(EDcalc_iso_float)

class EDcalc_aniso_float(EDcalc_base_float):
    __swig_setmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EDcalc_aniso_float, name, value)
    __swig_getmethods__ = {}
    for _s in [EDcalc_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EDcalc_aniso_float, name)
    __repr__ = _swig_repr

    def __init__(self, radius=2.5):
        this = _clipper.new_EDcalc_aniso_float(radius)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, *args):
        return _clipper.EDcalc_aniso_float___call__(self, *args)

    def compute(self, *args):
        return _clipper.EDcalc_aniso_float_compute(self, *args)
    __swig_destroy__ = _clipper.delete_EDcalc_aniso_float
    __del__ = lambda self: None
EDcalc_aniso_float_swigregister = _clipper.EDcalc_aniso_float_swigregister
EDcalc_aniso_float_swigregister(EDcalc_aniso_float)

class BasisFn_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_base, name)
    __repr__ = _swig_repr
    GENERAL = _clipper.BasisFn_base_GENERAL
    LINEAR = _clipper.BasisFn_base_LINEAR

    def __init__(self, *args):
        if self.__class__ == BasisFn_base:
            _self = None
        else:
            _self = self
        this = _clipper.new_BasisFn_base(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def num_params(self):
        return _clipper.BasisFn_base_num_params(self)

    def f(self, hkl, cell, params):
        return _clipper.BasisFn_base_f(self, hkl, cell, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_base_fderiv(self, hkl, cell, params)

    def type(self):
        return _clipper.BasisFn_base_type(self)

    def num_diagonals(self):
        return _clipper.BasisFn_base_num_diagonals(self)
    def __disown__(self):
        self.this.disown()
        _clipper.disown_BasisFn_base(self)
        return weakref_proxy(self)
BasisFn_base_swigregister = _clipper.BasisFn_base_swigregister
BasisFn_base_swigregister(BasisFn_base)

class TargetFn_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_base, name)
    __repr__ = _swig_repr
    GENERAL = _clipper.TargetFn_base_GENERAL
    QUADRATIC = _clipper.TargetFn_base_QUADRATIC

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_base_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_base_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_base
    __del__ = lambda self: None

    def __init__(self):
        if self.__class__ == TargetFn_base:
            _self = None
        else:
            _self = self
        this = _clipper.new_TargetFn_base(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _clipper.disown_TargetFn_base(self)
        return weakref_proxy(self)
TargetFn_base_swigregister = _clipper.TargetFn_base_swigregister
TargetFn_base_swigregister(TargetFn_base)

class ResolutionFn(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResolutionFn, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResolutionFn, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_info, basisfn, targetfn, params, damp=0.0, debug=False):
        this = _clipper.new_ResolutionFn(hkl_info, basisfn, targetfn, params, damp, debug)
        try:
            self.this.append(this)
        except:
            self.this = this

    def f(self, ih):
        return _clipper.ResolutionFn_f(self, ih)

    def params(self):
        return _clipper.ResolutionFn_params(self)
    __swig_destroy__ = _clipper.delete_ResolutionFn
    __del__ = lambda self: None
ResolutionFn_swigregister = _clipper.ResolutionFn_swigregister
ResolutionFn_swigregister(ResolutionFn)

class ResolutionFn_nonlinear(ResolutionFn):
    __swig_setmethods__ = {}
    for _s in [ResolutionFn]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResolutionFn_nonlinear, name, value)
    __swig_getmethods__ = {}
    for _s in [ResolutionFn]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ResolutionFn_nonlinear, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_info, basisfn, targetfn, params, damp=0.0, debug=False):
        this = _clipper.new_ResolutionFn_nonlinear(hkl_info, basisfn, targetfn, params, damp, debug)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_ResolutionFn_nonlinear
    __del__ = lambda self: None
ResolutionFn_nonlinear_swigregister = _clipper.ResolutionFn_nonlinear_swigregister
ResolutionFn_nonlinear_swigregister(ResolutionFn_nonlinear)

class Resolution_ordinal(Generic_ordinal):
    __swig_setmethods__ = {}
    for _s in [Generic_ordinal]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Resolution_ordinal, name, value)
    __swig_getmethods__ = {}
    for _s in [Generic_ordinal]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Resolution_ordinal, name)
    __repr__ = _swig_repr

    def init(self, *args):
        return _clipper.Resolution_ordinal_init(self, *args)

    def __init__(self):
        this = _clipper.new_Resolution_ordinal()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _clipper.delete_Resolution_ordinal
    __del__ = lambda self: None
Resolution_ordinal_swigregister = _clipper.Resolution_ordinal_swigregister
Resolution_ordinal_swigregister(Resolution_ordinal)

class BasisFn_binner(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_binner, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_binner, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_BasisFn_binner(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def f_s(self, s, params):
        return _clipper.BasisFn_binner_f_s(self, s, params)

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_binner_fderiv_s(self, s, params)

    def type(self):
        return _clipper.BasisFn_binner_type(self)

    def num_diagonals(self):
        return _clipper.BasisFn_binner_num_diagonals(self)

    def f(self, hkl, cell, params):
        return _clipper.BasisFn_binner_f(self, hkl, cell, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_binner_fderiv(self, hkl, cell, params)
    __swig_destroy__ = _clipper.delete_BasisFn_binner
    __del__ = lambda self: None
BasisFn_binner_swigregister = _clipper.BasisFn_binner_swigregister
BasisFn_binner_swigregister(BasisFn_binner)

class BasisFn_linear(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_linear, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_linear, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_BasisFn_linear(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def f_s(self, s, params):
        return _clipper.BasisFn_linear_f_s(self, s, params)

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_linear_fderiv_s(self, s, params)

    def type(self):
        return _clipper.BasisFn_linear_type(self)

    def num_diagonals(self):
        return _clipper.BasisFn_linear_num_diagonals(self)

    def f(self, hkl, cell, params):
        return _clipper.BasisFn_linear_f(self, hkl, cell, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_linear_fderiv(self, hkl, cell, params)
    __swig_destroy__ = _clipper.delete_BasisFn_linear
    __del__ = lambda self: None
BasisFn_linear_swigregister = _clipper.BasisFn_linear_swigregister
BasisFn_linear_swigregister(BasisFn_linear)

class BasisFn_spline(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_spline, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_spline, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_BasisFn_spline(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def f_s(self, s, params):
        return _clipper.BasisFn_spline_f_s(self, s, params)

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_spline_fderiv_s(self, s, params)

    def type(self):
        return _clipper.BasisFn_spline_type(self)

    def num_diagonals(self):
        return _clipper.BasisFn_spline_num_diagonals(self)

    def f(self, hkl, cell, params):
        return _clipper.BasisFn_spline_f(self, hkl, cell, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_spline_fderiv(self, hkl, cell, params)
    __swig_destroy__ = _clipper.delete_BasisFn_spline
    __del__ = lambda self: None
BasisFn_spline_swigregister = _clipper.BasisFn_spline_swigregister
BasisFn_spline_swigregister(BasisFn_spline)

class BasisFn_gaussian(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_gaussian, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_gaussian, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_BasisFn_gaussian()
        try:
            self.this.append(this)
        except:
            self.this = this

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_gaussian_fderiv_s(self, s, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_gaussian_fderiv(self, hkl, cell, params)

    def scale(self, params):
        return _clipper.BasisFn_gaussian_scale(self, params)

    def u_iso(self, params):
        return _clipper.BasisFn_gaussian_u_iso(self, params)
    __swig_destroy__ = _clipper.delete_BasisFn_gaussian
    __del__ = lambda self: None
BasisFn_gaussian_swigregister = _clipper.BasisFn_gaussian_swigregister
BasisFn_gaussian_swigregister(BasisFn_gaussian)

class BasisFn_aniso_gaussian(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_aniso_gaussian, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_aniso_gaussian, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_BasisFn_aniso_gaussian()
        try:
            self.this.append(this)
        except:
            self.this = this

    def fderiv_coord(self, xs, params):
        return _clipper.BasisFn_aniso_gaussian_fderiv_coord(self, xs, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_aniso_gaussian_fderiv(self, hkl, cell, params)

    def scale(self, params):
        return _clipper.BasisFn_aniso_gaussian_scale(self, params)

    def u_aniso_orth(self, params):
        return _clipper.BasisFn_aniso_gaussian_u_aniso_orth(self, params)
    __swig_destroy__ = _clipper.delete_BasisFn_aniso_gaussian
    __del__ = lambda self: None
BasisFn_aniso_gaussian_swigregister = _clipper.BasisFn_aniso_gaussian_swigregister
BasisFn_aniso_gaussian_swigregister(BasisFn_aniso_gaussian)

class BasisFn_log_gaussian(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_log_gaussian, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_log_gaussian, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_BasisFn_log_gaussian()
        try:
            self.this.append(this)
        except:
            self.this = this

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_log_gaussian_fderiv_s(self, s, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_log_gaussian_fderiv(self, hkl, cell, params)

    def type(self):
        return _clipper.BasisFn_log_gaussian_type(self)

    def scale(self, params):
        return _clipper.BasisFn_log_gaussian_scale(self, params)

    def u_iso(self, params):
        return _clipper.BasisFn_log_gaussian_u_iso(self, params)
    __swig_destroy__ = _clipper.delete_BasisFn_log_gaussian
    __del__ = lambda self: None
BasisFn_log_gaussian_swigregister = _clipper.BasisFn_log_gaussian_swigregister
BasisFn_log_gaussian_swigregister(BasisFn_log_gaussian)

class BasisFn_log_aniso_gaussian(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_log_aniso_gaussian, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_log_aniso_gaussian, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_BasisFn_log_aniso_gaussian()
        try:
            self.this.append(this)
        except:
            self.this = this

    def fderiv_coord(self, xs, params):
        return _clipper.BasisFn_log_aniso_gaussian_fderiv_coord(self, xs, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_log_aniso_gaussian_fderiv(self, hkl, cell, params)

    def type(self):
        return _clipper.BasisFn_log_aniso_gaussian_type(self)

    def scale(self, params):
        return _clipper.BasisFn_log_aniso_gaussian_scale(self, params)

    def u_aniso_orth(self, params):
        return _clipper.BasisFn_log_aniso_gaussian_u_aniso_orth(self, params)
    __swig_destroy__ = _clipper.delete_BasisFn_log_aniso_gaussian
    __del__ = lambda self: None
BasisFn_log_aniso_gaussian_swigregister = _clipper.BasisFn_log_aniso_gaussian_swigregister
BasisFn_log_aniso_gaussian_swigregister(BasisFn_log_aniso_gaussian)

class BasisFn_expcubic(BasisFn_base):
    __swig_setmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisFn_expcubic, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisFn_expcubic, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _clipper.new_BasisFn_expcubic()
        try:
            self.this.append(this)
        except:
            self.this = this

    def fderiv_s(self, s, params):
        return _clipper.BasisFn_expcubic_fderiv_s(self, s, params)

    def fderiv(self, hkl, cell, params):
        return _clipper.BasisFn_expcubic_fderiv(self, hkl, cell, params)
    __swig_destroy__ = _clipper.delete_BasisFn_expcubic
    __del__ = lambda self: None
BasisFn_expcubic_swigregister = _clipper.BasisFn_expcubic_swigregister
BasisFn_expcubic_swigregister(BasisFn_expcubic)

class TargetFn_scaleEsq_E_sigE_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_scaleEsq_E_sigE_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_scaleEsq_E_sigE_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data_):
        this = _clipper.new_TargetFn_scaleEsq_E_sigE_T(hkl_data_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_scaleEsq_E_sigE_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_scaleEsq_E_sigE_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_scaleEsq_E_sigE_T
    __del__ = lambda self: None
TargetFn_scaleEsq_E_sigE_T_swigregister = _clipper.TargetFn_scaleEsq_E_sigE_T_swigregister
TargetFn_scaleEsq_E_sigE_T_swigregister(TargetFn_scaleEsq_E_sigE_T)

class TargetFn_meanFnth_F_phi_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_meanFnth_F_phi_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_meanFnth_F_phi_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data_, n):
        this = _clipper.new_TargetFn_meanFnth_F_phi_T(hkl_data_, n)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_meanFnth_F_phi_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_meanFnth_F_phi_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_meanFnth_F_phi_T
    __del__ = lambda self: None
TargetFn_meanFnth_F_phi_T_swigregister = _clipper.TargetFn_meanFnth_F_phi_T_swigregister
TargetFn_meanFnth_F_phi_T_swigregister(TargetFn_meanFnth_F_phi_T)

class TargetFn_scaleF1F2_F_sigF_2_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_scaleF1F2_F_sigF_2_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_scaleF1F2_F_sigF_2_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data1_, hkl_data2_):
        this = _clipper.new_TargetFn_scaleF1F2_F_sigF_2_T(hkl_data1_, hkl_data2_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_scaleF1F2_F_sigF_2_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_scaleF1F2_F_sigF_2_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_scaleF1F2_F_sigF_2_T
    __del__ = lambda self: None
TargetFn_scaleF1F2_F_sigF_2_T_swigregister = _clipper.TargetFn_scaleF1F2_F_sigF_2_T_swigregister
TargetFn_scaleF1F2_F_sigF_2_T_swigregister(TargetFn_scaleF1F2_F_sigF_2_T)

class TargetFn_scaleLogF1F2_F_sigF_2_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_scaleLogF1F2_F_sigF_2_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_scaleLogF1F2_F_sigF_2_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data1_, hkl_data2_):
        this = _clipper.new_TargetFn_scaleLogF1F2_F_sigF_2_T(hkl_data1_, hkl_data2_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_scaleLogF1F2_F_sigF_2_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_scaleLogF1F2_F_sigF_2_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_scaleLogF1F2_F_sigF_2_T
    __del__ = lambda self: None
TargetFn_scaleLogF1F2_F_sigF_2_T_swigregister = _clipper.TargetFn_scaleLogF1F2_F_sigF_2_T_swigregister
TargetFn_scaleLogF1F2_F_sigF_2_T_swigregister(TargetFn_scaleLogF1F2_F_sigF_2_T)

class TargetFn_scaleI1I2_I_sigI_2_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_scaleI1I2_I_sigI_2_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_scaleI1I2_I_sigI_2_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data1_, hkl_data2_):
        this = _clipper.new_TargetFn_scaleI1I2_I_sigI_2_T(hkl_data1_, hkl_data2_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_scaleI1I2_I_sigI_2_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_scaleI1I2_I_sigI_2_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_scaleI1I2_I_sigI_2_T
    __del__ = lambda self: None
TargetFn_scaleI1I2_I_sigI_2_T_swigregister = _clipper.TargetFn_scaleI1I2_I_sigI_2_T_swigregister
TargetFn_scaleI1I2_I_sigI_2_T_swigregister(TargetFn_scaleI1I2_I_sigI_2_T)

class TargetFn_scaleLogI1I2_I_sigI_2_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_scaleLogI1I2_I_sigI_2_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_scaleLogI1I2_I_sigI_2_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data1_, hkl_data2_):
        this = _clipper.new_TargetFn_scaleLogI1I2_I_sigI_2_T(hkl_data1_, hkl_data2_)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_scaleLogI1I2_I_sigI_2_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_scaleLogI1I2_I_sigI_2_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_scaleLogI1I2_I_sigI_2_T
    __del__ = lambda self: None
TargetFn_scaleLogI1I2_I_sigI_2_T_swigregister = _clipper.TargetFn_scaleLogI1I2_I_sigI_2_T_swigregister
TargetFn_scaleLogI1I2_I_sigI_2_T_swigregister(TargetFn_scaleLogI1I2_I_sigI_2_T)

class TargetFn_meanEnth_E_sigE_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_meanEnth_E_sigE_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_meanEnth_E_sigE_T, name)
    __repr__ = _swig_repr

    def __init__(self, hkl_data_, n):
        this = _clipper.new_TargetFn_meanEnth_E_sigE_T(hkl_data_, n)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, fh):
        return _clipper.TargetFn_meanEnth_E_sigE_T_rderiv(self, ih, fh)

    def type(self):
        return _clipper.TargetFn_meanEnth_E_sigE_T_type(self)
    __swig_destroy__ = _clipper.delete_TargetFn_meanEnth_E_sigE_T
    __del__ = lambda self: None
TargetFn_meanEnth_E_sigE_T_swigregister = _clipper.TargetFn_meanEnth_E_sigE_T_swigregister
TargetFn_meanEnth_E_sigE_T_swigregister(TargetFn_meanEnth_E_sigE_T)

class TargetFn_sigmaa_omegaa_E_sigE_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_sigmaa_omegaa_E_sigE_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_sigmaa_omegaa_E_sigE_T, name)
    __repr__ = _swig_repr

    def __init__(self, eo, ec):
        this = _clipper.new_TargetFn_sigmaa_omegaa_E_sigE_T(eo, ec)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, omegaa):
        return _clipper.TargetFn_sigmaa_omegaa_E_sigE_T_rderiv(self, ih, omegaa)
    __swig_getmethods__["sigmaa"] = lambda x: _clipper.TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa
    if _newclass:
        sigmaa = staticmethod(_clipper.TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa)
    __swig_destroy__ = _clipper.delete_TargetFn_sigmaa_omegaa_E_sigE_T
    __del__ = lambda self: None
TargetFn_sigmaa_omegaa_E_sigE_T_swigregister = _clipper.TargetFn_sigmaa_omegaa_E_sigE_T_swigregister
TargetFn_sigmaa_omegaa_E_sigE_T_swigregister(TargetFn_sigmaa_omegaa_E_sigE_T)

def TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa(omegaa):
    return _clipper.TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa(omegaa)
TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa = _clipper.TargetFn_sigmaa_omegaa_E_sigE_T_sigmaa

class TargetFn_sigmaa_E_sigE_T(TargetFn_base):
    __swig_setmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetFn_sigmaa_E_sigE_T, name, value)
    __swig_getmethods__ = {}
    for _s in [TargetFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TargetFn_sigmaa_E_sigE_T, name)
    __repr__ = _swig_repr

    def __init__(self, eo, ec):
        this = _clipper.new_TargetFn_sigmaa_E_sigE_T(eo, ec)
        try:
            self.this.append(this)
        except:
            self.this = this

    def rderiv(self, ih, sigmaa0):
        return _clipper.TargetFn_sigmaa_E_sigE_T_rderiv(self, ih, sigmaa0)
    __swig_getmethods__["sigmaa"] = lambda x: _clipper.TargetFn_sigmaa_E_sigE_T_sigmaa
    if _newclass:
        sigmaa = staticmethod(_clipper.TargetFn_sigmaa_E_sigE_T_sigmaa)
    __swig_destroy__ = _clipper.delete_TargetFn_sigmaa_E_sigE_T
    __del__ = lambda self: None
TargetFn_sigmaa_E_sigE_T_swigregister = _clipper.TargetFn_sigmaa_E_sigE_T_swigregister
TargetFn_sigmaa_E_sigE_T_swigregister(TargetFn_sigmaa_E_sigE_T)

def TargetFn_sigmaa_E_sigE_T_sigmaa(sigm):
    return _clipper.TargetFn_sigmaa_E_sigE_T_sigmaa(sigm)
TargetFn_sigmaa_E_sigE_T_sigmaa = _clipper.TargetFn_sigmaa_E_sigE_T_sigmaa


def TargetFn_scaleEsq_E_sigE(hkl_data_):
    return _clipper.TargetFn_scaleEsq_E_sigE(hkl_data_)
TargetFn_scaleEsq_E_sigE = _clipper.TargetFn_scaleEsq_E_sigE

def TargetFn_meanFnth_F_phi(hkl_data_, val):
    return _clipper.TargetFn_meanFnth_F_phi(hkl_data_, val)
TargetFn_meanFnth_F_phi = _clipper.TargetFn_meanFnth_F_phi

def TargetFn_scaleF1F2_F_sigF_2(F1, F2):
    return _clipper.TargetFn_scaleF1F2_F_sigF_2(F1, F2)
TargetFn_scaleF1F2_F_sigF_2 = _clipper.TargetFn_scaleF1F2_F_sigF_2

def TargetFn_scaleLogF1F2_F_sigF_2(hkl_data1_, hkl_data2_):
    return _clipper.TargetFn_scaleLogF1F2_F_sigF_2(hkl_data1_, hkl_data2_)
TargetFn_scaleLogF1F2_F_sigF_2 = _clipper.TargetFn_scaleLogF1F2_F_sigF_2

def TargetFn_scaleI1I2_I_sigI_2(hkl_data1_, hkl_data2_):
    return _clipper.TargetFn_scaleI1I2_I_sigI_2(hkl_data1_, hkl_data2_)
TargetFn_scaleI1I2_I_sigI_2 = _clipper.TargetFn_scaleI1I2_I_sigI_2

def TargetFn_scaleLogI1I2_I_sigI_2(hkl_data1_, hkl_data2_):
    return _clipper.TargetFn_scaleLogI1I2_I_sigI_2(hkl_data1_, hkl_data2_)
TargetFn_scaleLogI1I2_I_sigI_2 = _clipper.TargetFn_scaleLogI1I2_I_sigI_2

def TargetFn_meanEnth_E_sigE(hkl_data_, n):
    return _clipper.TargetFn_meanEnth_E_sigE(hkl_data_, n)
TargetFn_meanEnth_E_sigE = _clipper.TargetFn_meanEnth_E_sigE

def TargetFn_sigmaa_omegaa_E_sigE_2(eo, ec):
    return _clipper.TargetFn_sigmaa_omegaa_E_sigE_2(eo, ec)
TargetFn_sigmaa_omegaa_E_sigE_2 = _clipper.TargetFn_sigmaa_omegaa_E_sigE_2

def TargetFn_sigmaa_E_sigE_2(eo, ec):
    return _clipper.TargetFn_sigmaa_E_sigE_2(eo, ec)
TargetFn_sigmaa_E_sigE_2 = _clipper.TargetFn_sigmaa_E_sigE_2
class NX_operator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NX_operator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NX_operator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_NX_operator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.NX_operator_init(self, *args)

    def coord_map(self, c):
        return _clipper.NX_operator_coord_map(self, c)

    def coord_frac(self, c):
        return _clipper.NX_operator_coord_frac(self, c)

    def is_null(self):
        return _clipper.NX_operator_is_null(self)

    def debug(self):
        return _clipper.NX_operator_debug(self)
    __swig_destroy__ = _clipper.delete_NX_operator
    __del__ = lambda self: None
NX_operator_swigregister = _clipper.NX_operator_swigregister
NX_operator_swigregister(NX_operator)

class NXmap_operator_float(NX_operator):
    __swig_setmethods__ = {}
    for _s in [NX_operator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NXmap_operator_float, name, value)
    __swig_getmethods__ = {}
    for _s in [NX_operator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NXmap_operator_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_NXmap_operator_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.NXmap_operator_float_init(self, *args)

    def nxmap(self):
        return _clipper.NXmap_operator_float_nxmap(self)
    __swig_destroy__ = _clipper.delete_NXmap_operator_float
    __del__ = lambda self: None
NXmap_operator_float_swigregister = _clipper.NXmap_operator_float_swigregister
NXmap_operator_float_swigregister(NXmap_operator_float)

class Convolution_search_slow_float_T(Convolution_search_base_float):
    __swig_setmethods__ = {}
    for _s in [Convolution_search_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Convolution_search_slow_float_T, name, value)
    __swig_getmethods__ = {}
    for _s in [Convolution_search_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Convolution_search_slow_float_T, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def init(self, xmap):
        return _clipper.Convolution_search_slow_float_T_init(self, xmap)

    def __call__(self, *args):
        return _clipper.Convolution_search_slow_float_T___call__(self, *args)

    def compute(self, res, srchval, nxop):
        return _clipper.Convolution_search_slow_float_T_compute(self, res, srchval, nxop)
    __swig_destroy__ = _clipper.delete_Convolution_search_slow_float_T
    __del__ = lambda self: None
Convolution_search_slow_float_T_swigregister = _clipper.Convolution_search_slow_float_T_swigregister
Convolution_search_slow_float_T_swigregister(Convolution_search_slow_float_T)

class Convolution_search_fft_float_T(Convolution_search_base_float):
    __swig_setmethods__ = {}
    for _s in [Convolution_search_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Convolution_search_fft_float_T, name, value)
    __swig_getmethods__ = {}
    for _s in [Convolution_search_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Convolution_search_fft_float_T, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def init(self, xmap):
        return _clipper.Convolution_search_fft_float_T_init(self, xmap)

    def __call__(self, *args):
        return _clipper.Convolution_search_fft_float_T___call__(self, *args)

    def compute(self, res, srchval, nxop):
        return _clipper.Convolution_search_fft_float_T_compute(self, res, srchval, nxop)
    __swig_destroy__ = _clipper.delete_Convolution_search_fft_float_T
    __del__ = lambda self: None
Convolution_search_fft_float_T_swigregister = _clipper.Convolution_search_fft_float_T_swigregister
Convolution_search_fft_float_T_swigregister(Convolution_search_fft_float_T)


def Convolution_search_slow_float(*args):
    return _clipper.Convolution_search_slow_float(*args)
Convolution_search_slow_float = _clipper.Convolution_search_slow_float

def Convolution_search_fft_float(*args):
    return _clipper.Convolution_search_fft_float(*args)
Convolution_search_fft_float = _clipper.Convolution_search_fft_float
class MapFilterFn_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilterFn_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilterFn_base, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _clipper.delete_MapFilterFn_base
    __del__ = lambda self: None

    def __call__(self, radius):
        return _clipper.MapFilterFn_base___call__(self, radius)
MapFilterFn_base_swigregister = _clipper.MapFilterFn_base_swigregister
MapFilterFn_base_swigregister(MapFilterFn_base)

class MapFilterFn_step(MapFilterFn_base):
    __swig_setmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilterFn_step, name, value)
    __swig_getmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilterFn_step, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MapFilterFn_step(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, radius):
        return _clipper.MapFilterFn_step___call__(self, radius)
    __swig_destroy__ = _clipper.delete_MapFilterFn_step
    __del__ = lambda self: None
MapFilterFn_step_swigregister = _clipper.MapFilterFn_step_swigregister
MapFilterFn_step_swigregister(MapFilterFn_step)

class MapFilterFn_linear(MapFilterFn_base):
    __swig_setmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilterFn_linear, name, value)
    __swig_getmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilterFn_linear, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MapFilterFn_linear(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, radius):
        return _clipper.MapFilterFn_linear___call__(self, radius)
    __swig_destroy__ = _clipper.delete_MapFilterFn_linear
    __del__ = lambda self: None
MapFilterFn_linear_swigregister = _clipper.MapFilterFn_linear_swigregister
MapFilterFn_linear_swigregister(MapFilterFn_linear)

class MapFilterFn_quadratic(MapFilterFn_base):
    __swig_setmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilterFn_quadratic, name, value)
    __swig_getmethods__ = {}
    for _s in [MapFilterFn_base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilterFn_quadratic, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_MapFilterFn_quadratic(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, radius):
        return _clipper.MapFilterFn_quadratic___call__(self, radius)
    __swig_destroy__ = _clipper.delete_MapFilterFn_quadratic
    __del__ = lambda self: None
MapFilterFn_quadratic_swigregister = _clipper.MapFilterFn_quadratic_swigregister
MapFilterFn_quadratic_swigregister(MapFilterFn_quadratic)

class MapFilter_slow_float(MapFilter_base_float):
    __swig_setmethods__ = {}
    for _s in [MapFilter_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilter_slow_float, name, value)
    __swig_getmethods__ = {}
    for _s in [MapFilter_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilter_slow_float, name)
    __repr__ = _swig_repr
    NONE = _clipper.MapFilter_slow_float_NONE
    Absolute = _clipper.MapFilter_slow_float_Absolute
    Relative = _clipper.MapFilter_slow_float_Relative

    def __init__(self, *args):
        this = _clipper.new_MapFilter_slow_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, result, xmap):
        return _clipper.MapFilter_slow_float___call__(self, result, xmap)
    __swig_destroy__ = _clipper.delete_MapFilter_slow_float
    __del__ = lambda self: None
MapFilter_slow_float_swigregister = _clipper.MapFilter_slow_float_swigregister
MapFilter_slow_float_swigregister(MapFilter_slow_float)

class MapFilter_fft_float(MapFilter_base_float):
    __swig_setmethods__ = {}
    for _s in [MapFilter_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapFilter_fft_float, name, value)
    __swig_getmethods__ = {}
    for _s in [MapFilter_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapFilter_fft_float, name)
    __repr__ = _swig_repr
    NONE = _clipper.MapFilter_fft_float_NONE
    Absolute = _clipper.MapFilter_fft_float_Absolute
    Relative = _clipper.MapFilter_fft_float_Relative

    def __init__(self, *args):
        this = _clipper.new_MapFilter_fft_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, *args):
        return _clipper.MapFilter_fft_float___call__(self, *args)
    __swig_destroy__ = _clipper.delete_MapFilter_fft_float
    __del__ = lambda self: None
MapFilter_fft_float_swigregister = _clipper.MapFilter_fft_float_swigregister
MapFilter_fft_float_swigregister(MapFilter_fft_float)

class OriginMatch_float(OriginMatch_base_float):
    __swig_setmethods__ = {}
    for _s in [OriginMatch_base_float]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OriginMatch_float, name, value)
    __swig_getmethods__ = {}
    for _s in [OriginMatch_base_float]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OriginMatch_float, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_OriginMatch_float(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, shift, fphi1, fphi2):
        return _clipper.OriginMatch_float___call__(self, shift, fphi1, fphi2)
    __swig_destroy__ = _clipper.delete_OriginMatch_float
    __del__ = lambda self: None
OriginMatch_float_swigregister = _clipper.OriginMatch_float_swigregister
OriginMatch_float_swigregister(OriginMatch_float)

class AtomShapeFn(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomShapeFn, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomShapeFn, name)
    __repr__ = _swig_repr
    X = _clipper.AtomShapeFn_X
    Y = _clipper.AtomShapeFn_Y
    Z = _clipper.AtomShapeFn_Z
    Uiso = _clipper.AtomShapeFn_Uiso
    Occ = _clipper.AtomShapeFn_Occ
    U11 = _clipper.AtomShapeFn_U11
    U22 = _clipper.AtomShapeFn_U22
    U33 = _clipper.AtomShapeFn_U33
    U12 = _clipper.AtomShapeFn_U12
    U13 = _clipper.AtomShapeFn_U13
    U23 = _clipper.AtomShapeFn_U23

    def __init__(self, *args):
        this = _clipper.new_AtomShapeFn(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.AtomShapeFn_init(self, *args)

    def rho_curv(self, xyz, rho, grad, curv):
        return _clipper.AtomShapeFn_rho_curv(self, xyz, rho, grad, curv)

    def rho_grad(self, *args):
        return _clipper.AtomShapeFn_rho_grad(self, *args)

    def f(self, *args):
        return _clipper.AtomShapeFn_f(self, *args)

    def rho(self, *args):
        return _clipper.AtomShapeFn_rho(self, *args)

    def agarwal_params(self):
        return _clipper.AtomShapeFn_agarwal_params(self)
    __swig_destroy__ = _clipper.delete_AtomShapeFn
    __del__ = lambda self: None
AtomShapeFn_swigregister = _clipper.AtomShapeFn_swigregister
AtomShapeFn_swigregister(AtomShapeFn)

class AtomSF(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomSF, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomSF, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_AtomSF(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        return _clipper.AtomSF_init(self, *args)

    def f_iso(self, s):
        return _clipper.AtomSF_f_iso(self, s)

    def f_aniso(self, rfl):
        return _clipper.AtomSF_f_aniso(self, rfl)

    def rho_iso(self, d2):
        return _clipper.AtomSF_rho_iso(self, d2)

    def rho_aniso(self, uvw):
        return _clipper.AtomSF_rho_aniso(self, uvw)
    __swig_destroy__ = _clipper.delete_AtomSF
    __del__ = lambda self: None
AtomSF_swigregister = _clipper.AtomSF_swigregister
AtomSF_swigregister(AtomSF)

class Euler_ccp4(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Euler_ccp4, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Euler_ccp4, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Euler_ccp4(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def alpha(self):
        return _clipper.Euler_ccp4_alpha(self)

    def beta(self):
        return _clipper.Euler_ccp4_beta(self)

    def gamma(self):
        return _clipper.Euler_ccp4_gamma(self)

    def format(self):
        return _clipper.Euler_ccp4_format(self)
    __swig_destroy__ = _clipper.delete_Euler_ccp4
    __del__ = lambda self: None
Euler_ccp4_swigregister = _clipper.Euler_ccp4_swigregister
Euler_ccp4_swigregister(Euler_ccp4)

class Polar_ccp4(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polar_ccp4, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Polar_ccp4, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Polar_ccp4(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def psi(self):
        return _clipper.Polar_ccp4_psi(self)

    def omega(self):
        return _clipper.Polar_ccp4_omega(self)

    def phi(self):
        return _clipper.Polar_ccp4_phi(self)

    def kappa(self):
        return _clipper.Polar_ccp4_kappa(self)

    def format(self):
        return _clipper.Polar_ccp4_format(self)
    __swig_destroy__ = _clipper.delete_Polar_ccp4
    __del__ = lambda self: None
Polar_ccp4_swigregister = _clipper.Polar_ccp4_swigregister
Polar_ccp4_swigregister(Polar_ccp4)

class Rotation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _clipper.new_Rotation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def w(self):
        return _clipper.Rotation_w(self)

    def x(self):
        return _clipper.Rotation_x(self)

    def y(self):
        return _clipper.Rotation_y(self)

    def z(self):
        return _clipper.Rotation_z(self)

    def euler_ccp4(self):
        return _clipper.Rotation_euler_ccp4(self)

    def polar_ccp4(self):
        return _clipper.Rotation_polar_ccp4(self)

    def matrix(self):
        return _clipper.Rotation_matrix(self)

    def norm(self):
        return _clipper.Rotation_norm(self)

    def abs_angle(self):
        return _clipper.Rotation_abs_angle(self)

    def inverse(self):
        return _clipper.Rotation_inverse(self)
    __swig_getmethods__["zero"] = lambda x: _clipper.Rotation_zero
    if _newclass:
        zero = staticmethod(_clipper.Rotation_zero)
    __swig_getmethods__["null"] = lambda x: _clipper.Rotation_null
    if _newclass:
        null = staticmethod(_clipper.Rotation_null)

    def is_null(self):
        return _clipper.Rotation_is_null(self)

    def format(self):
        return _clipper.Rotation_format(self)
    EulerXYZr = _clipper.Rotation_EulerXYZr
    EulerXYZs = _clipper.Rotation_EulerXYZs
    EulerXYXr = _clipper.Rotation_EulerXYXr
    EulerXYXs = _clipper.Rotation_EulerXYXs
    EulerXZXr = _clipper.Rotation_EulerXZXr
    EulerXZXs = _clipper.Rotation_EulerXZXs
    EulerXZYr = _clipper.Rotation_EulerXZYr
    EulerXZYs = _clipper.Rotation_EulerXZYs
    EulerYZXr = _clipper.Rotation_EulerYZXr
    EulerYZXs = _clipper.Rotation_EulerYZXs
    EulerYZYr = _clipper.Rotation_EulerYZYr
    EulerYZYs = _clipper.Rotation_EulerYZYs
    EulerYXYr = _clipper.Rotation_EulerYXYr
    EulerYXYs = _clipper.Rotation_EulerYXYs
    EulerYXZr = _clipper.Rotation_EulerYXZr
    EulerYXZs = _clipper.Rotation_EulerYXZs
    EulerZXYr = _clipper.Rotation_EulerZXYr
    EulerZXYs = _clipper.Rotation_EulerZXYs
    EulerZXZr = _clipper.Rotation_EulerZXZr
    EulerZXZs = _clipper.Rotation_EulerZXZs
    EulerZYZr = _clipper.Rotation_EulerZYZr
    EulerZYZs = _clipper.Rotation_EulerZYZs
    EulerZYXr = _clipper.Rotation_EulerZYXr
    EulerZYXs = _clipper.Rotation_EulerZYXs
    __swig_destroy__ = _clipper.delete_Rotation
    __del__ = lambda self: None
Rotation_swigregister = _clipper.Rotation_swigregister
Rotation_swigregister(Rotation)

def Rotation_zero():
    return _clipper.Rotation_zero()
Rotation_zero = _clipper.Rotation_zero

def Rotation_null():
    return _clipper.Rotation_null()
Rotation_null = _clipper.Rotation_null

# This file is compatible with both classic and new-style classes.