# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _stl_vec
def _swig_setattr(self,class_type,name,value):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    self.__dict__[name] = value

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class intp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intp, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_intp,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_intp):
        try:
            if self.thisown: destroy(self)
        except: pass
    def assign(*args): return apply(_stl_vec.intp_assign,args)
    def value(*args): return apply(_stl_vec.intp_value,args)
    def cast(*args): return apply(_stl_vec.intp_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.intp_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.intp_frompointer)
    def __repr__(self):
        return "<C intp instance at %s>" % (self.this,)

class intpPtr(intp):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = intp
_stl_vec.intp_swigregister(intpPtr)
intp_frompointer = _stl_vec.intp_frompointer


class doublep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doublep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doublep, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_doublep,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_doublep):
        try:
            if self.thisown: destroy(self)
        except: pass
    def assign(*args): return apply(_stl_vec.doublep_assign,args)
    def value(*args): return apply(_stl_vec.doublep_value,args)
    def cast(*args): return apply(_stl_vec.doublep_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.doublep_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.doublep_frompointer)
    def __repr__(self):
        return "<C doublep instance at %s>" % (self.this,)

class doublepPtr(doublep):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = doublep
_stl_vec.doublep_swigregister(doublepPtr)
doublep_frompointer = _stl_vec.doublep_frompointer


class realtypep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, realtypep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, realtypep, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_realtypep,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_realtypep):
        try:
            if self.thisown: destroy(self)
        except: pass
    def assign(*args): return apply(_stl_vec.realtypep_assign,args)
    def value(*args): return apply(_stl_vec.realtypep_value,args)
    def cast(*args): return apply(_stl_vec.realtypep_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.realtypep_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.realtypep_frompointer)
    def __repr__(self):
        return "<C realtypep instance at %s>" % (self.this,)

class realtypepPtr(realtypep):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = realtypep
_stl_vec.realtypep_swigregister(realtypepPtr)
realtypep_frompointer = _stl_vec.realtypep_frompointer


class floatp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floatp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floatp, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_floatp,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_floatp):
        try:
            if self.thisown: destroy(self)
        except: pass
    def assign(*args): return apply(_stl_vec.floatp_assign,args)
    def value(*args): return apply(_stl_vec.floatp_value,args)
    def cast(*args): return apply(_stl_vec.floatp_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.floatp_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.floatp_frompointer)
    def __repr__(self):
        return "<C floatp instance at %s>" % (self.this,)

class floatpPtr(floatp):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = floatp
_stl_vec.floatp_swigregister(floatpPtr)
floatp_frompointer = _stl_vec.floatp_frompointer


class inta(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, inta, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, inta, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_inta,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_inta):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __getitem__(*args): return apply(_stl_vec.inta___getitem__,args)
    def __setitem__(*args): return apply(_stl_vec.inta___setitem__,args)
    def cast(*args): return apply(_stl_vec.inta_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.inta_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.inta_frompointer)
    def __repr__(self):
        return "<C inta instance at %s>" % (self.this,)

class intaPtr(inta):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = inta
_stl_vec.inta_swigregister(intaPtr)
inta_frompointer = _stl_vec.inta_frompointer


class doublea(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doublea, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doublea, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_doublea,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_doublea):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __getitem__(*args): return apply(_stl_vec.doublea___getitem__,args)
    def __setitem__(*args): return apply(_stl_vec.doublea___setitem__,args)
    def cast(*args): return apply(_stl_vec.doublea_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.doublea_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.doublea_frompointer)
    def __repr__(self):
        return "<C doublea instance at %s>" % (self.this,)

class doubleaPtr(doublea):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = doublea
_stl_vec.doublea_swigregister(doubleaPtr)
doublea_frompointer = _stl_vec.doublea_frompointer


class realtypea(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, realtypea, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, realtypea, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_realtypea,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_realtypea):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __getitem__(*args): return apply(_stl_vec.realtypea___getitem__,args)
    def __setitem__(*args): return apply(_stl_vec.realtypea___setitem__,args)
    def cast(*args): return apply(_stl_vec.realtypea_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.realtypea_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.realtypea_frompointer)
    def __repr__(self):
        return "<C realtypea instance at %s>" % (self.this,)

class realtypeaPtr(realtypea):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = realtypea
_stl_vec.realtypea_swigregister(realtypeaPtr)
realtypea_frompointer = _stl_vec.realtypea_frompointer


class floata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floata, name)
    def __init__(self,*args):
        self.this = apply(_stl_vec.new_floata,args)
        self.thisown = 1
    def __del__(self, destroy= _stl_vec.delete_floata):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __getitem__(*args): return apply(_stl_vec.floata___getitem__,args)
    def __setitem__(*args): return apply(_stl_vec.floata___setitem__,args)
    def cast(*args): return apply(_stl_vec.floata_cast,args)
    __swig_getmethods__["frompointer"] = lambda x: _stl_vec.floata_frompointer
    if _newclass:frompointer = staticmethod(_stl_vec.floata_frompointer)
    def __repr__(self):
        return "<C floata instance at %s>" % (self.this,)

class floataPtr(floata):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = floata
_stl_vec.floata_swigregister(floataPtr)
floata_frompointer = _stl_vec.floata_frompointer


double_to_realtype = _stl_vec.double_to_realtype

realtype_to_double = _stl_vec.realtype_to_double

new_stl_vec_cartesian = _stl_vec.new_stl_vec_cartesian