# 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.


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKCommonPython



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__

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


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.stdcomplexPython
import itk.pyBasePython
import itk.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__(self) -> vnl_vectorCF
        __init__(self, len) -> vnl_vectorCF

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorCF

        Parameters
        ----------
        len: unsigned long
        v0: stdcomplexF const &

        __init__(self, len, n, values) -> vnl_vectorCF

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: stdcomplexF const *

        __init__(self, data_block, n) -> vnl_vectorCF

        Parameters
        ----------
        data_block: stdcomplexF const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorCF

        Parameters
        ----------
        arg0: vnl_vectorCF const &

        """
        _vnl_vectorPython.vnl_vectorCF_swiginit(self, _vnl_vectorPython.new_vnl_vectorCF(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorCF

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorCF_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: stdcomplexF const &

        """
        return _vnl_vectorPython.vnl_vectorCF_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> stdcomplexF

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: stdcomplexF const &

        """
        return _vnl_vectorPython.vnl_vectorCF_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorCF

        Parameters
        ----------
        ptr: stdcomplexF const *

        """
        return _vnl_vectorPython.vnl_vectorCF_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: stdcomplexF *

        """
        return _vnl_vectorPython.vnl_vectorCF_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorCF

        Parameters
        ----------
        ptr: stdcomplexF const *

        """
        return _vnl_vectorPython.vnl_vectorCF_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> stdcomplexF

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> stdcomplexF

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorCF

        Parameters
        ----------
        arg0: stdcomplexF

        __iadd__(self, rhs) -> vnl_vectorCF

        Parameters
        ----------
        rhs: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorCF

        Parameters
        ----------
        value: stdcomplexF

        __isub__(self, rhs) -> vnl_vectorCF

        Parameters
        ----------
        rhs: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorCF

        Parameters
        ----------
        M: vnl_matrixCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorCF

        Parameters
        ----------
        M: vnl_matrixCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorCF

        Parameters
        ----------
        arg0: stdcomplexF

        __imul__(self, m) -> vnl_vectorCF

        Parameters
        ----------
        m: vnl_matrixCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorCF"""
        return _vnl_vectorPython.vnl_vectorCF___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorCF"""
        return _vnl_vectorPython.vnl_vectorCF___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: stdcomplexF

        __add__(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: stdcomplexF

        __sub__(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorCF

        Parameters
        ----------
        v: stdcomplexF

        __mul__(self, M) -> vnl_vectorCF

        Parameters
        ----------
        M: vnl_matrixCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> stdcomplexF
        data_block(self) -> stdcomplexF
        """
        return _vnl_vectorPython.vnl_vectorCF_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> stdcomplexF
        begin(self) -> stdcomplexF
        """
        return _vnl_vectorPython.vnl_vectorCF_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> stdcomplexF
        end(self) -> stdcomplexF
        """
        return _vnl_vectorPython.vnl_vectorCF_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> stdcomplexF
        front(self) -> stdcomplexF
        """
        return _vnl_vectorPython.vnl_vectorCF_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> stdcomplexF
        back(self) -> stdcomplexF
        """
        return _vnl_vectorPython.vnl_vectorCF_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorCF

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorCF

        Parameters
        ----------
        arg0: vnl_vectorCF const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorCF"""
        return _vnl_vectorPython.vnl_vectorCF_normalize(self)

    def rms(self):
        r"""rms(self) -> float"""
        return _vnl_vectorPython.vnl_vectorCF_rms(self)

    def min_value(self):
        r"""min_value(self) -> stdcomplexF"""
        return _vnl_vectorPython.vnl_vectorCF_min_value(self)

    def max_value(self):
        r"""max_value(self) -> stdcomplexF"""
        return _vnl_vectorPython.vnl_vectorCF_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorCF_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorCF_arg_max(self)

    def mean(self):
        r"""mean(self) -> stdcomplexF"""
        return _vnl_vectorPython.vnl_vectorCF_mean(self)

    def sum(self):
        r"""sum(self) -> stdcomplexF"""
        return _vnl_vectorPython.vnl_vectorCF_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorCF
        flip(self, b, e) -> vnl_vectorCF

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorCF_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorCF

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorCF_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorCF

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorCF_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorCF &

        """
        return _vnl_vectorPython.vnl_vectorCF_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorCF_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorCF_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorCF_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorCF_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorCF const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorCF_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorCF const &

        """
        return _vnl_vectorPython.vnl_vectorCF___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorCF_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorCF_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorCF_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorCF

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorCF_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: stdcomplexF *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorCF_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: stdcomplexF *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorCF_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorD
        __init__(self, len) -> vnl_vectorD

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorD

        Parameters
        ----------
        len: unsigned long
        v0: double const &

        __init__(self, len, n, values) -> vnl_vectorD

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: double const *

        __init__(self, data_block, n) -> vnl_vectorD

        Parameters
        ----------
        data_block: double const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorD

        Parameters
        ----------
        arg0: vnl_vectorD const &

        """
        _vnl_vectorPython.vnl_vectorD_swiginit(self, _vnl_vectorPython.new_vnl_vectorD(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorD

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorD_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: double const &

        """
        return _vnl_vectorPython.vnl_vectorD_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> double

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: double const &

        """
        return _vnl_vectorPython.vnl_vectorD_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorD

        Parameters
        ----------
        ptr: double const *

        """
        return _vnl_vectorPython.vnl_vectorD_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: double *

        """
        return _vnl_vectorPython.vnl_vectorD_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorD

        Parameters
        ----------
        ptr: double const *

        """
        return _vnl_vectorPython.vnl_vectorD_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> double

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> double const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorD

        Parameters
        ----------
        arg0: double

        __iadd__(self, rhs) -> vnl_vectorD

        Parameters
        ----------
        rhs: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorD

        Parameters
        ----------
        value: double

        __isub__(self, rhs) -> vnl_vectorD

        Parameters
        ----------
        rhs: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorD

        Parameters
        ----------
        M: vnl_matrixD const &

        """
        return _vnl_vectorPython.vnl_vectorD_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorD

        Parameters
        ----------
        M: vnl_matrixD const &

        """
        return _vnl_vectorPython.vnl_vectorD_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorD

        Parameters
        ----------
        arg0: double

        __imul__(self, m) -> vnl_vectorD

        Parameters
        ----------
        m: vnl_matrixD const &

        """
        return _vnl_vectorPython.vnl_vectorD___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorD"""
        return _vnl_vectorPython.vnl_vectorD___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorD"""
        return _vnl_vectorPython.vnl_vectorD___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: double

        __add__(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: double

        __sub__(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorD

        Parameters
        ----------
        v: double

        __mul__(self, M) -> vnl_vectorD

        Parameters
        ----------
        M: vnl_matrixD const &

        """
        return _vnl_vectorPython.vnl_vectorD___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> double const
        data_block(self) -> double *
        """
        return _vnl_vectorPython.vnl_vectorD_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> double
        begin(self) -> double const *
        """
        return _vnl_vectorPython.vnl_vectorD_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> double
        end(self) -> double const *
        """
        return _vnl_vectorPython.vnl_vectorD_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> double
        front(self) -> double const &
        """
        return _vnl_vectorPython.vnl_vectorD_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> double
        back(self) -> double const &
        """
        return _vnl_vectorPython.vnl_vectorD_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorD

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorD

        Parameters
        ----------
        arg0: vnl_vectorD const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorD"""
        return _vnl_vectorPython.vnl_vectorD_normalize(self)

    def rms(self):
        r"""rms(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_rms(self)

    def min_value(self):
        r"""min_value(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_min_value(self)

    def max_value(self):
        r"""max_value(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorD_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorD_arg_max(self)

    def mean(self):
        r"""mean(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_mean(self)

    def sum(self):
        r"""sum(self) -> double"""
        return _vnl_vectorPython.vnl_vectorD_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorD
        flip(self, b, e) -> vnl_vectorD

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorD_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorD

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorD_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorD

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorD_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorD &

        """
        return _vnl_vectorPython.vnl_vectorD_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorD_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorD_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorD_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorD_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorD const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorD_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorD const &

        """
        return _vnl_vectorPython.vnl_vectorD___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorD_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorD_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorD_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorD

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorD_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: double *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorD_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: double *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorD_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorF
        __init__(self, len) -> vnl_vectorF

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorF

        Parameters
        ----------
        len: unsigned long
        v0: float const &

        __init__(self, len, n, values) -> vnl_vectorF

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: float const *

        __init__(self, data_block, n) -> vnl_vectorF

        Parameters
        ----------
        data_block: float const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorF

        Parameters
        ----------
        arg0: vnl_vectorF const &

        """
        _vnl_vectorPython.vnl_vectorF_swiginit(self, _vnl_vectorPython.new_vnl_vectorF(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorF

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorF_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: float const &

        """
        return _vnl_vectorPython.vnl_vectorF_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> float

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: float const &

        """
        return _vnl_vectorPython.vnl_vectorF_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorF

        Parameters
        ----------
        ptr: float const *

        """
        return _vnl_vectorPython.vnl_vectorF_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: float *

        """
        return _vnl_vectorPython.vnl_vectorF_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorF

        Parameters
        ----------
        ptr: float const *

        """
        return _vnl_vectorPython.vnl_vectorF_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> float

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> float const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorF

        Parameters
        ----------
        arg0: float

        __iadd__(self, rhs) -> vnl_vectorF

        Parameters
        ----------
        rhs: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorF

        Parameters
        ----------
        value: float

        __isub__(self, rhs) -> vnl_vectorF

        Parameters
        ----------
        rhs: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorF

        Parameters
        ----------
        M: vnl_matrixF const &

        """
        return _vnl_vectorPython.vnl_vectorF_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorF

        Parameters
        ----------
        M: vnl_matrixF const &

        """
        return _vnl_vectorPython.vnl_vectorF_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorF

        Parameters
        ----------
        arg0: float

        __imul__(self, m) -> vnl_vectorF

        Parameters
        ----------
        m: vnl_matrixF const &

        """
        return _vnl_vectorPython.vnl_vectorF___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorF"""
        return _vnl_vectorPython.vnl_vectorF___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorF"""
        return _vnl_vectorPython.vnl_vectorF___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: float

        __add__(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: float

        __sub__(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorF

        Parameters
        ----------
        v: float

        __mul__(self, M) -> vnl_vectorF

        Parameters
        ----------
        M: vnl_matrixF const &

        """
        return _vnl_vectorPython.vnl_vectorF___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> float const
        data_block(self) -> float *
        """
        return _vnl_vectorPython.vnl_vectorF_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> float
        begin(self) -> float const *
        """
        return _vnl_vectorPython.vnl_vectorF_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> float
        end(self) -> float const *
        """
        return _vnl_vectorPython.vnl_vectorF_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> float
        front(self) -> float const &
        """
        return _vnl_vectorPython.vnl_vectorF_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> float
        back(self) -> float const &
        """
        return _vnl_vectorPython.vnl_vectorF_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorF

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorF

        Parameters
        ----------
        arg0: vnl_vectorF const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorF"""
        return _vnl_vectorPython.vnl_vectorF_normalize(self)

    def rms(self):
        r"""rms(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_rms(self)

    def min_value(self):
        r"""min_value(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_min_value(self)

    def max_value(self):
        r"""max_value(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorF_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorF_arg_max(self)

    def mean(self):
        r"""mean(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_mean(self)

    def sum(self):
        r"""sum(self) -> float"""
        return _vnl_vectorPython.vnl_vectorF_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorF
        flip(self, b, e) -> vnl_vectorF

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorF_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorF

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorF_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorF

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorF_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorF &

        """
        return _vnl_vectorPython.vnl_vectorF_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorF_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorF_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorF_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorF_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorF const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorF_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorF const &

        """
        return _vnl_vectorPython.vnl_vectorF___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorF_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorF_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorF_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorF

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorF_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: float *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorF_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: float *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorF_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorLD
        __init__(self, len) -> vnl_vectorLD

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorLD

        Parameters
        ----------
        len: unsigned long
        v0: long double const &

        __init__(self, len, n, values) -> vnl_vectorLD

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: long double const *

        __init__(self, data_block, n) -> vnl_vectorLD

        Parameters
        ----------
        data_block: long double const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorLD

        Parameters
        ----------
        arg0: vnl_vectorLD const &

        """
        _vnl_vectorPython.vnl_vectorLD_swiginit(self, _vnl_vectorPython.new_vnl_vectorLD(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorLD

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorLD_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: long double const &

        """
        return _vnl_vectorPython.vnl_vectorLD_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> long double

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: long double const &

        """
        return _vnl_vectorPython.vnl_vectorLD_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorLD

        Parameters
        ----------
        ptr: long double const *

        """
        return _vnl_vectorPython.vnl_vectorLD_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: long double *

        """
        return _vnl_vectorPython.vnl_vectorLD_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorLD

        Parameters
        ----------
        ptr: long double const *

        """
        return _vnl_vectorPython.vnl_vectorLD_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> long double

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> long double const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorLD

        Parameters
        ----------
        arg0: long double

        __iadd__(self, rhs) -> vnl_vectorLD

        Parameters
        ----------
        rhs: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorLD

        Parameters
        ----------
        value: long double

        __isub__(self, rhs) -> vnl_vectorLD

        Parameters
        ----------
        rhs: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorLD

        Parameters
        ----------
        M: vnl_matrixLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorLD

        Parameters
        ----------
        M: vnl_matrixLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorLD

        Parameters
        ----------
        arg0: long double

        __imul__(self, m) -> vnl_vectorLD

        Parameters
        ----------
        m: vnl_matrixLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorLD"""
        return _vnl_vectorPython.vnl_vectorLD___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorLD"""
        return _vnl_vectorPython.vnl_vectorLD___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: long double

        __add__(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: long double

        __sub__(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorLD

        Parameters
        ----------
        v: long double

        __mul__(self, M) -> vnl_vectorLD

        Parameters
        ----------
        M: vnl_matrixLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> long double const
        data_block(self) -> long double *
        """
        return _vnl_vectorPython.vnl_vectorLD_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> long double
        begin(self) -> long double const *
        """
        return _vnl_vectorPython.vnl_vectorLD_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> long double
        end(self) -> long double const *
        """
        return _vnl_vectorPython.vnl_vectorLD_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> long double
        front(self) -> long double const &
        """
        return _vnl_vectorPython.vnl_vectorLD_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> long double
        back(self) -> long double const &
        """
        return _vnl_vectorPython.vnl_vectorLD_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorLD

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorLD

        Parameters
        ----------
        arg0: vnl_vectorLD const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorLD"""
        return _vnl_vectorPython.vnl_vectorLD_normalize(self)

    def rms(self):
        r"""rms(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_rms(self)

    def min_value(self):
        r"""min_value(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorLD_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorLD_arg_max(self)

    def mean(self):
        r"""mean(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_mean(self)

    def sum(self):
        r"""sum(self) -> long double"""
        return _vnl_vectorPython.vnl_vectorLD_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorLD
        flip(self, b, e) -> vnl_vectorLD

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorLD_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorLD

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorLD_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorLD

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorLD_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorLD &

        """
        return _vnl_vectorPython.vnl_vectorLD_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorLD_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorLD_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorLD_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorLD_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorLD const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorLD_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorLD const &

        """
        return _vnl_vectorPython.vnl_vectorLD___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorLD_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorLD_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorLD_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorLD

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorLD_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: long double *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorLD_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: long double *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorLD_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorSC
        __init__(self, len) -> vnl_vectorSC

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorSC

        Parameters
        ----------
        len: unsigned long
        v0: signed char const &

        __init__(self, len, n, values) -> vnl_vectorSC

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: signed char const *

        __init__(self, data_block, n) -> vnl_vectorSC

        Parameters
        ----------
        data_block: signed char const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorSC

        Parameters
        ----------
        arg0: vnl_vectorSC const &

        """
        _vnl_vectorPython.vnl_vectorSC_swiginit(self, _vnl_vectorPython.new_vnl_vectorSC(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSC

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSC_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: signed char const &

        """
        return _vnl_vectorPython.vnl_vectorSC_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> signed char

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: signed char const &

        """
        return _vnl_vectorPython.vnl_vectorSC_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorSC

        Parameters
        ----------
        ptr: signed char const *

        """
        return _vnl_vectorPython.vnl_vectorSC_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: signed char *

        """
        return _vnl_vectorPython.vnl_vectorSC_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorSC

        Parameters
        ----------
        ptr: signed char const *

        """
        return _vnl_vectorPython.vnl_vectorSC_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> signed char

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> signed char const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorSC

        Parameters
        ----------
        arg0: signed char

        __iadd__(self, rhs) -> vnl_vectorSC

        Parameters
        ----------
        rhs: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorSC

        Parameters
        ----------
        value: signed char

        __isub__(self, rhs) -> vnl_vectorSC

        Parameters
        ----------
        rhs: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorSC

        Parameters
        ----------
        M: vnl_matrixSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorSC

        Parameters
        ----------
        M: vnl_matrixSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorSC

        Parameters
        ----------
        arg0: signed char

        __imul__(self, m) -> vnl_vectorSC

        Parameters
        ----------
        m: vnl_matrixSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorSC"""
        return _vnl_vectorPython.vnl_vectorSC___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorSC"""
        return _vnl_vectorPython.vnl_vectorSC___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: signed char

        __add__(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: signed char

        __sub__(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorSC

        Parameters
        ----------
        v: signed char

        __mul__(self, M) -> vnl_vectorSC

        Parameters
        ----------
        M: vnl_matrixSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> signed char const
        data_block(self) -> signed char *
        """
        return _vnl_vectorPython.vnl_vectorSC_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> signed char
        begin(self) -> signed char const *
        """
        return _vnl_vectorPython.vnl_vectorSC_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> signed char
        end(self) -> signed char const *
        """
        return _vnl_vectorPython.vnl_vectorSC_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> signed char
        front(self) -> signed char const &
        """
        return _vnl_vectorPython.vnl_vectorSC_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> signed char
        back(self) -> signed char const &
        """
        return _vnl_vectorPython.vnl_vectorSC_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorSC

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorSC

        Parameters
        ----------
        arg0: vnl_vectorSC const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorSC"""
        return _vnl_vectorPython.vnl_vectorSC_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorSC_rms(self)

    def min_value(self):
        r"""min_value(self) -> signed char"""
        return _vnl_vectorPython.vnl_vectorSC_min_value(self)

    def max_value(self):
        r"""max_value(self) -> signed char"""
        return _vnl_vectorPython.vnl_vectorSC_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSC_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSC_arg_max(self)

    def mean(self):
        r"""mean(self) -> signed char"""
        return _vnl_vectorPython.vnl_vectorSC_mean(self)

    def sum(self):
        r"""sum(self) -> signed char"""
        return _vnl_vectorPython.vnl_vectorSC_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorSC
        flip(self, b, e) -> vnl_vectorSC

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorSC_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorSC

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSC_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorSC

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSC_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorSC &

        """
        return _vnl_vectorPython.vnl_vectorSC_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorSC_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSC_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSC_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSC_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorSC const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorSC_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSC const &

        """
        return _vnl_vectorPython.vnl_vectorSC___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSC_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorSC_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSC_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorSC

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSC_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: signed char *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSC_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: signed char *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSC_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorSI
        __init__(self, len) -> vnl_vectorSI

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorSI

        Parameters
        ----------
        len: unsigned long
        v0: int const &

        __init__(self, len, n, values) -> vnl_vectorSI

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: int const *

        __init__(self, data_block, n) -> vnl_vectorSI

        Parameters
        ----------
        data_block: int const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorSI

        Parameters
        ----------
        arg0: vnl_vectorSI const &

        """
        _vnl_vectorPython.vnl_vectorSI_swiginit(self, _vnl_vectorPython.new_vnl_vectorSI(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSI

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSI_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: int const &

        """
        return _vnl_vectorPython.vnl_vectorSI_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> int

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: int const &

        """
        return _vnl_vectorPython.vnl_vectorSI_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorSI

        Parameters
        ----------
        ptr: int const *

        """
        return _vnl_vectorPython.vnl_vectorSI_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: int *

        """
        return _vnl_vectorPython.vnl_vectorSI_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorSI

        Parameters
        ----------
        ptr: int const *

        """
        return _vnl_vectorPython.vnl_vectorSI_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> int

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> int const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorSI

        Parameters
        ----------
        arg0: int

        __iadd__(self, rhs) -> vnl_vectorSI

        Parameters
        ----------
        rhs: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorSI

        Parameters
        ----------
        value: int

        __isub__(self, rhs) -> vnl_vectorSI

        Parameters
        ----------
        rhs: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorSI

        Parameters
        ----------
        M: vnl_matrixSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorSI

        Parameters
        ----------
        M: vnl_matrixSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorSI

        Parameters
        ----------
        arg0: int

        __imul__(self, m) -> vnl_vectorSI

        Parameters
        ----------
        m: vnl_matrixSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorSI"""
        return _vnl_vectorPython.vnl_vectorSI___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorSI"""
        return _vnl_vectorPython.vnl_vectorSI___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: int

        __add__(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: int

        __sub__(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorSI

        Parameters
        ----------
        v: int

        __mul__(self, M) -> vnl_vectorSI

        Parameters
        ----------
        M: vnl_matrixSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> int const
        data_block(self) -> int *
        """
        return _vnl_vectorPython.vnl_vectorSI_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> int
        begin(self) -> int const *
        """
        return _vnl_vectorPython.vnl_vectorSI_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> int
        end(self) -> int const *
        """
        return _vnl_vectorPython.vnl_vectorSI_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> int
        front(self) -> int const &
        """
        return _vnl_vectorPython.vnl_vectorSI_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> int
        back(self) -> int const &
        """
        return _vnl_vectorPython.vnl_vectorSI_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorSI

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorSI

        Parameters
        ----------
        arg0: vnl_vectorSI const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorSI"""
        return _vnl_vectorPython.vnl_vectorSI_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorSI_rms(self)

    def min_value(self):
        r"""min_value(self) -> int"""
        return _vnl_vectorPython.vnl_vectorSI_min_value(self)

    def max_value(self):
        r"""max_value(self) -> int"""
        return _vnl_vectorPython.vnl_vectorSI_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSI_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSI_arg_max(self)

    def mean(self):
        r"""mean(self) -> int"""
        return _vnl_vectorPython.vnl_vectorSI_mean(self)

    def sum(self):
        r"""sum(self) -> int"""
        return _vnl_vectorPython.vnl_vectorSI_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorSI
        flip(self, b, e) -> vnl_vectorSI

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorSI_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorSI

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSI_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorSI

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSI_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorSI &

        """
        return _vnl_vectorPython.vnl_vectorSI_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorSI_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSI_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSI_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSI_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorSI const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorSI_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSI const &

        """
        return _vnl_vectorPython.vnl_vectorSI___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSI_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorSI_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSI_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorSI

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSI_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: int *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSI_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: int *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSI_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorSL
        __init__(self, len) -> vnl_vectorSL

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorSL

        Parameters
        ----------
        len: unsigned long
        v0: long const &

        __init__(self, len, n, values) -> vnl_vectorSL

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: long const *

        __init__(self, data_block, n) -> vnl_vectorSL

        Parameters
        ----------
        data_block: long const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorSL

        Parameters
        ----------
        arg0: vnl_vectorSL const &

        """
        _vnl_vectorPython.vnl_vectorSL_swiginit(self, _vnl_vectorPython.new_vnl_vectorSL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSL

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: long const &

        """
        return _vnl_vectorPython.vnl_vectorSL_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> long

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: long const &

        """
        return _vnl_vectorPython.vnl_vectorSL_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorSL

        Parameters
        ----------
        ptr: long const *

        """
        return _vnl_vectorPython.vnl_vectorSL_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: long *

        """
        return _vnl_vectorPython.vnl_vectorSL_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorSL

        Parameters
        ----------
        ptr: long const *

        """
        return _vnl_vectorPython.vnl_vectorSL_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> long

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> long const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorSL

        Parameters
        ----------
        arg0: long

        __iadd__(self, rhs) -> vnl_vectorSL

        Parameters
        ----------
        rhs: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorSL

        Parameters
        ----------
        value: long

        __isub__(self, rhs) -> vnl_vectorSL

        Parameters
        ----------
        rhs: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorSL

        Parameters
        ----------
        M: vnl_matrixSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorSL

        Parameters
        ----------
        M: vnl_matrixSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorSL

        Parameters
        ----------
        arg0: long

        __imul__(self, m) -> vnl_vectorSL

        Parameters
        ----------
        m: vnl_matrixSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorSL"""
        return _vnl_vectorPython.vnl_vectorSL___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorSL"""
        return _vnl_vectorPython.vnl_vectorSL___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: long

        __add__(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: long

        __sub__(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorSL

        Parameters
        ----------
        v: long

        __mul__(self, M) -> vnl_vectorSL

        Parameters
        ----------
        M: vnl_matrixSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> long const
        data_block(self) -> long *
        """
        return _vnl_vectorPython.vnl_vectorSL_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> long
        begin(self) -> long const *
        """
        return _vnl_vectorPython.vnl_vectorSL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> long
        end(self) -> long const *
        """
        return _vnl_vectorPython.vnl_vectorSL_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> long
        front(self) -> long const &
        """
        return _vnl_vectorPython.vnl_vectorSL_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> long
        back(self) -> long const &
        """
        return _vnl_vectorPython.vnl_vectorSL_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorSL

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorSL

        Parameters
        ----------
        arg0: vnl_vectorSL const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorSL"""
        return _vnl_vectorPython.vnl_vectorSL_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_rms(self)

    def min_value(self):
        r"""min_value(self) -> long"""
        return _vnl_vectorPython.vnl_vectorSL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long"""
        return _vnl_vectorPython.vnl_vectorSL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSL_arg_max(self)

    def mean(self):
        r"""mean(self) -> long"""
        return _vnl_vectorPython.vnl_vectorSL_mean(self)

    def sum(self):
        r"""sum(self) -> long"""
        return _vnl_vectorPython.vnl_vectorSL_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorSL
        flip(self, b, e) -> vnl_vectorSL

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorSL_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorSL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSL_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorSL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSL_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorSL &

        """
        return _vnl_vectorPython.vnl_vectorSL_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorSL_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSL_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSL_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSL_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorSL const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorSL_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSL const &

        """
        return _vnl_vectorPython.vnl_vectorSL___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSL_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorSL_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSL_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorSL

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSL_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: long *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSL_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: long *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSL_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorSLL
        __init__(self, len) -> vnl_vectorSLL

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorSLL

        Parameters
        ----------
        len: unsigned long
        v0: long long const &

        __init__(self, len, n, values) -> vnl_vectorSLL

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: long long const *

        __init__(self, data_block, n) -> vnl_vectorSLL

        Parameters
        ----------
        data_block: long long const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorSLL

        Parameters
        ----------
        arg0: vnl_vectorSLL const &

        """
        _vnl_vectorPython.vnl_vectorSLL_swiginit(self, _vnl_vectorPython.new_vnl_vectorSLL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSLL

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSLL_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: long long const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> long long

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: long long const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorSLL

        Parameters
        ----------
        ptr: long long const *

        """
        return _vnl_vectorPython.vnl_vectorSLL_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: long long *

        """
        return _vnl_vectorPython.vnl_vectorSLL_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorSLL

        Parameters
        ----------
        ptr: long long const *

        """
        return _vnl_vectorPython.vnl_vectorSLL_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> long long

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> long long const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorSLL

        Parameters
        ----------
        arg0: long long

        __iadd__(self, rhs) -> vnl_vectorSLL

        Parameters
        ----------
        rhs: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorSLL

        Parameters
        ----------
        value: long long

        __isub__(self, rhs) -> vnl_vectorSLL

        Parameters
        ----------
        rhs: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorSLL

        Parameters
        ----------
        M: vnl_matrixSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorSLL

        Parameters
        ----------
        M: vnl_matrixSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorSLL

        Parameters
        ----------
        arg0: long long

        __imul__(self, m) -> vnl_vectorSLL

        Parameters
        ----------
        m: vnl_matrixSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorSLL"""
        return _vnl_vectorPython.vnl_vectorSLL___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorSLL"""
        return _vnl_vectorPython.vnl_vectorSLL___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: long long

        __add__(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: long long

        __sub__(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorSLL

        Parameters
        ----------
        v: long long

        __mul__(self, M) -> vnl_vectorSLL

        Parameters
        ----------
        M: vnl_matrixSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> long long const
        data_block(self) -> long long *
        """
        return _vnl_vectorPython.vnl_vectorSLL_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> long long
        begin(self) -> long long const *
        """
        return _vnl_vectorPython.vnl_vectorSLL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> long long
        end(self) -> long long const *
        """
        return _vnl_vectorPython.vnl_vectorSLL_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> long long
        front(self) -> long long const &
        """
        return _vnl_vectorPython.vnl_vectorSLL_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> long long
        back(self) -> long long const &
        """
        return _vnl_vectorPython.vnl_vectorSLL_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorSLL

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorSLL

        Parameters
        ----------
        arg0: vnl_vectorSLL const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorSLL"""
        return _vnl_vectorPython.vnl_vectorSLL_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorSLL_rms(self)

    def min_value(self):
        r"""min_value(self) -> long long"""
        return _vnl_vectorPython.vnl_vectorSLL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long long"""
        return _vnl_vectorPython.vnl_vectorSLL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSLL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSLL_arg_max(self)

    def mean(self):
        r"""mean(self) -> long long"""
        return _vnl_vectorPython.vnl_vectorSLL_mean(self)

    def sum(self):
        r"""sum(self) -> long long"""
        return _vnl_vectorPython.vnl_vectorSLL_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorSLL
        flip(self, b, e) -> vnl_vectorSLL

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorSLL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorSLL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorSLL &

        """
        return _vnl_vectorPython.vnl_vectorSLL_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorSLL_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSLL_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSLL_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSLL_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorSLL const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorSLL_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSLL const &

        """
        return _vnl_vectorPython.vnl_vectorSLL___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSLL_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorSLL_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSLL_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorSLL

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSLL_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: long long *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSLL_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: long long *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSLL_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorSS
        __init__(self, len) -> vnl_vectorSS

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorSS

        Parameters
        ----------
        len: unsigned long
        v0: short const &

        __init__(self, len, n, values) -> vnl_vectorSS

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: short const *

        __init__(self, data_block, n) -> vnl_vectorSS

        Parameters
        ----------
        data_block: short const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorSS

        Parameters
        ----------
        arg0: vnl_vectorSS const &

        """
        _vnl_vectorPython.vnl_vectorSS_swiginit(self, _vnl_vectorPython.new_vnl_vectorSS(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorSS

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSS_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: short const &

        """
        return _vnl_vectorPython.vnl_vectorSS_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> short

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: short const &

        """
        return _vnl_vectorPython.vnl_vectorSS_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorSS

        Parameters
        ----------
        ptr: short const *

        """
        return _vnl_vectorPython.vnl_vectorSS_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: short *

        """
        return _vnl_vectorPython.vnl_vectorSS_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorSS

        Parameters
        ----------
        ptr: short const *

        """
        return _vnl_vectorPython.vnl_vectorSS_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> short

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> short const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorSS

        Parameters
        ----------
        arg0: short

        __iadd__(self, rhs) -> vnl_vectorSS

        Parameters
        ----------
        rhs: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorSS

        Parameters
        ----------
        value: short

        __isub__(self, rhs) -> vnl_vectorSS

        Parameters
        ----------
        rhs: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorSS

        Parameters
        ----------
        M: vnl_matrixSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorSS

        Parameters
        ----------
        M: vnl_matrixSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorSS

        Parameters
        ----------
        arg0: short

        __imul__(self, m) -> vnl_vectorSS

        Parameters
        ----------
        m: vnl_matrixSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorSS"""
        return _vnl_vectorPython.vnl_vectorSS___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorSS"""
        return _vnl_vectorPython.vnl_vectorSS___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: short

        __add__(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: short

        __sub__(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorSS

        Parameters
        ----------
        v: short

        __mul__(self, M) -> vnl_vectorSS

        Parameters
        ----------
        M: vnl_matrixSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> short const
        data_block(self) -> short *
        """
        return _vnl_vectorPython.vnl_vectorSS_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> short
        begin(self) -> short const *
        """
        return _vnl_vectorPython.vnl_vectorSS_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> short
        end(self) -> short const *
        """
        return _vnl_vectorPython.vnl_vectorSS_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> short
        front(self) -> short const &
        """
        return _vnl_vectorPython.vnl_vectorSS_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> short
        back(self) -> short const &
        """
        return _vnl_vectorPython.vnl_vectorSS_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorSS

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorSS

        Parameters
        ----------
        arg0: vnl_vectorSS const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorSS"""
        return _vnl_vectorPython.vnl_vectorSS_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorSS_rms(self)

    def min_value(self):
        r"""min_value(self) -> short"""
        return _vnl_vectorPython.vnl_vectorSS_min_value(self)

    def max_value(self):
        r"""max_value(self) -> short"""
        return _vnl_vectorPython.vnl_vectorSS_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSS_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorSS_arg_max(self)

    def mean(self):
        r"""mean(self) -> short"""
        return _vnl_vectorPython.vnl_vectorSS_mean(self)

    def sum(self):
        r"""sum(self) -> short"""
        return _vnl_vectorPython.vnl_vectorSS_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorSS
        flip(self, b, e) -> vnl_vectorSS

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorSS_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorSS

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSS_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorSS

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorSS_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorSS &

        """
        return _vnl_vectorPython.vnl_vectorSS_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorSS_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSS_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSS_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorSS_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorSS const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorSS_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorSS const &

        """
        return _vnl_vectorPython.vnl_vectorSS___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorSS_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorSS_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSS_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorSS

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorSS_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: short *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSS_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: short *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorSS_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorUC
        __init__(self, len) -> vnl_vectorUC

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorUC

        Parameters
        ----------
        len: unsigned long
        v0: unsigned char const &

        __init__(self, len, n, values) -> vnl_vectorUC

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: unsigned char const *

        __init__(self, data_block, n) -> vnl_vectorUC

        Parameters
        ----------
        data_block: unsigned char const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorUC

        Parameters
        ----------
        arg0: vnl_vectorUC const &

        """
        _vnl_vectorPython.vnl_vectorUC_swiginit(self, _vnl_vectorPython.new_vnl_vectorUC(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUC

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUC_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: unsigned char const &

        """
        return _vnl_vectorPython.vnl_vectorUC_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> unsigned char

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: unsigned char const &

        """
        return _vnl_vectorPython.vnl_vectorUC_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorUC

        Parameters
        ----------
        ptr: unsigned char const *

        """
        return _vnl_vectorPython.vnl_vectorUC_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: unsigned char *

        """
        return _vnl_vectorPython.vnl_vectorUC_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorUC

        Parameters
        ----------
        ptr: unsigned char const *

        """
        return _vnl_vectorPython.vnl_vectorUC_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> unsigned char

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> unsigned char const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorUC

        Parameters
        ----------
        arg0: unsigned char

        __iadd__(self, rhs) -> vnl_vectorUC

        Parameters
        ----------
        rhs: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorUC

        Parameters
        ----------
        value: unsigned char

        __isub__(self, rhs) -> vnl_vectorUC

        Parameters
        ----------
        rhs: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorUC

        Parameters
        ----------
        M: vnl_matrixUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorUC

        Parameters
        ----------
        M: vnl_matrixUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorUC

        Parameters
        ----------
        arg0: unsigned char

        __imul__(self, m) -> vnl_vectorUC

        Parameters
        ----------
        m: vnl_matrixUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorUC"""
        return _vnl_vectorPython.vnl_vectorUC___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorUC"""
        return _vnl_vectorPython.vnl_vectorUC___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: unsigned char

        __add__(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: unsigned char

        __sub__(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorUC

        Parameters
        ----------
        v: unsigned char

        __mul__(self, M) -> vnl_vectorUC

        Parameters
        ----------
        M: vnl_matrixUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned char const
        data_block(self) -> unsigned char *
        """
        return _vnl_vectorPython.vnl_vectorUC_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned char
        begin(self) -> unsigned char const *
        """
        return _vnl_vectorPython.vnl_vectorUC_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned char
        end(self) -> unsigned char const *
        """
        return _vnl_vectorPython.vnl_vectorUC_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> unsigned char
        front(self) -> unsigned char const &
        """
        return _vnl_vectorPython.vnl_vectorUC_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> unsigned char
        back(self) -> unsigned char const &
        """
        return _vnl_vectorPython.vnl_vectorUC_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorUC

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorUC

        Parameters
        ----------
        arg0: vnl_vectorUC const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorUC"""
        return _vnl_vectorPython.vnl_vectorUC_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUC_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUC_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_mean(self)

    def sum(self):
        r"""sum(self) -> unsigned char"""
        return _vnl_vectorPython.vnl_vectorUC_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorUC
        flip(self, b, e) -> vnl_vectorUC

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUC_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorUC

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUC_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorUC

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUC_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorUC &

        """
        return _vnl_vectorPython.vnl_vectorUC_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorUC_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUC_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUC_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUC_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorUC const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorUC_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUC const &

        """
        return _vnl_vectorPython.vnl_vectorUC___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUC_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorUC_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUC_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorUC

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUC_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned char *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUC_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned char *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUC_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorUI
        __init__(self, len) -> vnl_vectorUI

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorUI

        Parameters
        ----------
        len: unsigned long
        v0: unsigned int const &

        __init__(self, len, n, values) -> vnl_vectorUI

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: unsigned int const *

        __init__(self, data_block, n) -> vnl_vectorUI

        Parameters
        ----------
        data_block: unsigned int const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorUI

        Parameters
        ----------
        arg0: vnl_vectorUI const &

        """
        _vnl_vectorPython.vnl_vectorUI_swiginit(self, _vnl_vectorPython.new_vnl_vectorUI(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUI

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUI_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: unsigned int const &

        """
        return _vnl_vectorPython.vnl_vectorUI_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> unsigned int

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: unsigned int const &

        """
        return _vnl_vectorPython.vnl_vectorUI_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorUI

        Parameters
        ----------
        ptr: unsigned int const *

        """
        return _vnl_vectorPython.vnl_vectorUI_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: unsigned int *

        """
        return _vnl_vectorPython.vnl_vectorUI_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorUI

        Parameters
        ----------
        ptr: unsigned int const *

        """
        return _vnl_vectorPython.vnl_vectorUI_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> unsigned int

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> unsigned int const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorUI

        Parameters
        ----------
        arg0: unsigned int

        __iadd__(self, rhs) -> vnl_vectorUI

        Parameters
        ----------
        rhs: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorUI

        Parameters
        ----------
        value: unsigned int

        __isub__(self, rhs) -> vnl_vectorUI

        Parameters
        ----------
        rhs: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorUI

        Parameters
        ----------
        M: vnl_matrixUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorUI

        Parameters
        ----------
        M: vnl_matrixUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorUI

        Parameters
        ----------
        arg0: unsigned int

        __imul__(self, m) -> vnl_vectorUI

        Parameters
        ----------
        m: vnl_matrixUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorUI"""
        return _vnl_vectorPython.vnl_vectorUI___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorUI"""
        return _vnl_vectorPython.vnl_vectorUI___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: unsigned int

        __add__(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: unsigned int

        __sub__(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorUI

        Parameters
        ----------
        v: unsigned int

        __mul__(self, M) -> vnl_vectorUI

        Parameters
        ----------
        M: vnl_matrixUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned int const
        data_block(self) -> unsigned int *
        """
        return _vnl_vectorPython.vnl_vectorUI_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned int
        begin(self) -> unsigned int const *
        """
        return _vnl_vectorPython.vnl_vectorUI_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned int
        end(self) -> unsigned int const *
        """
        return _vnl_vectorPython.vnl_vectorUI_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> unsigned int
        front(self) -> unsigned int const &
        """
        return _vnl_vectorPython.vnl_vectorUI_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> unsigned int
        back(self) -> unsigned int const &
        """
        return _vnl_vectorPython.vnl_vectorUI_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorUI

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorUI

        Parameters
        ----------
        arg0: vnl_vectorUI const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorUI"""
        return _vnl_vectorPython.vnl_vectorUI_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUI_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUI_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_mean(self)

    def sum(self):
        r"""sum(self) -> unsigned int"""
        return _vnl_vectorPython.vnl_vectorUI_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorUI
        flip(self, b, e) -> vnl_vectorUI

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUI_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorUI

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUI_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorUI

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUI_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorUI &

        """
        return _vnl_vectorPython.vnl_vectorUI_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorUI_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUI_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUI_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUI_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorUI const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorUI_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUI const &

        """
        return _vnl_vectorPython.vnl_vectorUI___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUI_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorUI_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUI_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorUI

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUI_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned int *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUI_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned int *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUI_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorUL
        __init__(self, len) -> vnl_vectorUL

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorUL

        Parameters
        ----------
        len: unsigned long
        v0: unsigned long const &

        __init__(self, len, n, values) -> vnl_vectorUL

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: unsigned long const *

        __init__(self, data_block, n) -> vnl_vectorUL

        Parameters
        ----------
        data_block: unsigned long const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorUL

        Parameters
        ----------
        arg0: vnl_vectorUL const &

        """
        _vnl_vectorPython.vnl_vectorUL_swiginit(self, _vnl_vectorPython.new_vnl_vectorUL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUL

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUL_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> unsigned long

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUL_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorUL

        Parameters
        ----------
        ptr: unsigned long const *

        """
        return _vnl_vectorPython.vnl_vectorUL_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: unsigned long *

        """
        return _vnl_vectorPython.vnl_vectorUL_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorUL

        Parameters
        ----------
        ptr: unsigned long const *

        """
        return _vnl_vectorPython.vnl_vectorUL_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> unsigned long

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> unsigned long const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorUL

        Parameters
        ----------
        arg0: unsigned long

        __iadd__(self, rhs) -> vnl_vectorUL

        Parameters
        ----------
        rhs: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorUL

        Parameters
        ----------
        value: unsigned long

        __isub__(self, rhs) -> vnl_vectorUL

        Parameters
        ----------
        rhs: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorUL

        Parameters
        ----------
        M: vnl_matrixUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorUL

        Parameters
        ----------
        M: vnl_matrixUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorUL

        Parameters
        ----------
        arg0: unsigned long

        __imul__(self, m) -> vnl_vectorUL

        Parameters
        ----------
        m: vnl_matrixUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorUL"""
        return _vnl_vectorPython.vnl_vectorUL___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorUL"""
        return _vnl_vectorPython.vnl_vectorUL___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: unsigned long

        __add__(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: unsigned long

        __sub__(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorUL

        Parameters
        ----------
        v: unsigned long

        __mul__(self, M) -> vnl_vectorUL

        Parameters
        ----------
        M: vnl_matrixUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned long const
        data_block(self) -> unsigned long *
        """
        return _vnl_vectorPython.vnl_vectorUL_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned long
        begin(self) -> unsigned long const *
        """
        return _vnl_vectorPython.vnl_vectorUL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned long
        end(self) -> unsigned long const *
        """
        return _vnl_vectorPython.vnl_vectorUL_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> unsigned long
        front(self) -> unsigned long const &
        """
        return _vnl_vectorPython.vnl_vectorUL_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> unsigned long
        back(self) -> unsigned long const &
        """
        return _vnl_vectorPython.vnl_vectorUL_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorUL

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorUL

        Parameters
        ----------
        arg0: vnl_vectorUL const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorUL"""
        return _vnl_vectorPython.vnl_vectorUL_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_mean(self)

    def sum(self):
        r"""sum(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUL_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorUL
        flip(self, b, e) -> vnl_vectorUL

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUL_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorUL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUL_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorUL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUL_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorUL &

        """
        return _vnl_vectorPython.vnl_vectorUL_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorUL_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUL_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUL_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUL_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorUL const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorUL_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUL const &

        """
        return _vnl_vectorPython.vnl_vectorUL___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUL_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorUL_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUL_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorUL

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUL_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned long *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUL_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned long *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUL_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorULL
        __init__(self, len) -> vnl_vectorULL

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorULL

        Parameters
        ----------
        len: unsigned long
        v0: unsigned long long const &

        __init__(self, len, n, values) -> vnl_vectorULL

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: unsigned long long const *

        __init__(self, data_block, n) -> vnl_vectorULL

        Parameters
        ----------
        data_block: unsigned long long const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorULL

        Parameters
        ----------
        arg0: vnl_vectorULL const &

        """
        _vnl_vectorPython.vnl_vectorULL_swiginit(self, _vnl_vectorPython.new_vnl_vectorULL(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorULL

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorULL_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: unsigned long long const &

        """
        return _vnl_vectorPython.vnl_vectorULL_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> unsigned long long

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: unsigned long long const &

        """
        return _vnl_vectorPython.vnl_vectorULL_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorULL

        Parameters
        ----------
        ptr: unsigned long long const *

        """
        return _vnl_vectorPython.vnl_vectorULL_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: unsigned long long *

        """
        return _vnl_vectorPython.vnl_vectorULL_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorULL

        Parameters
        ----------
        ptr: unsigned long long const *

        """
        return _vnl_vectorPython.vnl_vectorULL_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> unsigned long long

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> unsigned long long const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorULL

        Parameters
        ----------
        arg0: unsigned long long

        __iadd__(self, rhs) -> vnl_vectorULL

        Parameters
        ----------
        rhs: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorULL

        Parameters
        ----------
        value: unsigned long long

        __isub__(self, rhs) -> vnl_vectorULL

        Parameters
        ----------
        rhs: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorULL

        Parameters
        ----------
        M: vnl_matrixULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorULL

        Parameters
        ----------
        M: vnl_matrixULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorULL

        Parameters
        ----------
        arg0: unsigned long long

        __imul__(self, m) -> vnl_vectorULL

        Parameters
        ----------
        m: vnl_matrixULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorULL"""
        return _vnl_vectorPython.vnl_vectorULL___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorULL"""
        return _vnl_vectorPython.vnl_vectorULL___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: unsigned long long

        __add__(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: unsigned long long

        __sub__(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorULL

        Parameters
        ----------
        v: unsigned long long

        __mul__(self, M) -> vnl_vectorULL

        Parameters
        ----------
        M: vnl_matrixULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned long long const
        data_block(self) -> unsigned long long *
        """
        return _vnl_vectorPython.vnl_vectorULL_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned long long
        begin(self) -> unsigned long long const *
        """
        return _vnl_vectorPython.vnl_vectorULL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned long long
        end(self) -> unsigned long long const *
        """
        return _vnl_vectorPython.vnl_vectorULL_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> unsigned long long
        front(self) -> unsigned long long const &
        """
        return _vnl_vectorPython.vnl_vectorULL_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> unsigned long long
        back(self) -> unsigned long long const &
        """
        return _vnl_vectorPython.vnl_vectorULL_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorULL

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorULL

        Parameters
        ----------
        arg0: vnl_vectorULL const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorULL"""
        return _vnl_vectorPython.vnl_vectorULL_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorULL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorULL_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_mean(self)

    def sum(self):
        r"""sum(self) -> unsigned long long"""
        return _vnl_vectorPython.vnl_vectorULL_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorULL
        flip(self, b, e) -> vnl_vectorULL

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorULL_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorULL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorULL_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorULL

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorULL_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorULL &

        """
        return _vnl_vectorPython.vnl_vectorULL_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorULL_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorULL_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorULL_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorULL_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorULL const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorULL_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorULL const &

        """
        return _vnl_vectorPython.vnl_vectorULL___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorULL_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorULL_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorULL_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorULL

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorULL_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned long long *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorULL_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned long long *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorULL_set_data_same_size(self, datain, LetArrayManageMemory)

# 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__(self) -> vnl_vectorUS
        __init__(self, len) -> vnl_vectorUS

        Parameters
        ----------
        len: unsigned long

        __init__(self, len, v0) -> vnl_vectorUS

        Parameters
        ----------
        len: unsigned long
        v0: unsigned short const &

        __init__(self, len, n, values) -> vnl_vectorUS

        Parameters
        ----------
        len: unsigned long
        n: unsigned long
        values: unsigned short const *

        __init__(self, data_block, n) -> vnl_vectorUS

        Parameters
        ----------
        data_block: unsigned short const *
        n: unsigned long

        __init__(self, arg0) -> vnl_vectorUS

        Parameters
        ----------
        arg0: vnl_vectorUS const &

        """
        _vnl_vectorPython.vnl_vectorUS_swiginit(self, _vnl_vectorPython.new_vnl_vectorUS(*args))
    __swig_destroy__ = _vnl_vectorPython.delete_vnl_vectorUS

    def size(self):
        r"""size(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUS_size(self)

    def put(self, i, v):
        r"""
        put(self, i, v)

        Parameters
        ----------
        i: unsigned long
        v: unsigned short const &

        """
        return _vnl_vectorPython.vnl_vectorUS_put(self, i, v)

    def get(self, i):
        r"""
        get(self, i) -> unsigned short

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS_get(self, i)

    def fill(self, v):
        r"""
        fill(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: unsigned short const &

        """
        return _vnl_vectorPython.vnl_vectorUS_fill(self, v)

    def copy_in(self, ptr):
        r"""
        copy_in(self, ptr) -> vnl_vectorUS

        Parameters
        ----------
        ptr: unsigned short const *

        """
        return _vnl_vectorPython.vnl_vectorUS_copy_in(self, ptr)

    def copy_out(self, arg0):
        r"""
        copy_out(self, arg0)

        Parameters
        ----------
        arg0: unsigned short *

        """
        return _vnl_vectorPython.vnl_vectorUS_copy_out(self, arg0)

    def set(self, ptr):
        r"""
        set(self, ptr) -> vnl_vectorUS

        Parameters
        ----------
        ptr: unsigned short const *

        """
        return _vnl_vectorPython.vnl_vectorUS_set(self, ptr)

    def __call__(self, *args):
        r"""
        __call__(self, i) -> unsigned short

        Parameters
        ----------
        i: unsigned long

        __call__(self, i) -> unsigned short const &

        Parameters
        ----------
        i: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS___call__(self, *args)

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



    def __iadd__(self, *args):
        r"""
        __iadd__(self, arg0) -> vnl_vectorUS

        Parameters
        ----------
        arg0: unsigned short

        __iadd__(self, rhs) -> vnl_vectorUS

        Parameters
        ----------
        rhs: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(self, value) -> vnl_vectorUS

        Parameters
        ----------
        value: unsigned short

        __isub__(self, rhs) -> vnl_vectorUS

        Parameters
        ----------
        rhs: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___isub__(self, *args)

    def pre_multiply(self, M):
        r"""
        pre_multiply(self, M) -> vnl_vectorUS

        Parameters
        ----------
        M: vnl_matrixUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS_pre_multiply(self, M)

    def post_multiply(self, M):
        r"""
        post_multiply(self, M) -> vnl_vectorUS

        Parameters
        ----------
        M: vnl_matrixUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS_post_multiply(self, M)

    def __imul__(self, *args):
        r"""
        __imul__(self, arg0) -> vnl_vectorUS

        Parameters
        ----------
        arg0: unsigned short

        __imul__(self, m) -> vnl_vectorUS

        Parameters
        ----------
        m: vnl_matrixUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___imul__(self, *args)

    def __pos__(self):
        r"""__pos__(self) -> vnl_vectorUS"""
        return _vnl_vectorPython.vnl_vectorUS___pos__(self)

    def __neg__(self):
        r"""__neg__(self) -> vnl_vectorUS"""
        return _vnl_vectorPython.vnl_vectorUS___neg__(self)

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



    def __add__(self, *args):
        r"""
        __add__(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: unsigned short

        __add__(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: unsigned short

        __sub__(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(self, v) -> vnl_vectorUS

        Parameters
        ----------
        v: unsigned short

        __mul__(self, M) -> vnl_vectorUS

        Parameters
        ----------
        M: vnl_matrixUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___mul__(self, *args)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned short const
        data_block(self) -> unsigned short *
        """
        return _vnl_vectorPython.vnl_vectorUS_data_block(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned short
        begin(self) -> unsigned short const *
        """
        return _vnl_vectorPython.vnl_vectorUS_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned short
        end(self) -> unsigned short const *
        """
        return _vnl_vectorPython.vnl_vectorUS_end(self, *args)

    def front(self, *args):
        r"""
        front(self) -> unsigned short
        front(self) -> unsigned short const &
        """
        return _vnl_vectorPython.vnl_vectorUS_front(self, *args)

    def back(self, *args):
        r"""
        back(self) -> unsigned short
        back(self) -> unsigned short const &
        """
        return _vnl_vectorPython.vnl_vectorUS_back(self, *args)

    def extract(self, len, start=0):
        r"""
        extract(self, len, start=0) -> vnl_vectorUS

        Parameters
        ----------
        len: unsigned long
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS_extract(self, len, start)

    def update(self, arg0, start=0):
        r"""
        update(self, arg0, start=0) -> vnl_vectorUS

        Parameters
        ----------
        arg0: vnl_vectorUS const &
        start: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS_update(self, arg0, start)

    def squared_magnitude(self):
        r"""squared_magnitude(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_squared_magnitude(self)

    def magnitude(self):
        r"""magnitude(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_magnitude(self)

    def one_norm(self):
        r"""one_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_one_norm(self)

    def two_norm(self):
        r"""two_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_two_norm(self)

    def inf_norm(self):
        r"""inf_norm(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_inf_norm(self)

    def normalize(self):
        r"""normalize(self) -> vnl_vectorUS"""
        return _vnl_vectorPython.vnl_vectorUS_normalize(self)

    def rms(self):
        r"""rms(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUS_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned long"""
        return _vnl_vectorPython.vnl_vectorUS_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_mean(self)

    def sum(self):
        r"""sum(self) -> unsigned short"""
        return _vnl_vectorPython.vnl_vectorUS_sum(self)

    def flip(self, *args):
        r"""
        flip(self) -> vnl_vectorUS
        flip(self, b, e) -> vnl_vectorUS

        Parameters
        ----------
        b: unsigned long const &
        e: unsigned long const &

        """
        return _vnl_vectorPython.vnl_vectorUS_flip(self, *args)

    def roll(self, shift):
        r"""
        roll(self, shift) -> vnl_vectorUS

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUS_roll(self, shift)

    def roll_inplace(self, shift):
        r"""
        roll_inplace(self, shift) -> vnl_vectorUS

        Parameters
        ----------
        shift: int const &

        """
        return _vnl_vectorPython.vnl_vectorUS_roll_inplace(self, shift)

    def swap(self, that):
        r"""
        swap(self, that)

        Parameters
        ----------
        that: vnl_vectorUS &

        """
        return _vnl_vectorPython.vnl_vectorUS_swap(self, that)

    def assert_size(self, arg0):
        r"""
        assert_size(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS_assert_size(self, arg0)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_vectorPython.vnl_vectorUS_assert_finite(self)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUS_is_finite(self)

    def is_zero(self):
        r"""is_zero(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUS_is_zero(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_vectorPython.vnl_vectorUS_empty(self)

    def is_equal(self, rhs, tol):
        r"""
        is_equal(self, rhs, tol) -> bool

        Parameters
        ----------
        rhs: vnl_vectorUS const &
        tol: double

        """
        return _vnl_vectorPython.vnl_vectorUS_is_equal(self, rhs, tol)

    def operator_eq(self, v):
        r"""
        operator_eq(self, v) -> bool

        Parameters
        ----------
        v: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS_operator_eq(self, v)

    def __eq__(self, that):
        r"""
        __eq__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___eq__(self, that)

    def __ne__(self, that):
        r"""
        __ne__(self, that) -> bool

        Parameters
        ----------
        that: vnl_vectorUS const &

        """
        return _vnl_vectorPython.vnl_vectorUS___ne__(self, that)

    def set_size(self, n):
        r"""
        set_size(self, n) -> bool

        Parameters
        ----------
        n: unsigned long

        """
        return _vnl_vectorPython.vnl_vectorUS_set_size(self, n)

    def clear(self):
        r"""clear(self)"""
        return _vnl_vectorPython.vnl_vectorUS_clear(self)

    def read_ascii(self, s):
        r"""
        read_ascii(self, s) -> bool

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUS_read_ascii(self, s)

    @staticmethod
    def read(s):
        r"""
        read(s) -> vnl_vectorUS

        Parameters
        ----------
        s: std::basic_istream< char,std::char_traits< char > > &

        """
        return _vnl_vectorPython.vnl_vectorUS_read(s)

    def set_data(self, datain, sz, LetArrayManageMemory):
        r"""
        set_data(self, datain, sz, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned short *
        sz: unsigned long
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUS_set_data(self, datain, sz, LetArrayManageMemory)

    def set_data_same_size(self, datain, LetArrayManageMemory):
        r"""
        set_data_same_size(self, datain, LetArrayManageMemory)

        Parameters
        ----------
        datain: unsigned short *
        LetArrayManageMemory: bool

        """
        return _vnl_vectorPython.vnl_vectorUS_set_data_same_size(self, datain, LetArrayManageMemory)

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

