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

"""Interface to pointlike"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_pointlike')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_pointlike')
    _pointlike = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_pointlike', [dirname(__file__)])
        except ImportError:
            import _pointlike
            return _pointlike
        try:
            _mod = imp.load_module('_pointlike', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _pointlike = swig_import_helper()
    del swig_import_helper
else:
    import _pointlike
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

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__ = _pointlike.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        this = _pointlike.new_DoublePair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pointlike.DoublePair_first_set
    __swig_getmethods__["first"] = _pointlike.DoublePair_first_get
    if _newclass:
        first = _swig_property(_pointlike.DoublePair_first_get, _pointlike.DoublePair_first_set)
    __swig_setmethods__["second"] = _pointlike.DoublePair_second_set
    __swig_getmethods__["second"] = _pointlike.DoublePair_second_get
    if _newclass:
        second = _swig_property(_pointlike.DoublePair_second_get, _pointlike.DoublePair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _pointlike.delete_DoublePair
    __del__ = lambda self: None
DoublePair_swigregister = _pointlike.DoublePair_swigregister
DoublePair_swigregister(DoublePair)

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 _pointlike.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 _pointlike.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 _pointlike.FloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _pointlike.LongVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pointlike.LongVector___nonzero__(self)

    def __bool__(self):
        return _pointlike.LongVector___bool__(self)

    def __len__(self):
        return _pointlike.LongVector___len__(self)

    def __getslice__(self, i, j):
        return _pointlike.LongVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pointlike.LongVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pointlike.LongVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pointlike.LongVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pointlike.LongVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pointlike.LongVector___setitem__(self, *args)

    def pop(self):
        return _pointlike.LongVector_pop(self)

    def append(self, x):
        return _pointlike.LongVector_append(self, x)

    def empty(self):
        return _pointlike.LongVector_empty(self)

    def size(self):
        return _pointlike.LongVector_size(self)

    def swap(self, v):
        return _pointlike.LongVector_swap(self, v)

    def begin(self):
        return _pointlike.LongVector_begin(self)

    def end(self):
        return _pointlike.LongVector_end(self)

    def rbegin(self):
        return _pointlike.LongVector_rbegin(self)

    def rend(self):
        return _pointlike.LongVector_rend(self)

    def clear(self):
        return _pointlike.LongVector_clear(self)

    def get_allocator(self):
        return _pointlike.LongVector_get_allocator(self)

    def pop_back(self):
        return _pointlike.LongVector_pop_back(self)

    def erase(self, *args):
        return _pointlike.LongVector_erase(self, *args)

    def __init__(self, *args):
        this = _pointlike.new_LongVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pointlike.LongVector_push_back(self, x)

    def front(self):
        return _pointlike.LongVector_front(self)

    def back(self):
        return _pointlike.LongVector_back(self)

    def assign(self, n, x):
        return _pointlike.LongVector_assign(self, n, x)

    def resize(self, *args):
        return _pointlike.LongVector_resize(self, *args)

    def insert(self, *args):
        return _pointlike.LongVector_insert(self, *args)

    def reserve(self, n):
        return _pointlike.LongVector_reserve(self, n)

    def capacity(self):
        return _pointlike.LongVector_capacity(self)
    __swig_destroy__ = _pointlike.delete_LongVector
    __del__ = lambda self: None
LongVector_swigregister = _pointlike.LongVector_swigregister
LongVector_swigregister(LongVector)

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 _pointlike.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class Hep3Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hep3Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hep3Vector, name)
    __repr__ = _swig_repr
    X = _pointlike.Hep3Vector_X
    Y = _pointlike.Hep3Vector_Y
    Z = _pointlike.Hep3Vector_Z
    NUM_COORDINATES = _pointlike.Hep3Vector_NUM_COORDINATES
    SIZE = _pointlike.Hep3Vector_SIZE

    def __init__(self, *args):
        this = _pointlike.new_Hep3Vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_Hep3Vector
    __del__ = lambda self: None

    def __call__(self, *args):
        return _pointlike.Hep3Vector___call__(self, *args)

    def x(self):
        return _pointlike.Hep3Vector_x(self)

    def y(self):
        return _pointlike.Hep3Vector_y(self)

    def z(self):
        return _pointlike.Hep3Vector_z(self)

    def setX(self, arg2):
        return _pointlike.Hep3Vector_setX(self, arg2)

    def setY(self, arg2):
        return _pointlike.Hep3Vector_setY(self, arg2)

    def setZ(self, arg2):
        return _pointlike.Hep3Vector_setZ(self, arg2)

    def set(self, x, y, z):
        return _pointlike.Hep3Vector_set(self, x, y, z)

    def phi(self):
        return _pointlike.Hep3Vector_phi(self)

    def mag2(self):
        return _pointlike.Hep3Vector_mag2(self)

    def mag(self):
        return _pointlike.Hep3Vector_mag(self)

    def setPhi(self, arg2):
        return _pointlike.Hep3Vector_setPhi(self, arg2)

    def setTheta(self, arg2):
        return _pointlike.Hep3Vector_setTheta(self, arg2)

    def setMag(self, arg2):
        return _pointlike.Hep3Vector_setMag(self, arg2)

    def setPerp(self, arg2):
        return _pointlike.Hep3Vector_setPerp(self, arg2)

    def setCylTheta(self, arg2):
        return _pointlike.Hep3Vector_setCylTheta(self, arg2)

    def perp2(self, *args):
        return _pointlike.Hep3Vector_perp2(self, *args)

    def perp(self, *args):
        return _pointlike.Hep3Vector_perp(self, *args)

    def __eq__(self, arg2):
        return _pointlike.Hep3Vector___eq__(self, arg2)

    def __ne__(self, arg2):
        return _pointlike.Hep3Vector___ne__(self, arg2)

    def isNear(self, *args):
        return _pointlike.Hep3Vector_isNear(self, *args)

    def howNear(self, v):
        return _pointlike.Hep3Vector_howNear(self, v)

    def deltaR(self, v):
        return _pointlike.Hep3Vector_deltaR(self, v)

    def __iadd__(self, arg2):
        return _pointlike.Hep3Vector___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _pointlike.Hep3Vector___isub__(self, arg2)

    def __neg__(self):
        return _pointlike.Hep3Vector___neg__(self)

    def __itruediv__(self, *args):
        return _pointlike.Hep3Vector___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def unit(self):
        return _pointlike.Hep3Vector_unit(self)

    def orthogonal(self):
        return _pointlike.Hep3Vector_orthogonal(self)

    def dot(self, arg2):
        return _pointlike.Hep3Vector_dot(self, arg2)

    def cross(self, arg2):
        return _pointlike.Hep3Vector_cross(self, arg2)

    def pseudoRapidity(self):
        return _pointlike.Hep3Vector_pseudoRapidity(self)

    def setEta(self, p):
        return _pointlike.Hep3Vector_setEta(self, p)

    def setCylEta(self, p):
        return _pointlike.Hep3Vector_setCylEta(self, p)

    def rotateX(self, arg2):
        return _pointlike.Hep3Vector_rotateX(self, arg2)

    def rotateY(self, arg2):
        return _pointlike.Hep3Vector_rotateY(self, arg2)

    def rotateZ(self, arg2):
        return _pointlike.Hep3Vector_rotateZ(self, arg2)

    def rotateUz(self, arg2):
        return _pointlike.Hep3Vector_rotateUz(self, arg2)

    def __imul__(self, *args):
        return _pointlike.Hep3Vector___imul__(self, *args)

    def transform(self, arg2):
        return _pointlike.Hep3Vector_transform(self, arg2)

    def setRThetaPhi(self, r, theta, phi):
        return _pointlike.Hep3Vector_setRThetaPhi(self, r, theta, phi)

    def setREtaPhi(self, r, eta, phi):
        return _pointlike.Hep3Vector_setREtaPhi(self, r, eta, phi)

    def setRhoPhiZ(self, rho, phi, z):
        return _pointlike.Hep3Vector_setRhoPhiZ(self, rho, phi, z)

    def setRhoPhiTheta(self, rho, phi, theta):
        return _pointlike.Hep3Vector_setRhoPhiTheta(self, rho, phi, theta)

    def setRhoPhiEta(self, rho, phi, eta):
        return _pointlike.Hep3Vector_setRhoPhiEta(self, rho, phi, eta)

    def getX(self):
        return _pointlike.Hep3Vector_getX(self)

    def getY(self):
        return _pointlike.Hep3Vector_getY(self)

    def getZ(self):
        return _pointlike.Hep3Vector_getZ(self)

    def getR(self):
        return _pointlike.Hep3Vector_getR(self)

    def getTheta(self):
        return _pointlike.Hep3Vector_getTheta(self)

    def getPhi(self):
        return _pointlike.Hep3Vector_getPhi(self)

    def r(self):
        return _pointlike.Hep3Vector_r(self)

    def rho(self):
        return _pointlike.Hep3Vector_rho(self)

    def getRho(self):
        return _pointlike.Hep3Vector_getRho(self)

    def getEta(self):
        return _pointlike.Hep3Vector_getEta(self)

    def setR(self, s):
        return _pointlike.Hep3Vector_setR(self, s)

    def setRho(self, s):
        return _pointlike.Hep3Vector_setRho(self, s)

    def compare(self, v):
        return _pointlike.Hep3Vector_compare(self, v)

    def __gt__(self, v):
        return _pointlike.Hep3Vector___gt__(self, v)

    def __lt__(self, v):
        return _pointlike.Hep3Vector___lt__(self, v)

    def __ge__(self, v):
        return _pointlike.Hep3Vector___ge__(self, v)

    def __le__(self, v):
        return _pointlike.Hep3Vector___le__(self, v)

    def diff2(self, v):
        return _pointlike.Hep3Vector_diff2(self, v)
    if _newclass:
        setTolerance = staticmethod(_pointlike.Hep3Vector_setTolerance)
    else:
        setTolerance = _pointlike.Hep3Vector_setTolerance
    if _newclass:
        getTolerance = staticmethod(_pointlike.Hep3Vector_getTolerance)
    else:
        getTolerance = _pointlike.Hep3Vector_getTolerance

    def isParallel(self, *args):
        return _pointlike.Hep3Vector_isParallel(self, *args)

    def isOrthogonal(self, *args):
        return _pointlike.Hep3Vector_isOrthogonal(self, *args)

    def howParallel(self, v):
        return _pointlike.Hep3Vector_howParallel(self, v)

    def howOrthogonal(self, v):
        return _pointlike.Hep3Vector_howOrthogonal(self, v)
    ToleranceTicks = _pointlike.Hep3Vector_ToleranceTicks

    def beta(self):
        return _pointlike.Hep3Vector_beta(self)

    def gamma(self):
        return _pointlike.Hep3Vector_gamma(self)

    def coLinearRapidity(self):
        return _pointlike.Hep3Vector_coLinearRapidity(self)

    def angle(self, *args):
        return _pointlike.Hep3Vector_angle(self, *args)

    def theta(self, *args):
        return _pointlike.Hep3Vector_theta(self, *args)

    def cosTheta(self, *args):
        return _pointlike.Hep3Vector_cosTheta(self, *args)

    def cos2Theta(self, *args):
        return _pointlike.Hep3Vector_cos2Theta(self, *args)

    def project(self, *args):
        return _pointlike.Hep3Vector_project(self, *args)

    def perpPart(self, *args):
        return _pointlike.Hep3Vector_perpPart(self, *args)

    def rapidity(self, *args):
        return _pointlike.Hep3Vector_rapidity(self, *args)

    def eta(self, *args):
        return _pointlike.Hep3Vector_eta(self, *args)

    def deltaPhi(self, v2):
        return _pointlike.Hep3Vector_deltaPhi(self, v2)

    def polarAngle(self, *args):
        return _pointlike.Hep3Vector_polarAngle(self, *args)

    def azimAngle(self, *args):
        return _pointlike.Hep3Vector_azimAngle(self, *args)

    def rotate(self, *args):
        return _pointlike.Hep3Vector_rotate(self, *args)

    def __getitem__(self, i):
        return _pointlike.Hep3Vector___getitem__(self, i)

    def __len__(self):
        return _pointlike.Hep3Vector___len__(self)
Hep3Vector_swigregister = _pointlike.Hep3Vector_swigregister
Hep3Vector_swigregister(Hep3Vector)

def Hep3Vector_setTolerance(tol):
    return _pointlike.Hep3Vector_setTolerance(tol)
Hep3Vector_setTolerance = _pointlike.Hep3Vector_setTolerance

def Hep3Vector_getTolerance():
    return _pointlike.Hep3Vector_getTolerance()
Hep3Vector_getTolerance = _pointlike.Hep3Vector_getTolerance


def rotationXOf(vec, delta):
    return _pointlike.rotationXOf(vec, delta)
rotationXOf = _pointlike.rotationXOf

def rotationYOf(vec, delta):
    return _pointlike.rotationYOf(vec, delta)
rotationYOf = _pointlike.rotationYOf

def rotationZOf(vec, delta):
    return _pointlike.rotationZOf(vec, delta)
rotationZOf = _pointlike.rotationZOf

def rotationOf(*args):
    return _pointlike.rotationOf(*args)
rotationOf = _pointlike.rotationOf

def __lshift__(arg1, arg2):
    return _pointlike.__lshift__(arg1, arg2)
__lshift__ = _pointlike.__lshift__

def __rshift__(arg1, arg2):
    return _pointlike.__rshift__(arg1, arg2)
__rshift__ = _pointlike.__rshift__

def __truediv__(arg1, a):
    return _pointlike.__truediv__(arg1, a)
__truediv__ = _pointlike.__truediv__

def __add__(arg1, arg2):
    return _pointlike.__add__(arg1, arg2)
__add__ = _pointlike.__add__

def __sub__(arg1, arg2):
    return _pointlike.__sub__(arg1, arg2)
__sub__ = _pointlike.__sub__

def __mul__(*args):
    return _pointlike.__mul__(*args)
__mul__ = _pointlike.__mul__
class HepRotation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HepRotation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HepRotation, name)
    __repr__ = _swig_repr

    def __getitem__(self, i):
        return _pointlike.HepRotation___getitem__(self, i)

    def __len__(self):
        return _pointlike.HepRotation___len__(self)

    def inverse(self):
        return _pointlike.HepRotation_inverse(self)

    def __init__(self):
        this = _pointlike.new_HepRotation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_HepRotation
    __del__ = lambda self: None
HepRotation_swigregister = _pointlike.HepRotation_swigregister
HepRotation_swigregister(HepRotation)
cvar = _pointlike.cvar
HepXHat = cvar.HepXHat
HepYHat = cvar.HepYHat
HepZHat = cvar.HepZHat

ASTRO_D2R = _pointlike.ASTRO_D2R
ASTRO_R2D = _pointlike.ASTRO_R2D
ASTRO_PIOVER2 = _pointlike.ASTRO_PIOVER2
ASTRO_4PI = _pointlike.ASTRO_4PI

def degToRad(deg):
    return _pointlike.degToRad(deg)
degToRad = _pointlike.degToRad

def radToDeg(rad):
    return _pointlike.radToDeg(rad)
radToDeg = _pointlike.radToDeg

def latToTheta_Deg(lat):
    return _pointlike.latToTheta_Deg(lat)
latToTheta_Deg = _pointlike.latToTheta_Deg

def thetaToLat_Deg(theta):
    return _pointlike.thetaToLat_Deg(theta)
thetaToLat_Deg = _pointlike.thetaToLat_Deg

def latToTheta_Rad(lat):
    return _pointlike.latToTheta_Rad(lat)
latToTheta_Rad = _pointlike.latToTheta_Rad

def thetaToLat_Rad(theta):
    return _pointlike.thetaToLat_Rad(theta)
thetaToLat_Rad = _pointlike.thetaToLat_Rad
class ProjBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProjBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    WCS = _pointlike.ProjBase_WCS
    HEALPIX = _pointlike.ProjBase_HEALPIX
    UNKNOWN = _pointlike.ProjBase_UNKNOWN
    __swig_destroy__ = _pointlike.delete_ProjBase
    __del__ = lambda self: None

    def clone(self):
        return _pointlike.ProjBase_clone(self)

    def sph2pix(self, s1, s2):
        return _pointlike.ProjBase_sph2pix(self, s1, s2)

    def pix2pix(self, x1, x2, otherProjection):
        return _pointlike.ProjBase_pix2pix(self, x1, x2, otherProjection)

    def pix2sph(self, x1, x2):
        return _pointlike.ProjBase_pix2sph(self, x1, x2)

    def isGalactic(self):
        return _pointlike.ProjBase_isGalactic(self)

    def projType(self):
        return _pointlike.ProjBase_projType(self)

    def method(self):
        return _pointlike.ProjBase_method(self)

    def range(self, x1, xvar):
        return _pointlike.ProjBase_range(self, x1, xvar)

    def testpix2sph(self, x1, x2):
        return _pointlike.ProjBase_testpix2sph(self, x1, x2)

    def setKeywords(self, header):
        return _pointlike.ProjBase_setKeywords(self, header)
ProjBase_swigregister = _pointlike.ProjBase_swigregister
ProjBase_swigregister(ProjBase)

class SkyProj(ProjBase):
    __swig_setmethods__ = {}
    for _s in [ProjBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SkyProj, name, value)
    __swig_getmethods__ = {}
    for _s in [ProjBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SkyProj, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pointlike.delete_SkyProj
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _pointlike.new_SkyProj(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        return _pointlike.SkyProj_clone(self)

    def sph2pix(self, s1, s2):
        return _pointlike.SkyProj_sph2pix(self, s1, s2)

    def pix2pix(self, x1, x2, otherProjection):
        return _pointlike.SkyProj_pix2pix(self, x1, x2, otherProjection)

    def pix2sph(self, x1, x2):
        return _pointlike.SkyProj_pix2sph(self, x1, x2)

    def range(self, x1, xvar):
        return _pointlike.SkyProj_range(self, x1, xvar)

    def testpix2sph(self, x1, x2):
        return _pointlike.SkyProj_testpix2sph(self, x1, x2)

    def setKeywords(self, header):
        return _pointlike.SkyProj_setKeywords(self, header)
SkyProj_swigregister = _pointlike.SkyProj_swigregister
SkyProj_swigregister(SkyProj)

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

    def __init__(self, dir, energy, time, event_class=-1, source=-1):
        this = _pointlike.new_Photon(dir, energy, time, event_class, source)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def energy(self):
        return _pointlike.Photon_energy(self)

    def eventClass(self):
        return _pointlike.Photon_eventClass(self)

    def time(self):
        return _pointlike.Photon_time(self)

    def source(self):
        return _pointlike.Photon_source(self)
    __swig_destroy__ = _pointlike.delete_Photon
    __del__ = lambda self: None
Photon_swigregister = _pointlike.Photon_swigregister
Photon_swigregister(Photon)

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

    def __init__(self, filename, offset=0):
        this = _pointlike.new_PointingHistory(filename, offset)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_PointingHistory
    __del__ = lambda self: None

    def readFitsData(self, filename):
        return _pointlike.PointingHistory_readFitsData(self, filename)

    def __call__(self, time):
        return _pointlike.PointingHistory___call__(self, time)

    def startTime(self):
        return _pointlike.PointingHistory_startTime(self)

    def endTime(self):
        return _pointlike.PointingHistory_endTime(self)
PointingHistory_swigregister = _pointlike.PointingHistory_swigregister
PointingHistory_swigregister(PointingHistory)

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

    def __init__(self, *args):
        this = _pointlike.new_PointingInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_PointingInfo
    __del__ = lambda self: None

    def xAxis(self):
        return _pointlike.PointingInfo_xAxis(self)

    def zAxis(self):
        return _pointlike.PointingInfo_zAxis(self)

    def zenith(self):
        return _pointlike.PointingInfo_zenith(self)

    def position(self):
        return _pointlike.PointingInfo_position(self)

    def earthCoord(self):
        return _pointlike.PointingInfo_earthCoord(self)

    def quaternion(self):
        return _pointlike.PointingInfo_quaternion(self)

    def rotation(self):
        return _pointlike.PointingInfo_rotation(self)

    def interpolate(self, next, fraction, time):
        return _pointlike.PointingInfo_interpolate(self, next, fraction, time)
PointingInfo_swigregister = _pointlike.PointingInfo_swigregister
PointingInfo_swigregister(PointingInfo)

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

    def __init__(self, *args):
        this = _pointlike.new_EarthCoordinate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def computeFerrariLatitudeAndAltitude(self, pos, lat, alt):
        return _pointlike.EarthCoordinate_computeFerrariLatitudeAndAltitude(self, pos, lat, alt)

    def insideSAA(self, *args):
        return _pointlike.EarthCoordinate_insideSAA(self, *args)
    if _newclass:
        earthRadius = staticmethod(_pointlike.EarthCoordinate_earthRadius)
    else:
        earthRadius = _pointlike.EarthCoordinate_earthRadius

    def latitude(self):
        return _pointlike.EarthCoordinate_latitude(self)

    def longitude(self):
        return _pointlike.EarthCoordinate_longitude(self)

    def altitude(self):
        return _pointlike.EarthCoordinate_altitude(self)

    def L(self):
        return _pointlike.EarthCoordinate_L(self)

    def B(self):
        return _pointlike.EarthCoordinate_B(self)

    def _lambda(self):
        return _pointlike.EarthCoordinate__lambda(self)

    def R(self):
        return _pointlike.EarthCoordinate_R(self)

    def geolat(self):
        return _pointlike.EarthCoordinate_geolat(self)

    def geolon(self):
        return _pointlike.EarthCoordinate_geolon(self)

    def magnetic_field(self):
        return _pointlike.EarthCoordinate_magnetic_field(self)
    if _newclass:
        setSAAboundary = staticmethod(_pointlike.EarthCoordinate_setSAAboundary)
    else:
        setSAAboundary = _pointlike.EarthCoordinate_setSAAboundary
    __swig_destroy__ = _pointlike.delete_EarthCoordinate
    __del__ = lambda self: None
EarthCoordinate_swigregister = _pointlike.EarthCoordinate_swigregister
EarthCoordinate_swigregister(EarthCoordinate)

def EarthCoordinate_earthRadius():
    return _pointlike.EarthCoordinate_earthRadius()
EarthCoordinate_earthRadius = _pointlike.EarthCoordinate_earthRadius

def EarthCoordinate_setSAAboundary(boundary):
    return _pointlike.EarthCoordinate_setSAAboundary(boundary)
EarthCoordinate_setSAAboundary = _pointlike.EarthCoordinate_setSAAboundary

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    GLAST = _pointlike.GPS_GLAST
    LAT = _pointlike.GPS_LAT
    ZENITH = _pointlike.GPS_ZENITH
    CELESTIAL = _pointlike.GPS_CELESTIAL
    NADIR = _pointlike.GPS_NADIR
    NONE = _pointlike.GPS_NONE
    UPDOWN = _pointlike.GPS_UPDOWN
    SLEWING = _pointlike.GPS_SLEWING
    ONEPERORBIT = _pointlike.GPS_ONEPERORBIT
    EXPLICIT = _pointlike.GPS_EXPLICIT
    POINT = _pointlike.GPS_POINT
    HISTORY = _pointlike.GPS_HISTORY
    HISTORY_X_EAST = _pointlike.GPS_HISTORY_X_EAST

    def lat(self, *args):
        return _pointlike.GPS_lat(self, *args)

    def lon(self, *args):
        return _pointlike.GPS_lon(self, *args)

    def altitude(self, *args):
        return _pointlike.GPS_altitude(self, *args)

    def zAxisDir(self, *args):
        return _pointlike.GPS_zAxisDir(self, *args)

    def xAxisDir(self, *args):
        return _pointlike.GPS_xAxisDir(self, *args)

    def zenithDir(self, *args):
        return _pointlike.GPS_zenithDir(self, *args)

    def position(self, *args):
        return _pointlike.GPS_position(self, *args)

    def earthpos(self, *args):
        return _pointlike.GPS_earthpos(self, *args)

    def transformToGlast(self, seconds, index):
        return _pointlike.GPS_transformToGlast(self, seconds, index)

    def LATdirection(self, index, dir, met=-1):
        return _pointlike.GPS_LATdirection(self, index, dir, met)

    def toSky(self, latdir, met=-1):
        return _pointlike.GPS_toSky(self, latdir, met)

    def aberration(self, sdir, met=-1):
        return _pointlike.GPS_aberration(self, sdir, met)

    def correct(self, sdir, met=-1):
        return _pointlike.GPS_correct(self, sdir, met)

    def expansion(self, *args):
        return _pointlike.GPS_expansion(self, *args)

    def synch(self):
        return _pointlike.GPS_synch(self)

    def sampleintvl(self, *args):
        return _pointlike.GPS_sampleintvl(self, *args)

    def setPointingDirection(self, dir):
        return _pointlike.GPS_setPointingDirection(self, dir)

    def setPointingHistoryFile(self, fileName, offset=0, x_horizontal=False):
        return _pointlike.GPS_setPointingHistoryFile(self, fileName, offset, x_horizontal)

    def history(self):
        return _pointlike.GPS_history(self)

    def notifyObservers(self):
        return _pointlike.GPS_notifyObservers(self)

    def notification(self):
        return _pointlike.GPS_notification(self)
    if _newclass:
        instance = staticmethod(_pointlike.GPS_instance)
    else:
        instance = _pointlike.GPS_instance
    if _newclass:
        kill = staticmethod(_pointlike.GPS_kill)
    else:
        kill = _pointlike.GPS_kill

    def rockingDegrees(self, rockDegrees):
        return _pointlike.GPS_rockingDegrees(self, rockDegrees)

    def setRockType(self, rockType):
        return _pointlike.GPS_setRockType(self, rockType)

    def time(self, *args):
        return _pointlike.GPS_time(self, *args)

    def endTime(self):
        return _pointlike.GPS_endTime(self)
    if _newclass:
        test = staticmethod(_pointlike.GPS_test)
    else:
        test = _pointlike.GPS_test

    def setAlignmentRotation(self, r):
        return _pointlike.GPS_setAlignmentRotation(self, r)

    def enableAberration(self, flag=True):
        return _pointlike.GPS_enableAberration(self, flag)
GPS_swigregister = _pointlike.GPS_swigregister
GPS_swigregister(GPS)

def GPS_instance():
    return _pointlike.GPS_instance()
GPS_instance = _pointlike.GPS_instance

def GPS_kill():
    return _pointlike.GPS_kill()
GPS_kill = _pointlike.GPS_kill

def GPS_test():
    return _pointlike.GPS_test()
GPS_test = _pointlike.GPS_test

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

    def __init__(self, *args):
        this = _pointlike.new_Quaternion(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_Quaternion
    __del__ = lambda self: None

    def isNear(self, other):
        return _pointlike.Quaternion_isNear(self, other)

    def __mul__(self, *args):
        return _pointlike.Quaternion___mul__(self, *args)

    def vector(self):
        return _pointlike.Quaternion_vector(self)

    def scalar(self):
        return _pointlike.Quaternion_scalar(self)

    def norm(self):
        return _pointlike.Quaternion_norm(self)

    def conjugate(self):
        return _pointlike.Quaternion_conjugate(self)

    def rotate(self, v):
        return _pointlike.Quaternion_rotate(self, v)

    def rotation(self):
        return _pointlike.Quaternion_rotation(self)

    def power(self, t):
        return _pointlike.Quaternion_power(self, t)

    def interpolate(self, q1, t):
        return _pointlike.Quaternion_interpolate(self, q1, t)
    if _newclass:
        test = staticmethod(_pointlike.Quaternion_test)
    else:
        test = _pointlike.Quaternion_test
Quaternion_swigregister = _pointlike.Quaternion_swigregister
Quaternion_swigregister(Quaternion)

def Quaternion_test():
    return _pointlike.Quaternion_test()
Quaternion_test = _pointlike.Quaternion_test

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

    def getGregorianDate(self, *args):
        return _pointlike.JulianDate_getGregorianDate(self, *args)

    def __init__(self, *args):
        this = _pointlike.new_JulianDate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def seconds(self):
        return _pointlike.JulianDate_seconds(self)
    secondsPerDay = _pointlike.JulianDate_secondsPerDay
    if _newclass:
        missionStart = staticmethod(_pointlike.JulianDate_missionStart)
    else:
        missionStart = _pointlike.JulianDate_missionStart
    __swig_destroy__ = _pointlike.delete_JulianDate
    __del__ = lambda self: None
JulianDate_swigregister = _pointlike.JulianDate_swigregister
JulianDate_swigregister(JulianDate)

def JulianDate_missionStart():
    return _pointlike.JulianDate_missionStart()
JulianDate_missionStart = _pointlike.JulianDate_missionStart

class Healpix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Healpix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Healpix, name)
    __repr__ = _swig_repr
    RING = _pointlike.Healpix_RING
    NESTED = _pointlike.Healpix_NESTED
    NEST = _pointlike.Healpix_NEST

    def __init__(self, *args):
        this = _pointlike.new_Healpix(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def nside(self):
        return _pointlike.Healpix_nside(self)

    def npix(self):
        return _pointlike.Healpix_npix(self)

    def size(self):
        return _pointlike.Healpix_size(self)

    def pixelArea(self):
        return _pointlike.Healpix_pixelArea(self)

    def ord(self):
        return _pointlike.Healpix_ord(self)

    def nested(self):
        return _pointlike.Healpix_nested(self)

    def coordsys(self):
        return _pointlike.Healpix_coordsys(self)

    def galactic(self):
        return _pointlike.Healpix_galactic(self)

    def findNeighbors(self, index, neighbors):
        return _pointlike.Healpix_findNeighbors(self, index, neighbors)

    def query_disc(self, dir, radius, v):
        return _pointlike.Healpix_query_disc(self, dir, radius, v)

    def pix2ang(self, index, theta, phi):
        return _pointlike.Healpix_pix2ang(self, index, theta, phi)

    def ang2pix(self, theta, phi, index):
        return _pointlike.Healpix_ang2pix(self, theta, phi, index)
    __swig_destroy__ = _pointlike.delete_Healpix
    __del__ = lambda self: None
Healpix_swigregister = _pointlike.Healpix_swigregister
Healpix_swigregister(Healpix)

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

    def __init__(self, *args):
        this = _pointlike.new_Module(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_Module
    __del__ = lambda self: None

    def getValue(self, *args):
        return _pointlike.Module_getValue(self, *args)

    def getList(self, *args):
        return _pointlike.Module_getList(self, *args)

    def getDict(self, *args):
        return _pointlike.Module_getDict(self, *args)

    def type(self, obj):
        return _pointlike.Module_type(self, obj)

    def call(self, o, args=None):
        return _pointlike.Module_call(self, o, args)

    def attribute(self, name, check=True):
        return _pointlike.Module_attribute(self, name, check)

    def root(self):
        return _pointlike.Module_root(self)
    if _newclass:
        test = staticmethod(_pointlike.Module_test)
    else:
        test = _pointlike.Module_test
Module_swigregister = _pointlike.Module_swigregister
Module_swigregister(Module)

def Module_test(argc, argv, modulename):
    return _pointlike.Module_test(argc, argv, modulename)
Module_test = _pointlike.Module_test

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

    def __init__(self, data, dir, umax, background):
        this = _pointlike.new_SimpleLikelihood(data, dir, umax, background)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_SimpleLikelihood
    __del__ = lambda self: None

    def band(self, i=0):
        return _pointlike.SimpleLikelihood_band(self, i)

    def bands(self):
        return _pointlike.SimpleLikelihood_bands(self)

    def addBand(self, moredata, background=None):
        return _pointlike.SimpleLikelihood_addBand(self, moredata, background)

    def logLikelihood(self, counts):
        return _pointlike.SimpleLikelihood_logLikelihood(self, counts)

    def extendedLikelihood(self, expected):
        return _pointlike.SimpleLikelihood_extendedLikelihood(self, expected)

    def maximize(self):
        return _pointlike.SimpleLikelihood_maximize(self)

    def photons(self):
        return _pointlike.SimpleLikelihood_photons(self)

    def gradient(self):
        return _pointlike.SimpleLikelihood_gradient(self)

    def curvature(self):
        return _pointlike.SimpleLikelihood_curvature(self)

    def value(self):
        return _pointlike.SimpleLikelihood_value(self)

    def setDir(self, dir, subset=False):
        return _pointlike.SimpleLikelihood_setDir(self, dir, subset)

    def alpha(self):
        return _pointlike.SimpleLikelihood_alpha(self)

    def setalpha(self, alpha):
        return _pointlike.SimpleLikelihood_setalpha(self, alpha)

    def sigma_alpha(self):
        return _pointlike.SimpleLikelihood_sigma_alpha(self)

    def TS(self, alpha=-1):
        return _pointlike.SimpleLikelihood_TS(self, alpha)

    def poissonLikelihood(self, a):
        return _pointlike.SimpleLikelihood_poissonLikelihood(self, a)

    def poissonDerivatives(self, a):
        return _pointlike.SimpleLikelihood_poissonDerivatives(self, a)

    def signal(self, a=-1):
        return _pointlike.SimpleLikelihood_signal(self, a)

    def background(self):
        return _pointlike.SimpleLikelihood_background(self)

    def solidAngle(self):
        return _pointlike.SimpleLikelihood_solidAngle(self)

    def umax(self):
        return _pointlike.SimpleLikelihood_umax(self)

    def average_u(self):
        return _pointlike.SimpleLikelihood_average_u(self)

    def average_b(self):
        return _pointlike.SimpleLikelihood_average_b(self)

    def feval(self, k):
        return _pointlike.SimpleLikelihood_feval(self, k)

    def geval(self, k):
        return _pointlike.SimpleLikelihood_geval(self, k)

    def eval(self, ks, gamma):
        return _pointlike.SimpleLikelihood_eval(self, ks, gamma)

    def exposure(self):
        return _pointlike.SimpleLikelihood_exposure(self)

    def changepsf(self):
        return _pointlike.SimpleLikelihood_changepsf(self)

    def setgamma(self, gamma):
        return _pointlike.SimpleLikelihood_setgamma(self, gamma)

    def __call__(self, *args):
        return _pointlike.SimpleLikelihood___call__(self, *args)

    def display(self, dir, mode):
        return _pointlike.SimpleLikelihood_display(self, dir, mode)

    def sigma(self):
        return _pointlike.SimpleLikelihood_sigma(self)

    def setsigma(self, sigma):
        return _pointlike.SimpleLikelihood_setsigma(self, sigma)

    def gamma(self):
        return _pointlike.SimpleLikelihood_gamma(self)

    def recalc(self, subset=True):
        return _pointlike.SimpleLikelihood_recalc(self, subset)

    def reload(self, subset=True):
        return _pointlike.SimpleLikelihood_reload(self, subset)

    def TSmap(self, sdir):
        return _pointlike.SimpleLikelihood_TSmap(self, sdir)

    def derivatives(self, x):
        return _pointlike.SimpleLikelihood_derivatives(self, x)

    def background_function(self):
        return _pointlike.SimpleLikelihood_background_function(self)

    def aperature_correction(self):
        return _pointlike.SimpleLikelihood_aperature_correction(self)
    if _newclass:
        tolerance = staticmethod(_pointlike.SimpleLikelihood_tolerance)
    else:
        tolerance = _pointlike.SimpleLikelihood_tolerance
    if _newclass:
        setTolerance = staticmethod(_pointlike.SimpleLikelihood_setTolerance)
    else:
        setTolerance = _pointlike.SimpleLikelihood_setTolerance
    if _newclass:
        defaultUmax = staticmethod(_pointlike.SimpleLikelihood_defaultUmax)
    else:
        defaultUmax = _pointlike.SimpleLikelihood_defaultUmax
    if _newclass:
        setDefaultUmax = staticmethod(_pointlike.SimpleLikelihood_setDefaultUmax)
    else:
        setDefaultUmax = _pointlike.SimpleLikelihood_setDefaultUmax
    if _newclass:
        enable_extended_likelihood = staticmethod(_pointlike.SimpleLikelihood_enable_extended_likelihood)
    else:
        enable_extended_likelihood = _pointlike.SimpleLikelihood_enable_extended_likelihood
    if _newclass:
        extended_likelihood = staticmethod(_pointlike.SimpleLikelihood_extended_likelihood)
    else:
        extended_likelihood = _pointlike.SimpleLikelihood_extended_likelihood
SimpleLikelihood_swigregister = _pointlike.SimpleLikelihood_swigregister
SimpleLikelihood_swigregister(SimpleLikelihood)

def SimpleLikelihood_tolerance():
    return _pointlike.SimpleLikelihood_tolerance()
SimpleLikelihood_tolerance = _pointlike.SimpleLikelihood_tolerance

def SimpleLikelihood_setTolerance(tol):
    return _pointlike.SimpleLikelihood_setTolerance(tol)
SimpleLikelihood_setTolerance = _pointlike.SimpleLikelihood_setTolerance

def SimpleLikelihood_defaultUmax():
    return _pointlike.SimpleLikelihood_defaultUmax()
SimpleLikelihood_defaultUmax = _pointlike.SimpleLikelihood_defaultUmax

def SimpleLikelihood_setDefaultUmax(umax):
    return _pointlike.SimpleLikelihood_setDefaultUmax(umax)
SimpleLikelihood_setDefaultUmax = _pointlike.SimpleLikelihood_setDefaultUmax

def SimpleLikelihood_enable_extended_likelihood(q=True):
    return _pointlike.SimpleLikelihood_enable_extended_likelihood(q)
SimpleLikelihood_enable_extended_likelihood = _pointlike.SimpleLikelihood_enable_extended_likelihood

def SimpleLikelihood_extended_likelihood():
    return _pointlike.SimpleLikelihood_extended_likelihood()
SimpleLikelihood_extended_likelihood = _pointlike.SimpleLikelihood_extended_likelihood

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

    def __init__(self, data, name, dir):
        this = _pointlike.new_PointSourceLikelihood(data, name, dir)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_PointSourceLikelihood
    __del__ = lambda self: None

    def maximize(self):
        return _pointlike.PointSourceLikelihood_maximize(self)

    def setDir(self, dir, subset=False):
        return _pointlike.PointSourceLikelihood_setDir(self, dir, subset)

    def gradient(self):
        return _pointlike.PointSourceLikelihood_gradient(self)

    def curvature(self):
        return _pointlike.PointSourceLikelihood_curvature(self)

    def printSpectrum(self):
        return _pointlike.PointSourceLikelihood_printSpectrum(self)

    def energyList(self):
        return _pointlike.PointSourceLikelihood_energyList(self)

    def localize(self, *args):
        return _pointlike.PointSourceLikelihood_localize(self, *args)

    def logLikelihood(self, model, extended=True):
        return _pointlike.PointSourceLikelihood_logLikelihood(self, model, extended)

    def name(self):
        return _pointlike.PointSourceLikelihood_name(self)

    def dir(self):
        return _pointlike.PointSourceLikelihood_dir(self)

    def TS(self, *args):
        return _pointlike.PointSourceLikelihood_TS(self, *args)

    def alpha(self, band):
        return _pointlike.PointSourceLikelihood_alpha(self, band)

    def errorCircle(self):
        return _pointlike.PointSourceLikelihood_errorCircle(self)

    def set_ostream(self, out):
        return _pointlike.PointSourceLikelihood_set_ostream(self, out)
    if _newclass:
        set_verbose = staticmethod(_pointlike.PointSourceLikelihood_set_verbose)
    else:
        set_verbose = _pointlike.PointSourceLikelihood_set_verbose
    if _newclass:
        verbose = staticmethod(_pointlike.PointSourceLikelihood_verbose)
    else:
        verbose = _pointlike.PointSourceLikelihood_verbose

    def value(self, dir, e):
        return _pointlike.PointSourceLikelihood_value(self, dir, e)

    def band_value(self, dir, band):
        return _pointlike.PointSourceLikelihood_band_value(self, dir, band)

    def integral(self, dir, a, b):
        return _pointlike.PointSourceLikelihood_integral(self, dir, a, b)
    if _newclass:
        setParameters = staticmethod(_pointlike.PointSourceLikelihood_setParameters)
    else:
        setParameters = _pointlike.PointSourceLikelihood_setParameters
    if _newclass:
        setDefaultUmax = staticmethod(_pointlike.PointSourceLikelihood_setDefaultUmax)
    else:
        setDefaultUmax = _pointlike.PointSourceLikelihood_setDefaultUmax
    if _newclass:
        set_diffuse = staticmethod(_pointlike.PointSourceLikelihood_set_diffuse)
    else:
        set_diffuse = _pointlike.PointSourceLikelihood_set_diffuse
    if _newclass:
        set_background = staticmethod(_pointlike.PointSourceLikelihood_set_background)
    else:
        set_background = _pointlike.PointSourceLikelihood_set_background
    if _newclass:
        clear_background = staticmethod(_pointlike.PointSourceLikelihood_clear_background)
    else:
        clear_background = _pointlike.PointSourceLikelihood_clear_background

    def addBackgroundPointSource(self, fit):
        return _pointlike.PointSourceLikelihood_addBackgroundPointSource(self, fit)

    def clearBackgroundPointSource(self):
        return _pointlike.PointSourceLikelihood_clearBackgroundPointSource(self)

    def background(self):
        return _pointlike.PointSourceLikelihood_background(self)
    if _newclass:
        set_tolerance = staticmethod(_pointlike.PointSourceLikelihood_set_tolerance)
    else:
        set_tolerance = _pointlike.PointSourceLikelihood_set_tolerance
    if _newclass:
        set_energy_range = staticmethod(_pointlike.PointSourceLikelihood_set_energy_range)
    else:
        set_energy_range = _pointlike.PointSourceLikelihood_set_energy_range
    if _newclass:
        get_energy_range = staticmethod(_pointlike.PointSourceLikelihood_get_energy_range)
    else:
        get_energy_range = _pointlike.PointSourceLikelihood_get_energy_range
    if _newclass:
        set_min_alpha = staticmethod(_pointlike.PointSourceLikelihood_set_min_alpha)
    else:
        set_min_alpha = _pointlike.PointSourceLikelihood_set_min_alpha

    def display(self, dir, energy, mode):
        return _pointlike.PointSourceLikelihood_display(self, dir, energy, mode)

    def TSmap(self, sdir, band=-1):
        return _pointlike.PointSourceLikelihood_TSmap(self, sdir, band)
    if _newclass:
        set_merge = staticmethod(_pointlike.PointSourceLikelihood_set_merge)
    else:
        set_merge = _pointlike.PointSourceLikelihood_set_merge
    if _newclass:
        merge = staticmethod(_pointlike.PointSourceLikelihood_merge)
    else:
        merge = _pointlike.PointSourceLikelihood_merge
    if _newclass:
        set_fitlsq = staticmethod(_pointlike.PointSourceLikelihood_set_fitlsq)
    else:
        set_fitlsq = _pointlike.PointSourceLikelihood_set_fitlsq
    if _newclass:
        fitlsq = staticmethod(_pointlike.PointSourceLikelihood_fitlsq)
    else:
        fitlsq = _pointlike.PointSourceLikelihood_fitlsq
    if _newclass:
        set_maxROI = staticmethod(_pointlike.PointSourceLikelihood_set_maxROI)
    else:
        set_maxROI = _pointlike.PointSourceLikelihood_set_maxROI
    if _newclass:
        maxROI = staticmethod(_pointlike.PointSourceLikelihood_maxROI)
    else:
        maxROI = _pointlike.PointSourceLikelihood_maxROI
    if _newclass:
        set_minROI = staticmethod(_pointlike.PointSourceLikelihood_set_minROI)
    else:
        set_minROI = _pointlike.PointSourceLikelihood_set_minROI
    if _newclass:
        minROI = staticmethod(_pointlike.PointSourceLikelihood_minROI)
    else:
        minROI = _pointlike.PointSourceLikelihood_minROI
    if _newclass:
        set_maxSig = staticmethod(_pointlike.PointSourceLikelihood_set_maxSig)
    else:
        set_maxSig = _pointlike.PointSourceLikelihood_set_maxSig
    if _newclass:
        maxSig = staticmethod(_pointlike.PointSourceLikelihood_maxSig)
    else:
        maxSig = _pointlike.PointSourceLikelihood_maxSig
    if _newclass:
        set_conf = staticmethod(_pointlike.PointSourceLikelihood_set_conf)
    else:
        set_conf = _pointlike.PointSourceLikelihood_set_conf
    if _newclass:
        conf = staticmethod(_pointlike.PointSourceLikelihood_conf)
    else:
        conf = _pointlike.PointSourceLikelihood_conf

    def setup(self, data):
        return _pointlike.PointSourceLikelihood_setup(self, data)

    def out(self):
        return _pointlike.PointSourceLikelihood_out(self)

    def __getitem__(self, i):
        return _pointlike.PointSourceLikelihood___getitem__(self, i)

    def __len__(self):
        return _pointlike.PointSourceLikelihood___len__(self)
PointSourceLikelihood_swigregister = _pointlike.PointSourceLikelihood_swigregister
PointSourceLikelihood_swigregister(PointSourceLikelihood)

def PointSourceLikelihood_set_verbose(verbosity=True):
    return _pointlike.PointSourceLikelihood_set_verbose(verbosity)
PointSourceLikelihood_set_verbose = _pointlike.PointSourceLikelihood_set_verbose

def PointSourceLikelihood_verbose():
    return _pointlike.PointSourceLikelihood_verbose()
PointSourceLikelihood_verbose = _pointlike.PointSourceLikelihood_verbose

def PointSourceLikelihood_setParameters(par):
    return _pointlike.PointSourceLikelihood_setParameters(par)
PointSourceLikelihood_setParameters = _pointlike.PointSourceLikelihood_setParameters

def PointSourceLikelihood_setDefaultUmax(umax):
    return _pointlike.PointSourceLikelihood_setDefaultUmax(umax)
PointSourceLikelihood_setDefaultUmax = _pointlike.PointSourceLikelihood_setDefaultUmax

def PointSourceLikelihood_set_diffuse(*args):
    return _pointlike.PointSourceLikelihood_set_diffuse(*args)
PointSourceLikelihood_set_diffuse = _pointlike.PointSourceLikelihood_set_diffuse

def PointSourceLikelihood_set_background(background):
    return _pointlike.PointSourceLikelihood_set_background(background)
PointSourceLikelihood_set_background = _pointlike.PointSourceLikelihood_set_background

def PointSourceLikelihood_clear_background():
    return _pointlike.PointSourceLikelihood_clear_background()
PointSourceLikelihood_clear_background = _pointlike.PointSourceLikelihood_clear_background

def PointSourceLikelihood_set_tolerance(tol):
    return _pointlike.PointSourceLikelihood_set_tolerance(tol)
PointSourceLikelihood_set_tolerance = _pointlike.PointSourceLikelihood_set_tolerance

def PointSourceLikelihood_set_energy_range(emin, emax=1e6):
    return _pointlike.PointSourceLikelihood_set_energy_range(emin, emax)
PointSourceLikelihood_set_energy_range = _pointlike.PointSourceLikelihood_set_energy_range

def PointSourceLikelihood_get_energy_range(emin, emax):
    return _pointlike.PointSourceLikelihood_get_energy_range(emin, emax)
PointSourceLikelihood_get_energy_range = _pointlike.PointSourceLikelihood_get_energy_range

def PointSourceLikelihood_set_min_alpha(a):
    return _pointlike.PointSourceLikelihood_set_min_alpha(a)
PointSourceLikelihood_set_min_alpha = _pointlike.PointSourceLikelihood_set_min_alpha

def PointSourceLikelihood_set_merge(merge):
    return _pointlike.PointSourceLikelihood_set_merge(merge)
PointSourceLikelihood_set_merge = _pointlike.PointSourceLikelihood_set_merge

def PointSourceLikelihood_merge():
    return _pointlike.PointSourceLikelihood_merge()
PointSourceLikelihood_merge = _pointlike.PointSourceLikelihood_merge

def PointSourceLikelihood_set_fitlsq(fit):
    return _pointlike.PointSourceLikelihood_set_fitlsq(fit)
PointSourceLikelihood_set_fitlsq = _pointlike.PointSourceLikelihood_set_fitlsq

def PointSourceLikelihood_fitlsq():
    return _pointlike.PointSourceLikelihood_fitlsq()
PointSourceLikelihood_fitlsq = _pointlike.PointSourceLikelihood_fitlsq

def PointSourceLikelihood_set_maxROI(roi):
    return _pointlike.PointSourceLikelihood_set_maxROI(roi)
PointSourceLikelihood_set_maxROI = _pointlike.PointSourceLikelihood_set_maxROI

def PointSourceLikelihood_maxROI():
    return _pointlike.PointSourceLikelihood_maxROI()
PointSourceLikelihood_maxROI = _pointlike.PointSourceLikelihood_maxROI

def PointSourceLikelihood_set_minROI(roi):
    return _pointlike.PointSourceLikelihood_set_minROI(roi)
PointSourceLikelihood_set_minROI = _pointlike.PointSourceLikelihood_set_minROI

def PointSourceLikelihood_minROI():
    return _pointlike.PointSourceLikelihood_minROI()
PointSourceLikelihood_minROI = _pointlike.PointSourceLikelihood_minROI

def PointSourceLikelihood_set_maxSig(r):
    return _pointlike.PointSourceLikelihood_set_maxSig(r)
PointSourceLikelihood_set_maxSig = _pointlike.PointSourceLikelihood_set_maxSig

def PointSourceLikelihood_maxSig():
    return _pointlike.PointSourceLikelihood_maxSig()
PointSourceLikelihood_maxSig = _pointlike.PointSourceLikelihood_maxSig

def PointSourceLikelihood_set_conf(conf):
    return _pointlike.PointSourceLikelihood_set_conf(conf)
PointSourceLikelihood_set_conf = _pointlike.PointSourceLikelihood_set_conf

def PointSourceLikelihood_conf():
    return _pointlike.PointSourceLikelihood_conf()
PointSourceLikelihood_conf = _pointlike.PointSourceLikelihood_conf

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

    def __init__(self, psl, mode):
        this = _pointlike.new_PSLdisplay(psl, mode)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self, dir, e):
        return _pointlike.PSLdisplay_value(self, dir, e)

    def integral(self, dir, a, b):
        return _pointlike.PSLdisplay_integral(self, dir, a, b)

    def name(self):
        return _pointlike.PSLdisplay_name(self)
    __swig_destroy__ = _pointlike.delete_PSLdisplay
    __del__ = lambda self: None
PSLdisplay_swigregister = _pointlike.PSLdisplay_swigregister
PSLdisplay_swigregister(PSLdisplay)

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

    def __init__(self, *args):
        this = _pointlike.new_TSmap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setPointSource(self, psl):
        return _pointlike.TSmap_setPointSource(self, psl)
    __swig_destroy__ = _pointlike.delete_TSmap
    __del__ = lambda self: None

    def __call__(self, sdir):
        return _pointlike.TSmap___call__(self, sdir)
TSmap_swigregister = _pointlike.TSmap_swigregister
TSmap_swigregister(TSmap)

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

    def __init__(self, *args):
        this = _pointlike.new_Data(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add(self, file, event_type=-1, source_id=-1):
        return _pointlike.Data_add(self, file, event_type, source_id)

    def addgti(self, file):
        return _pointlike.Data_addgti(self, file)

    def map(self, *args):
        return _pointlike.Data_map(self, *args)
    __swig_destroy__ = _pointlike.delete_Data
    __del__ = lambda self: None

    def minTime(self):
        return _pointlike.Data_minTime(self)

    def maxTime(self):
        return _pointlike.Data_maxTime(self)

    def info(self, *args):
        return _pointlike.Data_info(self, *args)

    def combine_bands(self):
        return _pointlike.Data_combine_bands(self)

    def write(self, outputFile, clobber=True):
        return _pointlike.Data_write(self, outputFile, clobber)
    if _newclass:
        setHistoryFile = staticmethod(_pointlike.Data_setHistoryFile)
    else:
        setHistoryFile = _pointlike.Data_setHistoryFile
    if _newclass:
        class_level = staticmethod(_pointlike.Data_class_level)
    else:
        class_level = _pointlike.Data_class_level
    if _newclass:
        set_class_level = staticmethod(_pointlike.Data_set_class_level)
    else:
        set_class_level = _pointlike.Data_set_class_level
    if _newclass:
        use_mc_energy = staticmethod(_pointlike.Data_use_mc_energy)
    else:
        use_mc_energy = _pointlike.Data_use_mc_energy
    if _newclass:
        set_use_mc_energy = staticmethod(_pointlike.Data_set_use_mc_energy)
    else:
        set_use_mc_energy = _pointlike.Data_set_use_mc_energy
    if _newclass:
        set_rot = staticmethod(_pointlike.Data_set_rot)
    else:
        set_rot = _pointlike.Data_set_rot
    if _newclass:
        set_alignment = staticmethod(_pointlike.Data_set_alignment)
    else:
        set_alignment = _pointlike.Data_set_alignment
    if _newclass:
        get_rot = staticmethod(_pointlike.Data_get_rot)
    else:
        get_rot = _pointlike.Data_get_rot
    if _newclass:
        historyfile = staticmethod(_pointlike.Data_historyfile)
    else:
        historyfile = _pointlike.Data_historyfile
    if _newclass:
        get_pointing = staticmethod(_pointlike.Data_get_pointing)
    else:
        get_pointing = _pointlike.Data_get_pointing
    if _newclass:
        inTimeRange = staticmethod(_pointlike.Data_inTimeRange)
    else:
        inTimeRange = _pointlike.Data_inTimeRange
    if _newclass:
        setEnergyBins = staticmethod(_pointlike.Data_setEnergyBins)
    else:
        setEnergyBins = _pointlike.Data_setEnergyBins
    if _newclass:
        setPhotonBinner = staticmethod(_pointlike.Data_setPhotonBinner)
    else:
        setPhotonBinner = _pointlike.Data_setPhotonBinner
    if _newclass:
        zenith_angle_cut = staticmethod(_pointlike.Data_zenith_angle_cut)
    else:
        zenith_angle_cut = _pointlike.Data_zenith_angle_cut
    if _newclass:
        set_zenith_angle_cut = staticmethod(_pointlike.Data_set_zenith_angle_cut)
    else:
        set_zenith_angle_cut = _pointlike.Data_set_zenith_angle_cut
    if _newclass:
        theta_cut = staticmethod(_pointlike.Data_theta_cut)
    else:
        theta_cut = _pointlike.Data_theta_cut
    if _newclass:
        set_theta_cut = staticmethod(_pointlike.Data_set_theta_cut)
    else:
        set_theta_cut = _pointlike.Data_set_theta_cut
    if _newclass:
        theta_min_cut = staticmethod(_pointlike.Data_theta_min_cut)
    else:
        theta_min_cut = _pointlike.Data_theta_min_cut
    if _newclass:
        set_theta_min_cut = staticmethod(_pointlike.Data_set_theta_min_cut)
    else:
        set_theta_min_cut = _pointlike.Data_set_theta_min_cut
    if _newclass:
        useEarthCoordinates = staticmethod(_pointlike.Data_useEarthCoordinates)
    else:
        useEarthCoordinates = _pointlike.Data_useEarthCoordinates
    if _newclass:
        set_Gti_mask = staticmethod(_pointlike.Data_set_Gti_mask)
    else:
        set_Gti_mask = _pointlike.Data_set_Gti_mask
Data_swigregister = _pointlike.Data_swigregister
Data_swigregister(Data)

def Data_setHistoryFile(history):
    return _pointlike.Data_setHistoryFile(history)
Data_setHistoryFile = _pointlike.Data_setHistoryFile

def Data_class_level():
    return _pointlike.Data_class_level()
Data_class_level = _pointlike.Data_class_level

def Data_set_class_level(cut):
    return _pointlike.Data_set_class_level(cut)
Data_set_class_level = _pointlike.Data_set_class_level

def Data_use_mc_energy():
    return _pointlike.Data_use_mc_energy()
Data_use_mc_energy = _pointlike.Data_use_mc_energy

def Data_set_use_mc_energy(use_it):
    return _pointlike.Data_set_use_mc_energy(use_it)
Data_set_use_mc_energy = _pointlike.Data_set_use_mc_energy

def Data_set_rot(*args):
    return _pointlike.Data_set_rot(*args)
Data_set_rot = _pointlike.Data_set_rot

def Data_set_alignment(filename):
    return _pointlike.Data_set_alignment(filename)
Data_set_alignment = _pointlike.Data_set_alignment

def Data_get_rot(time):
    return _pointlike.Data_get_rot(time)
Data_get_rot = _pointlike.Data_get_rot

def Data_historyfile():
    return _pointlike.Data_historyfile()
Data_historyfile = _pointlike.Data_historyfile

def Data_get_pointing(time):
    return _pointlike.Data_get_pointing(time)
Data_get_pointing = _pointlike.Data_get_pointing

def Data_inTimeRange(time):
    return _pointlike.Data_inTimeRange(time)
Data_inTimeRange = _pointlike.Data_inTimeRange

def Data_setEnergyBins(bins):
    return _pointlike.Data_setEnergyBins(bins)
Data_setEnergyBins = _pointlike.Data_setEnergyBins

def Data_setPhotonBinner(binner):
    return _pointlike.Data_setPhotonBinner(binner)
Data_setPhotonBinner = _pointlike.Data_setPhotonBinner

def Data_zenith_angle_cut():
    return _pointlike.Data_zenith_angle_cut()
Data_zenith_angle_cut = _pointlike.Data_zenith_angle_cut

def Data_set_zenith_angle_cut(cut):
    return _pointlike.Data_set_zenith_angle_cut(cut)
Data_set_zenith_angle_cut = _pointlike.Data_set_zenith_angle_cut

def Data_theta_cut():
    return _pointlike.Data_theta_cut()
Data_theta_cut = _pointlike.Data_theta_cut

def Data_set_theta_cut(cut):
    return _pointlike.Data_set_theta_cut(cut)
Data_set_theta_cut = _pointlike.Data_set_theta_cut

def Data_theta_min_cut():
    return _pointlike.Data_theta_min_cut()
Data_theta_min_cut = _pointlike.Data_theta_min_cut

def Data_set_theta_min_cut(cut):
    return _pointlike.Data_set_theta_min_cut(cut)
Data_set_theta_min_cut = _pointlike.Data_set_theta_min_cut

def Data_useEarthCoordinates():
    return _pointlike.Data_useEarthCoordinates()
Data_useEarthCoordinates = _pointlike.Data_useEarthCoordinates

def Data_set_Gti_mask(arg2):
    return _pointlike.Data_set_Gti_mask(arg2)
Data_set_Gti_mask = _pointlike.Data_set_Gti_mask

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

    def __init__(self, *args):
        this = _pointlike.new_CanInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self):
        return _pointlike.CanInfo_value(self)

    def sigma(self):
        return _pointlike.CanInfo_sigma(self)

    def dir(self):
        return _pointlike.CanInfo_dir(self)

    def ra(self):
        return _pointlike.CanInfo_ra(self)

    def dec(self):
        return _pointlike.CanInfo_dec(self)

    def is2bdeleted(self):
        return _pointlike.CanInfo_is2bdeleted(self)

    def isSource(self):
        return _pointlike.CanInfo_isSource(self)

    def fit(self):
        return _pointlike.CanInfo_fit(self)

    def weighted_count(self):
        return _pointlike.CanInfo_weighted_count(self)

    def skipped(self):
        return _pointlike.CanInfo_skipped(self)

    def hasStrongNeighbor(self):
        return _pointlike.CanInfo_hasStrongNeighbor(self)

    def strongNeighbor(self):
        return _pointlike.CanInfo_strongNeighbor(self)

    def setDelete(self):
        return _pointlike.CanInfo_setDelete(self)

    def setSource(self, value=True):
        return _pointlike.CanInfo_setSource(self, value)

    def set_total_value(self, value=0.0):
        return _pointlike.CanInfo_set_total_value(self, value)

    def set_sigma(self, value=0.0):
        return _pointlike.CanInfo_set_sigma(self, value)

    def set_dir(self, *args):
        return _pointlike.CanInfo_set_dir(self, *args)

    def set_fit(self, fit):
        return _pointlike.CanInfo_set_fit(self, fit)

    def set_skipped(self, value=0):
        return _pointlike.CanInfo_set_skipped(self, value)

    def setHasStrongNeighbor(self, value=True):
        return _pointlike.CanInfo_setHasStrongNeighbor(self, value)

    def setStrongNeighbor(self, value):
        return _pointlike.CanInfo_setStrongNeighbor(self, value)
    __swig_destroy__ = _pointlike.delete_CanInfo
    __del__ = lambda self: None
CanInfo_swigregister = _pointlike.CanInfo_swigregister
CanInfo_swigregister(CanInfo)

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

    def __init__(self, data):
        this = _pointlike.new_SourceFinder(data)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_SourceFinder
    __del__ = lambda self: None

    def getCandidates(self):
        return _pointlike.SourceFinder_getCandidates(self)

    def examineRegion(self):
        return _pointlike.SourceFinder_examineRegion(self)

    def prune_neighbors(self):
        return _pointlike.SourceFinder_prune_neighbors(self)

    def createReg(self, *args):
        return _pointlike.SourceFinder_createReg(self, *args)

    def createTable(self, filename):
        return _pointlike.SourceFinder_createTable(self, filename)

    def getMap(self):
        return _pointlike.SourceFinder_getMap(self)

    def candidateList(self):
        return _pointlike.SourceFinder_candidateList(self)

    def createFitsFile(self, *args):
        return _pointlike.SourceFinder_createFitsFile(self, *args)

    def createRegFile(self, *args):
        return _pointlike.SourceFinder_createRegFile(self, *args)

    def run(self):
        return _pointlike.SourceFinder_run(self)
    if _newclass:
        setParameters = staticmethod(_pointlike.SourceFinder_setParameters)
    else:
        setParameters = _pointlike.SourceFinder_setParameters
SourceFinder_swigregister = _pointlike.SourceFinder_swigregister
SourceFinder_swigregister(SourceFinder)

def SourceFinder_setParameters(module):
    return _pointlike.SourceFinder_setParameters(module)
SourceFinder_setParameters = _pointlike.SourceFinder_setParameters

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

    def __init__(self, *args):
        this = _pointlike.new_Draw(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def region(self, dir, outputFile, pixelsize, fov, smooth=False, mincount=0, kernel=0, smooth_radius=3):
        return _pointlike.Draw_region(self, dir, outputFile, pixelsize, fov, smooth, mincount, kernel, smooth_radius)

    def density(self, dir, outputFile, pixelsize, fov, smooth=False, mincount=0, kernel=0, smooth_radius=3):
        return _pointlike.Draw_density(self, dir, outputFile, pixelsize, fov, smooth, mincount, kernel, smooth_radius)

    def sky(self, outputfile, pixelsize=0.1, smooth=False, mincount=0):
        return _pointlike.Draw_sky(self, outputfile, pixelsize, smooth, mincount)

    def googleSky(self, outfile, pixelsize=0.1, smooth=False, mincount=0):
        return _pointlike.Draw_googleSky(self, outfile, pixelsize, smooth, mincount)

    def galactic(self):
        return _pointlike.Draw_galactic(self)

    def equatorial(self):
        return _pointlike.Draw_equatorial(self)

    def projection(self, p):
        return _pointlike.Draw_projection(self, p)

    def zenith(self):
        return _pointlike.Draw_zenith(self)

    def use_exposure(self, *args):
        return _pointlike.Draw_use_exposure(self, *args)

    def use_exposure2(self, *args):
        return _pointlike.Draw_use_exposure2(self, *args)

    def set_layers(self, n):
        return _pointlike.Draw_set_layers(self, n)
    __swig_destroy__ = _pointlike.delete_Draw
    __del__ = lambda self: None
Draw_swigregister = _pointlike.Draw_swigregister
Draw_swigregister(Draw)

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

    def __init__(self, *args):
        this = _pointlike.new_SkyDensity(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, sd):
        return _pointlike.SkyDensity___call__(self, sd)
    __swig_destroy__ = _pointlike.delete_SkyDensity
    __del__ = lambda self: None
SkyDensity_swigregister = _pointlike.SkyDensity_swigregister
SkyDensity_swigregister(SkyDensity)

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

    def __init__(self, *args):
        this = _pointlike.new_Source(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pointlike.delete_Source
    __del__ = lambda self: None

    def localize(self):
        return _pointlike.Source_localize(self)

    def name(self):
        return _pointlike.Source_name(self)

    def dir(self):
        return _pointlike.Source_dir(self)

    def seed_dir(self):
        return _pointlike.Source_seed_dir(self)

    def moved(self):
        return _pointlike.Source_moved(self)

    def info(self, *args):
        return _pointlike.Source_info(self, *args)
    if _newclass:
        header = staticmethod(_pointlike.Source_header)
    else:
        header = _pointlike.Source_header

    def TS(self, *args):
        return _pointlike.Source_TS(self, *args)

    def seedTS(self):
        return _pointlike.Source_seedTS(self)

    def sigma(self):
        return _pointlike.Source_sigma(self)

    def fit(self, *args):
        return _pointlike.Source_fit(self, *args)

    def neighbor(self):
        return _pointlike.Source_neighbor(self)

    def set_neighbor(self, other):
        return _pointlike.Source_set_neighbor(self, other)

    def fit_params(self):
        return _pointlike.Source_fit_params(self)

    def TScircle(self, radius=3.):
        return _pointlike.Source_TScircle(self, radius)
Source_swigregister = _pointlike.Source_swigregister
Source_swigregister(Source)

def Source_header(*args):
    return _pointlike.Source_header(*args)
Source_header = _pointlike.Source_header

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

    def __init__(self, *args):
        this = _pointlike.new_SourceList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def sort_TS(self):
        return _pointlike.SourceList_sort_TS(self)

    def sort_ra(self):
        return _pointlike.SourceList_sort_ra(self)

    def refit(self):
        return _pointlike.SourceList_refit(self)

    def filter_TS(self, threshold=0):
        return _pointlike.SourceList_filter_TS(self, threshold)

    def dump(self, *args):
        return _pointlike.SourceList_dump(self, *args)

    def dump_xml(self, *args):
        return _pointlike.SourceList_dump_xml(self, *args)

    def createRegFile(self, filename, color, tsmin):
        return _pointlike.SourceList_createRegFile(self, filename, color, tsmin)

    def verbose(self):
        return _pointlike.SourceList_verbose(self)
    if _newclass:
        set_log = staticmethod(_pointlike.SourceList_set_log)
    else:
        set_log = _pointlike.SourceList_set_log
    if _newclass:
        set_data = staticmethod(_pointlike.SourceList_set_data)
    else:
        set_data = _pointlike.SourceList_set_data
    if _newclass:
        data = staticmethod(_pointlike.SourceList_data)
    else:
        data = _pointlike.SourceList_data
    if _newclass:
        set_group_radius = staticmethod(_pointlike.SourceList_set_group_radius)
    else:
        set_group_radius = _pointlike.SourceList_set_group_radius
    if _newclass:
        set_uselsq = staticmethod(_pointlike.SourceList_set_uselsq)
    else:
        set_uselsq = _pointlike.SourceList_set_uselsq
    if _newclass:
        uselsq = staticmethod(_pointlike.SourceList_uselsq)
    else:
        uselsq = _pointlike.SourceList_uselsq

    def __getitem__(self, i):
        return _pointlike.SourceList___getitem__(self, i)

    def __len__(self):
        return _pointlike.SourceList___len__(self)

    def append(self, s):
        return _pointlike.SourceList_append(self, s)
    __swig_destroy__ = _pointlike.delete_SourceList
    __del__ = lambda self: None
SourceList_swigregister = _pointlike.SourceList_swigregister
SourceList_swigregister(SourceList)

def SourceList_set_log(logstream):
    return _pointlike.SourceList_set_log(logstream)
SourceList_set_log = _pointlike.SourceList_set_log

def SourceList_set_data(data):
    return _pointlike.SourceList_set_data(data)
SourceList_set_data = _pointlike.SourceList_set_data

def SourceList_data():
    return _pointlike.SourceList_data()
SourceList_data = _pointlike.SourceList_data

def SourceList_set_group_radius(value):
    return _pointlike.SourceList_set_group_radius(value)
SourceList_set_group_radius = _pointlike.SourceList_set_group_radius

def SourceList_set_uselsq(q):
    return _pointlike.SourceList_set_uselsq(q)
SourceList_set_uselsq = _pointlike.SourceList_set_uselsq

def SourceList_uselsq():
    return _pointlike.SourceList_uselsq()
SourceList_uselsq = _pointlike.SourceList_uselsq

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

    def __init__(self, psl, sigma=0):
        this = _pointlike.new_LeastSquaresFitter(psl, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def err(self):
        return _pointlike.LeastSquaresFitter_err(self)

    def params(self):
        return _pointlike.LeastSquaresFitter_params(self)

    def ellipse(self):
        return _pointlike.LeastSquaresFitter_ellipse(self)

    def func(self, params, x, y):
        return _pointlike.LeastSquaresFitter_func(self, params, x, y)
    if _newclass:
        header = staticmethod(_pointlike.LeastSquaresFitter_header)
    else:
        header = _pointlike.LeastSquaresFitter_header

    def __call__(self, dir):
        return _pointlike.LeastSquaresFitter___call__(self, dir)

    def test(self):
        return _pointlike.LeastSquaresFitter_test(self)
    __swig_destroy__ = _pointlike.delete_LeastSquaresFitter
    __del__ = lambda self: None
LeastSquaresFitter_swigregister = _pointlike.LeastSquaresFitter_swigregister
LeastSquaresFitter_swigregister(LeastSquaresFitter)

def LeastSquaresFitter_header():
    return _pointlike.LeastSquaresFitter_header()
LeastSquaresFitter_header = _pointlike.LeastSquaresFitter_header

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

    def __init__(self, *args):
        this = _pointlike.new_Alignment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def rotation(self, time):
        return _pointlike.Alignment_rotation(self, time)

    def rotate(self, arg2, time):
        return _pointlike.Alignment_rotate(self, arg2, time)

    def active(self):
        return _pointlike.Alignment_active(self)
    __swig_destroy__ = _pointlike.delete_Alignment
    __del__ = lambda self: None
Alignment_swigregister = _pointlike.Alignment_swigregister
Alignment_swigregister(Alignment)

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

    def iterator(self):
        return _pointlike.SourceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pointlike.SourceVector___nonzero__(self)

    def __bool__(self):
        return _pointlike.SourceVector___bool__(self)

    def __len__(self):
        return _pointlike.SourceVector___len__(self)

    def __getslice__(self, i, j):
        return _pointlike.SourceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pointlike.SourceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pointlike.SourceVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pointlike.SourceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pointlike.SourceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pointlike.SourceVector___setitem__(self, *args)

    def pop(self):
        return _pointlike.SourceVector_pop(self)

    def append(self, x):
        return _pointlike.SourceVector_append(self, x)

    def empty(self):
        return _pointlike.SourceVector_empty(self)

    def size(self):
        return _pointlike.SourceVector_size(self)

    def swap(self, v):
        return _pointlike.SourceVector_swap(self, v)

    def begin(self):
        return _pointlike.SourceVector_begin(self)

    def end(self):
        return _pointlike.SourceVector_end(self)

    def rbegin(self):
        return _pointlike.SourceVector_rbegin(self)

    def rend(self):
        return _pointlike.SourceVector_rend(self)

    def clear(self):
        return _pointlike.SourceVector_clear(self)

    def get_allocator(self):
        return _pointlike.SourceVector_get_allocator(self)

    def pop_back(self):
        return _pointlike.SourceVector_pop_back(self)

    def erase(self, *args):
        return _pointlike.SourceVector_erase(self, *args)

    def __init__(self, *args):
        this = _pointlike.new_SourceVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pointlike.SourceVector_push_back(self, x)

    def front(self):
        return _pointlike.SourceVector_front(self)

    def back(self):
        return _pointlike.SourceVector_back(self)

    def assign(self, n, x):
        return _pointlike.SourceVector_assign(self, n, x)

    def resize(self, *args):
        return _pointlike.SourceVector_resize(self, *args)

    def insert(self, *args):
        return _pointlike.SourceVector_insert(self, *args)

    def reserve(self, n):
        return _pointlike.SourceVector_reserve(self, n)

    def capacity(self):
        return _pointlike.SourceVector_capacity(self)
    __swig_destroy__ = _pointlike.delete_SourceVector
    __del__ = lambda self: None
SourceVector_swigregister = _pointlike.SourceVector_swigregister
SourceVector_swigregister(SourceVector)

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

    def iterator(self):
        return _pointlike.StringDoubleMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pointlike.StringDoubleMap___nonzero__(self)

    def __bool__(self):
        return _pointlike.StringDoubleMap___bool__(self)

    def __len__(self):
        return _pointlike.StringDoubleMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _pointlike.StringDoubleMap___getitem__(self, key)

    def __delitem__(self, key):
        return _pointlike.StringDoubleMap___delitem__(self, key)

    def has_key(self, key):
        return _pointlike.StringDoubleMap_has_key(self, key)

    def keys(self):
        return _pointlike.StringDoubleMap_keys(self)

    def values(self):
        return _pointlike.StringDoubleMap_values(self)

    def items(self):
        return _pointlike.StringDoubleMap_items(self)

    def __contains__(self, key):
        return _pointlike.StringDoubleMap___contains__(self, key)

    def key_iterator(self):
        return _pointlike.StringDoubleMap_key_iterator(self)

    def value_iterator(self):
        return _pointlike.StringDoubleMap_value_iterator(self)

    def __setitem__(self, *args):
        return _pointlike.StringDoubleMap___setitem__(self, *args)

    def asdict(self):
        return _pointlike.StringDoubleMap_asdict(self)

    def __init__(self, *args):
        this = _pointlike.new_StringDoubleMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _pointlike.StringDoubleMap_empty(self)

    def size(self):
        return _pointlike.StringDoubleMap_size(self)

    def swap(self, v):
        return _pointlike.StringDoubleMap_swap(self, v)

    def begin(self):
        return _pointlike.StringDoubleMap_begin(self)

    def end(self):
        return _pointlike.StringDoubleMap_end(self)

    def rbegin(self):
        return _pointlike.StringDoubleMap_rbegin(self)

    def rend(self):
        return _pointlike.StringDoubleMap_rend(self)

    def clear(self):
        return _pointlike.StringDoubleMap_clear(self)

    def get_allocator(self):
        return _pointlike.StringDoubleMap_get_allocator(self)

    def count(self, x):
        return _pointlike.StringDoubleMap_count(self, x)

    def erase(self, *args):
        return _pointlike.StringDoubleMap_erase(self, *args)

    def find(self, x):
        return _pointlike.StringDoubleMap_find(self, x)

    def lower_bound(self, x):
        return _pointlike.StringDoubleMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _pointlike.StringDoubleMap_upper_bound(self, x)
    __swig_destroy__ = _pointlike.delete_StringDoubleMap
    __del__ = lambda self: None
StringDoubleMap_swigregister = _pointlike.StringDoubleMap_swigregister
StringDoubleMap_swigregister(StringDoubleMap)

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

    def __init__(self, slike, dir, realizations=100):
        this = _pointlike.new_ConfidenceLevel(slike, dir, realizations)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self):
        return _pointlike.ConfidenceLevel___call__(self)

    def likelihood(self, alpha, save=False):
        return _pointlike.ConfidenceLevel_likelihood(self, alpha, save)

    def realize(self):
        return _pointlike.ConfidenceLevel_realize(self)
    __swig_destroy__ = _pointlike.delete_ConfidenceLevel
    __del__ = lambda self: None
ConfidenceLevel_swigregister = _pointlike.ConfidenceLevel_swigregister
ConfidenceLevel_swigregister(ConfidenceLevel)

# This file is compatible with both classic and new-style classes.


