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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _vnl_vectorPython
else:
    import _vnl_vectorPython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _vnl_vectorPython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _vnl_vectorPython.SWIG_PyStaticMethod_New

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,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import stdcomplexPython
import pyBasePython
import vnl_matrixPython
class vnl_vectorCF(object):
    r"""Proxy of C++ vnl_vectorCF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorCF self) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len, stdcomplexF v0) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len, unsigned long n, stdcomplexF values) -> vnl_vectorCF
        __init__(vnl_vectorCF self, stdcomplexF data_block, unsigned long n) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len, stdcomplexF px, stdcomplexF py) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len, stdcomplexF px, stdcomplexF py, stdcomplexF pz) -> vnl_vectorCF
        __init__(vnl_vectorCF self, unsigned long len, stdcomplexF px, stdcomplexF py, stdcomplexF pz, stdcomplexF pw) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, vnl_vectorCF arg1, vnl_tag_add arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, vnl_vectorCF arg1, vnl_tag_sub arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, stdcomplexF arg1, vnl_tag_mul arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, stdcomplexF arg1, vnl_tag_div arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, stdcomplexF arg1, vnl_tag_add arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, stdcomplexF arg1, vnl_tag_sub arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_matrixCF arg0, vnl_vectorCF arg1, vnl_tag_mul arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF arg0, vnl_matrixCF arg1, vnl_tag_mul arg2) -> vnl_vectorCF
        __init__(vnl_vectorCF self, vnl_vectorCF that, vnl_tag_grab arg1) -> vnl_vectorCF
        """
        _vnl_vectorPython.vnl_vectorCF_swiginit(self, _vnl_vectorPython.new_vnl_vectorCF(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorCF
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorCF___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorCF___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorCF_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorCF_read)

# Register vnl_vectorCF in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorCF_swigregister(vnl_vectorCF)
class vnl_vectorD(object):
    r"""Proxy of C++ vnl_vectorD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorD self) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len, double const & v0) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len, unsigned long n, double const * values) -> vnl_vectorD
        __init__(vnl_vectorD self, double const * data_block, unsigned long n) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len, double const & px, double const & py) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len, double const & px, double const & py, double const & pz) -> vnl_vectorD
        __init__(vnl_vectorD self, unsigned long len, double const & px, double const & py, double const & pz, double const & pw) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, vnl_vectorD arg1, vnl_tag_add arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, vnl_vectorD arg1, vnl_tag_sub arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, double arg1, vnl_tag_mul arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, double arg1, vnl_tag_div arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, double arg1, vnl_tag_add arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, double arg1, vnl_tag_sub arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_matrixD arg0, vnl_vectorD arg1, vnl_tag_mul arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD arg0, vnl_matrixD arg1, vnl_tag_mul arg2) -> vnl_vectorD
        __init__(vnl_vectorD self, vnl_vectorD that, vnl_tag_grab arg1) -> vnl_vectorD
        """
        _vnl_vectorPython.vnl_vectorD_swiginit(self, _vnl_vectorPython.new_vnl_vectorD(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorD
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorD___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorD___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorD_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorD_read)

# Register vnl_vectorD in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorD_swigregister(vnl_vectorD)
class vnl_vectorF(object):
    r"""Proxy of C++ vnl_vectorF class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorF self) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len, float const & v0) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len, unsigned long n, float const * values) -> vnl_vectorF
        __init__(vnl_vectorF self, float const * data_block, unsigned long n) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len, float const & px, float const & py) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len, float const & px, float const & py, float const & pz) -> vnl_vectorF
        __init__(vnl_vectorF self, unsigned long len, float const & px, float const & py, float const & pz, float const & pw) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, vnl_vectorF arg1, vnl_tag_add arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, vnl_vectorF arg1, vnl_tag_sub arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, float arg1, vnl_tag_mul arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, float arg1, vnl_tag_div arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, float arg1, vnl_tag_add arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, float arg1, vnl_tag_sub arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_matrixF arg0, vnl_vectorF arg1, vnl_tag_mul arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF arg0, vnl_matrixF arg1, vnl_tag_mul arg2) -> vnl_vectorF
        __init__(vnl_vectorF self, vnl_vectorF that, vnl_tag_grab arg1) -> vnl_vectorF
        """
        _vnl_vectorPython.vnl_vectorF_swiginit(self, _vnl_vectorPython.new_vnl_vectorF(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorF
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorF___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorF___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorF_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorF_read)

# Register vnl_vectorF in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorF_swigregister(vnl_vectorF)
class vnl_vectorLD(object):
    r"""Proxy of C++ vnl_vectorLD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorLD self) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len, long double const & v0) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len, unsigned long n, long double const * values) -> vnl_vectorLD
        __init__(vnl_vectorLD self, long double const * data_block, unsigned long n) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len, long double const & px, long double const & py) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len, long double const & px, long double const & py, long double const & pz) -> vnl_vectorLD
        __init__(vnl_vectorLD self, unsigned long len, long double const & px, long double const & py, long double const & pz, long double const & pw) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, vnl_vectorLD arg1, vnl_tag_add arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, vnl_vectorLD arg1, vnl_tag_sub arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, long double arg1, vnl_tag_mul arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, long double arg1, vnl_tag_div arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, long double arg1, vnl_tag_add arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, long double arg1, vnl_tag_sub arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_matrixLD arg0, vnl_vectorLD arg1, vnl_tag_mul arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD arg0, vnl_matrixLD arg1, vnl_tag_mul arg2) -> vnl_vectorLD
        __init__(vnl_vectorLD self, vnl_vectorLD that, vnl_tag_grab arg1) -> vnl_vectorLD
        """
        _vnl_vectorPython.vnl_vectorLD_swiginit(self, _vnl_vectorPython.new_vnl_vectorLD(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorLD
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorLD___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorLD___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorLD_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorLD_read)

# Register vnl_vectorLD in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorLD_swigregister(vnl_vectorLD)
class vnl_vectorSC(object):
    r"""Proxy of C++ vnl_vectorSC class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorSC self) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len, signed char const & v0) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len, unsigned long n, signed char const * values) -> vnl_vectorSC
        __init__(vnl_vectorSC self, signed char const * data_block, unsigned long n) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len, signed char const & px, signed char const & py) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len, signed char const & px, signed char const & py, signed char const & pz) -> vnl_vectorSC
        __init__(vnl_vectorSC self, unsigned long len, signed char const & px, signed char const & py, signed char const & pz, signed char const & pw) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, vnl_vectorSC arg1, vnl_tag_add arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, vnl_vectorSC arg1, vnl_tag_sub arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, signed char arg1, vnl_tag_mul arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, signed char arg1, vnl_tag_div arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, signed char arg1, vnl_tag_add arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, signed char arg1, vnl_tag_sub arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_matrixSC arg0, vnl_vectorSC arg1, vnl_tag_mul arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC arg0, vnl_matrixSC arg1, vnl_tag_mul arg2) -> vnl_vectorSC
        __init__(vnl_vectorSC self, vnl_vectorSC that, vnl_tag_grab arg1) -> vnl_vectorSC
        """
        _vnl_vectorPython.vnl_vectorSC_swiginit(self, _vnl_vectorPython.new_vnl_vectorSC(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSC
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSC___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSC___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSC_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorSC_read)

# Register vnl_vectorSC in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorSC_swigregister(vnl_vectorSC)
class vnl_vectorSI(object):
    r"""Proxy of C++ vnl_vectorSI class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorSI self) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len, int const & v0) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len, unsigned long n, int const * values) -> vnl_vectorSI
        __init__(vnl_vectorSI self, int const * data_block, unsigned long n) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len, int const & px, int const & py) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len, int const & px, int const & py, int const & pz) -> vnl_vectorSI
        __init__(vnl_vectorSI self, unsigned long len, int const & px, int const & py, int const & pz, int const & pw) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, vnl_vectorSI arg1, vnl_tag_add arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, vnl_vectorSI arg1, vnl_tag_sub arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, int arg1, vnl_tag_mul arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, int arg1, vnl_tag_div arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, int arg1, vnl_tag_add arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, int arg1, vnl_tag_sub arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_matrixSI arg0, vnl_vectorSI arg1, vnl_tag_mul arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI arg0, vnl_matrixSI arg1, vnl_tag_mul arg2) -> vnl_vectorSI
        __init__(vnl_vectorSI self, vnl_vectorSI that, vnl_tag_grab arg1) -> vnl_vectorSI
        """
        _vnl_vectorPython.vnl_vectorSI_swiginit(self, _vnl_vectorPython.new_vnl_vectorSI(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSI
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSI___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSI___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSI_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorSI_read)

# Register vnl_vectorSI in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorSI_swigregister(vnl_vectorSI)
class vnl_vectorSL(object):
    r"""Proxy of C++ vnl_vectorSL class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorSL self) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len, long const & v0) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len, unsigned long n, long const * values) -> vnl_vectorSL
        __init__(vnl_vectorSL self, long const * data_block, unsigned long n) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len, long const & px, long const & py) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len, long const & px, long const & py, long const & pz) -> vnl_vectorSL
        __init__(vnl_vectorSL self, unsigned long len, long const & px, long const & py, long const & pz, long const & pw) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, vnl_vectorSL arg1, vnl_tag_add arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, vnl_vectorSL arg1, vnl_tag_sub arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, long arg1, vnl_tag_mul arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, long arg1, vnl_tag_div arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, long arg1, vnl_tag_add arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, long arg1, vnl_tag_sub arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_matrixSL arg0, vnl_vectorSL arg1, vnl_tag_mul arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL arg0, vnl_matrixSL arg1, vnl_tag_mul arg2) -> vnl_vectorSL
        __init__(vnl_vectorSL self, vnl_vectorSL that, vnl_tag_grab arg1) -> vnl_vectorSL
        """
        _vnl_vectorPython.vnl_vectorSL_swiginit(self, _vnl_vectorPython.new_vnl_vectorSL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSL
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSL___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSL___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSL_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorSL_read)

# Register vnl_vectorSL in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorSL_swigregister(vnl_vectorSL)
class vnl_vectorSLL(object):
    r"""Proxy of C++ vnl_vectorSLL class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorSLL self) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len, long long const & v0) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len, unsigned long n, long long const * values) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, long long const * data_block, unsigned long n) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len, long long const & px, long long const & py) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len, long long const & px, long long const & py, long long const & pz) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, unsigned long len, long long const & px, long long const & py, long long const & pz, long long const & pw) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, vnl_vectorSLL arg1, vnl_tag_add arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, vnl_vectorSLL arg1, vnl_tag_sub arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, long long arg1, vnl_tag_mul arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, long long arg1, vnl_tag_div arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, long long arg1, vnl_tag_add arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, long long arg1, vnl_tag_sub arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_matrixSLL arg0, vnl_vectorSLL arg1, vnl_tag_mul arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL arg0, vnl_matrixSLL arg1, vnl_tag_mul arg2) -> vnl_vectorSLL
        __init__(vnl_vectorSLL self, vnl_vectorSLL that, vnl_tag_grab arg1) -> vnl_vectorSLL
        """
        _vnl_vectorPython.vnl_vectorSLL_swiginit(self, _vnl_vectorPython.new_vnl_vectorSLL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSLL
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSLL___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSLL___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSLL_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorSLL_read)

# Register vnl_vectorSLL in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorSLL_swigregister(vnl_vectorSLL)
class vnl_vectorSS(object):
    r"""Proxy of C++ vnl_vectorSS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorSS self) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len, short const & v0) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len, unsigned long n, short const * values) -> vnl_vectorSS
        __init__(vnl_vectorSS self, short const * data_block, unsigned long n) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len, short const & px, short const & py) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len, short const & px, short const & py, short const & pz) -> vnl_vectorSS
        __init__(vnl_vectorSS self, unsigned long len, short const & px, short const & py, short const & pz, short const & pw) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, vnl_vectorSS arg1, vnl_tag_add arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, vnl_vectorSS arg1, vnl_tag_sub arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, short arg1, vnl_tag_mul arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, short arg1, vnl_tag_div arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, short arg1, vnl_tag_add arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, short arg1, vnl_tag_sub arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_matrixSS arg0, vnl_vectorSS arg1, vnl_tag_mul arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS arg0, vnl_matrixSS arg1, vnl_tag_mul arg2) -> vnl_vectorSS
        __init__(vnl_vectorSS self, vnl_vectorSS that, vnl_tag_grab arg1) -> vnl_vectorSS
        """
        _vnl_vectorPython.vnl_vectorSS_swiginit(self, _vnl_vectorPython.new_vnl_vectorSS(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSS
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSS___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorSS___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorSS_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorSS_read)

# Register vnl_vectorSS in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorSS_swigregister(vnl_vectorSS)
class vnl_vectorUC(object):
    r"""Proxy of C++ vnl_vectorUC class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorUC self) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len, unsigned char const & v0) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len, unsigned long n, unsigned char const * values) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned char const * data_block, unsigned long n) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len, unsigned char const & px, unsigned char const & py) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len, unsigned char const & px, unsigned char const & py, unsigned char const & pz) -> vnl_vectorUC
        __init__(vnl_vectorUC self, unsigned long len, unsigned char const & px, unsigned char const & py, unsigned char const & pz, unsigned char const & pw) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, vnl_vectorUC arg1, vnl_tag_add arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, vnl_vectorUC arg1, vnl_tag_sub arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, unsigned char arg1, vnl_tag_mul arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, unsigned char arg1, vnl_tag_div arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, unsigned char arg1, vnl_tag_add arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, unsigned char arg1, vnl_tag_sub arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_matrixUC arg0, vnl_vectorUC arg1, vnl_tag_mul arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC arg0, vnl_matrixUC arg1, vnl_tag_mul arg2) -> vnl_vectorUC
        __init__(vnl_vectorUC self, vnl_vectorUC that, vnl_tag_grab arg1) -> vnl_vectorUC
        """
        _vnl_vectorPython.vnl_vectorUC_swiginit(self, _vnl_vectorPython.new_vnl_vectorUC(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUC
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUC___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUC___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUC_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorUC_read)

# Register vnl_vectorUC in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorUC_swigregister(vnl_vectorUC)
class vnl_vectorUI(object):
    r"""Proxy of C++ vnl_vectorUI class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorUI self) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len, unsigned int const & v0) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len, unsigned long n, unsigned int const * values) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned int const * data_block, unsigned long n) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len, unsigned int const & px, unsigned int const & py) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len, unsigned int const & px, unsigned int const & py, unsigned int const & pz) -> vnl_vectorUI
        __init__(vnl_vectorUI self, unsigned long len, unsigned int const & px, unsigned int const & py, unsigned int const & pz, unsigned int const & pw) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, vnl_vectorUI arg1, vnl_tag_add arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, vnl_vectorUI arg1, vnl_tag_sub arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, unsigned int arg1, vnl_tag_mul arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, unsigned int arg1, vnl_tag_div arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, unsigned int arg1, vnl_tag_add arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, unsigned int arg1, vnl_tag_sub arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_matrixUI arg0, vnl_vectorUI arg1, vnl_tag_mul arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI arg0, vnl_matrixUI arg1, vnl_tag_mul arg2) -> vnl_vectorUI
        __init__(vnl_vectorUI self, vnl_vectorUI that, vnl_tag_grab arg1) -> vnl_vectorUI
        """
        _vnl_vectorPython.vnl_vectorUI_swiginit(self, _vnl_vectorPython.new_vnl_vectorUI(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUI
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUI___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUI___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUI_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorUI_read)

# Register vnl_vectorUI in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorUI_swigregister(vnl_vectorUI)
class vnl_vectorUL(object):
    r"""Proxy of C++ vnl_vectorUL class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorUL self) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len, unsigned long const & v0) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len, unsigned long n, unsigned long const * values) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long const * data_block, unsigned long n) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len, unsigned long const & px, unsigned long const & py) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len, unsigned long const & px, unsigned long const & py, unsigned long const & pz) -> vnl_vectorUL
        __init__(vnl_vectorUL self, unsigned long len, unsigned long const & px, unsigned long const & py, unsigned long const & pz, unsigned long const & pw) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, vnl_vectorUL arg1, vnl_tag_add arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, vnl_vectorUL arg1, vnl_tag_sub arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, unsigned long arg1, vnl_tag_mul arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, unsigned long arg1, vnl_tag_div arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, unsigned long arg1, vnl_tag_add arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, unsigned long arg1, vnl_tag_sub arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_matrixUL arg0, vnl_vectorUL arg1, vnl_tag_mul arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL arg0, vnl_matrixUL arg1, vnl_tag_mul arg2) -> vnl_vectorUL
        __init__(vnl_vectorUL self, vnl_vectorUL that, vnl_tag_grab arg1) -> vnl_vectorUL
        """
        _vnl_vectorPython.vnl_vectorUL_swiginit(self, _vnl_vectorPython.new_vnl_vectorUL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUL
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUL___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUL___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUL_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorUL_read)

# Register vnl_vectorUL in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorUL_swigregister(vnl_vectorUL)
class vnl_vectorULL(object):
    r"""Proxy of C++ vnl_vectorULL class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorULL self) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len, unsigned long long const & v0) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len, unsigned long n, unsigned long long const * values) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long long const * data_block, unsigned long n) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len, unsigned long long const & px, unsigned long long const & py) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len, unsigned long long const & px, unsigned long long const & py, unsigned long long const & pz) -> vnl_vectorULL
        __init__(vnl_vectorULL self, unsigned long len, unsigned long long const & px, unsigned long long const & py, unsigned long long const & pz, unsigned long long const & pw) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, vnl_vectorULL arg1, vnl_tag_add arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, vnl_vectorULL arg1, vnl_tag_sub arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, unsigned long long arg1, vnl_tag_mul arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, unsigned long long arg1, vnl_tag_div arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, unsigned long long arg1, vnl_tag_add arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, unsigned long long arg1, vnl_tag_sub arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_matrixULL arg0, vnl_vectorULL arg1, vnl_tag_mul arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL arg0, vnl_matrixULL arg1, vnl_tag_mul arg2) -> vnl_vectorULL
        __init__(vnl_vectorULL self, vnl_vectorULL that, vnl_tag_grab arg1) -> vnl_vectorULL
        """
        _vnl_vectorPython.vnl_vectorULL_swiginit(self, _vnl_vectorPython.new_vnl_vectorULL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorULL
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorULL___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorULL___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorULL_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorULL_read)

# Register vnl_vectorULL in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorULL_swigregister(vnl_vectorULL)
class vnl_vectorUS(object):
    r"""Proxy of C++ vnl_vectorUS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vnl_vectorUS self) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len, unsigned short const & v0) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len, unsigned long n, unsigned short const * values) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned short const * data_block, unsigned long n) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len, unsigned short const & px, unsigned short const & py) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len, unsigned short const & px, unsigned short const & py, unsigned short const & pz) -> vnl_vectorUS
        __init__(vnl_vectorUS self, unsigned long len, unsigned short const & px, unsigned short const & py, unsigned short const & pz, unsigned short const & pw) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, vnl_vectorUS arg1, vnl_tag_add arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, vnl_vectorUS arg1, vnl_tag_sub arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, unsigned short arg1, vnl_tag_mul arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, unsigned short arg1, vnl_tag_div arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, unsigned short arg1, vnl_tag_add arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, unsigned short arg1, vnl_tag_sub arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_matrixUS arg0, vnl_vectorUS arg1, vnl_tag_mul arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS arg0, vnl_matrixUS arg1, vnl_tag_mul arg2) -> vnl_vectorUS
        __init__(vnl_vectorUS self, vnl_vectorUS that, vnl_tag_grab arg1) -> vnl_vectorUS
        """
        _vnl_vectorPython.vnl_vectorUS_swiginit(self, _vnl_vectorPython.new_vnl_vectorUS(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUS
    size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_size)
    put = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_put)
    get = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_get)
    fill = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_fill)
    copy_in = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_copy_in)
    copy_out = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_copy_out)
    set = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set)
    __call__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___call__)

    def __itruediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUS___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __iadd__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___iadd__)
    __isub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___isub__)
    pre_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_pre_multiply)
    post_multiply = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_post_multiply)
    __imul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___imul__)
    __pos__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___pos__)
    __neg__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___neg__)

    def __truediv__(self, *args):
        return _vnl_vectorPython.vnl_vectorUS___truediv__(self, *args)
    __div__ = __truediv__


    __add__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___add__)
    __sub__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___sub__)
    __mul__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___mul__)
    data_block = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_data_block)
    begin = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_begin)
    end = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_end)
    extract = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_extract)
    update = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_update)
    squared_magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_squared_magnitude)
    magnitude = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_magnitude)
    one_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_one_norm)
    two_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_two_norm)
    inf_norm = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_inf_norm)
    normalize = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_normalize)
    rms = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_rms)
    min_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_min_value)
    max_value = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_max_value)
    arg_min = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_arg_min)
    arg_max = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_arg_max)
    mean = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_mean)
    sum = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_sum)
    flip = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_flip)
    roll = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_roll)
    roll_inplace = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_roll_inplace)
    swap = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_swap)
    x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_x)
    y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_y)
    z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_z)
    t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_t)
    set_x = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set_x)
    set_y = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set_y)
    set_z = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set_z)
    set_t = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set_t)
    assert_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_assert_size)
    assert_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_assert_finite)
    is_finite = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_is_finite)
    is_zero = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_is_zero)
    empty = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_empty)
    is_equal = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_is_equal)
    operator_eq = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_operator_eq)
    __eq__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___eq__)
    __ne__ = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS___ne__)
    set_size = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_set_size)
    clear = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_clear)
    read_ascii = _swig_new_instance_method(_vnl_vectorPython.vnl_vectorUS_read_ascii)
    read = _swig_new_static_method(_vnl_vectorPython.vnl_vectorUS_read)

# Register vnl_vectorUS in _vnl_vectorPython:
_vnl_vectorPython.vnl_vectorUS_swigregister(vnl_vectorUS)

