# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.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 getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _vnl_c_vectorPython
else:
    import _vnl_c_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
class vnl_c_vectorCF(object):
    r"""Proxy of C++ vnl_c_vectorCF class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> stdcomplexF

        Parameters
        ----------
        v: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: stdcomplexF *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF *
        arg2: unsigned int
        arg3: stdcomplexF const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const *
        z: stdcomplexF *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const &
        z: stdcomplexF *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const *
        z: stdcomplexF *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const &
        z: stdcomplexF *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const *
        z: stdcomplexF *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const &
        z: stdcomplexF *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const *
        z: stdcomplexF *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF const &
        z: stdcomplexF *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: stdcomplexF const *
        y: stdcomplexF *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: stdcomplexF const &
        x: stdcomplexF const *
        y: stdcomplexF *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: stdcomplexF *
        arg1: unsigned int
        v: stdcomplexF const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: stdcomplexF *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> stdcomplexF

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: stdcomplexF const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> stdcomplexF

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: stdcomplexF const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: stdcomplexF *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> stdcomplexF

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> stdcomplexF

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> stdcomplexF

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> stdcomplexF

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> stdcomplexF

        Parameters
        ----------
        v: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> float

        Parameters
        ----------
        p: stdcomplexF const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> stdcomplexF

        Parameters
        ----------
        arg0: stdcomplexF const *
        arg1: stdcomplexF const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> stdcomplexF **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> stdcomplexF

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: stdcomplexF **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: stdcomplexF *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorCF_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorCF
        __init__(self, arg0) -> vnl_c_vectorCF

        Parameters
        ----------
        arg0: vnl_c_vectorCF const &

        """
        _vnl_c_vectorPython.vnl_c_vectorCF_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorCF(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorCF

# Register vnl_c_vectorCF in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorCF_swigregister(vnl_c_vectorCF)
class vnl_c_vectorD(object):
    r"""Proxy of C++ vnl_c_vectorD class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> double

        Parameters
        ----------
        v: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: double *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: double const *
        y: double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: double const *
        y: double *
        arg2: unsigned int
        arg3: double const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const *
        z: double *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const &
        z: double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const *
        z: double *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const &
        z: double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const *
        z: double *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const &
        z: double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const *
        z: double *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: double const *
        y: double const &
        z: double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: double const *
        y: double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: double const *
        y: double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: double const &
        x: double const *
        y: double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: double *
        arg1: unsigned int
        v: double const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: double *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> double

        Parameters
        ----------
        arg0: double const *
        arg1: double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> double

        Parameters
        ----------
        arg0: double const *
        arg1: double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: double const *
        arg1: double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> double

        Parameters
        ----------
        arg0: double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> double

        Parameters
        ----------
        arg0: double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> double

        Parameters
        ----------
        v: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> double

        Parameters
        ----------
        p: double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> double

        Parameters
        ----------
        arg0: double const *
        arg1: double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> double **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> double *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: double **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: double *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorD_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorD
        __init__(self, arg0) -> vnl_c_vectorD

        Parameters
        ----------
        arg0: vnl_c_vectorD const &

        """
        _vnl_c_vectorPython.vnl_c_vectorD_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorD(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorD

# Register vnl_c_vectorD in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorD_swigregister(vnl_c_vectorD)
class vnl_c_vectorF(object):
    r"""Proxy of C++ vnl_c_vectorF class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> float

        Parameters
        ----------
        v: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: float *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: float const *
        y: float *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: float const *
        y: float *
        arg2: unsigned int
        arg3: float const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const *
        z: float *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const &
        z: float *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const *
        z: float *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const &
        z: float *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const *
        z: float *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const &
        z: float *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const *
        z: float *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: float const *
        y: float const &
        z: float *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: float const *
        y: float *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: float const *
        y: float *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: float const &
        x: float const *
        y: float *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: float *
        arg1: unsigned int
        v: float const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: float *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> float

        Parameters
        ----------
        arg0: float const *
        arg1: float const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> float

        Parameters
        ----------
        arg0: float const *
        arg1: float const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: float const *
        arg1: float *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> float

        Parameters
        ----------
        arg0: float const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> float

        Parameters
        ----------
        arg0: float const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: float const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: float const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> float

        Parameters
        ----------
        v: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> float

        Parameters
        ----------
        p: float const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> float

        Parameters
        ----------
        arg0: float const *
        arg1: float const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> float **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> float *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: float **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: float *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorF_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorF
        __init__(self, arg0) -> vnl_c_vectorF

        Parameters
        ----------
        arg0: vnl_c_vectorF const &

        """
        _vnl_c_vectorPython.vnl_c_vectorF_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorF(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorF

# Register vnl_c_vectorF in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorF_swigregister(vnl_c_vectorF)
class vnl_c_vectorLD(object):
    r"""Proxy of C++ vnl_c_vectorLD class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> long double

        Parameters
        ----------
        v: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: long double *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: long double const *
        y: long double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double *
        arg2: unsigned int
        arg3: long double const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const *
        z: long double *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const &
        z: long double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const *
        z: long double *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const &
        z: long double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const *
        z: long double *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const &
        z: long double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const *
        z: long double *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long double const *
        y: long double const &
        z: long double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: long double const *
        y: long double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: long double const *
        y: long double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: long double const &
        x: long double const *
        y: long double *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: long double *
        arg1: unsigned int
        v: long double const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: long double *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> long double

        Parameters
        ----------
        arg0: long double const *
        arg1: long double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> long double

        Parameters
        ----------
        arg0: long double const *
        arg1: long double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: long double const *
        arg1: long double *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> long double

        Parameters
        ----------
        arg0: long double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> long double

        Parameters
        ----------
        arg0: long double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long double const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> long double

        Parameters
        ----------
        v: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> long double

        Parameters
        ----------
        p: long double const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> long double

        Parameters
        ----------
        arg0: long double const *
        arg1: long double const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> long double **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> long double *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long double **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long double *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorLD_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorLD
        __init__(self, arg0) -> vnl_c_vectorLD

        Parameters
        ----------
        arg0: vnl_c_vectorLD const &

        """
        _vnl_c_vectorPython.vnl_c_vectorLD_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorLD(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorLD

# Register vnl_c_vectorLD in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorLD_swigregister(vnl_c_vectorLD)
class vnl_c_vectorSC(object):
    r"""Proxy of C++ vnl_c_vectorSC class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> signed char

        Parameters
        ----------
        v: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: signed char *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: signed char const *
        y: signed char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char *
        arg2: unsigned int
        arg3: signed char const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const *
        z: signed char *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const &
        z: signed char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const *
        z: signed char *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const &
        z: signed char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const *
        z: signed char *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const &
        z: signed char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const *
        z: signed char *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: signed char const *
        y: signed char const &
        z: signed char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: signed char const *
        y: signed char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: signed char const *
        y: signed char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: signed char const &
        x: signed char const *
        y: signed char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: signed char *
        arg1: unsigned int
        v: signed char const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: signed char *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> signed char

        Parameters
        ----------
        arg0: signed char const *
        arg1: signed char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> signed char

        Parameters
        ----------
        arg0: signed char const *
        arg1: signed char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: signed char const *
        arg1: signed char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> signed char

        Parameters
        ----------
        arg0: signed char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> signed char

        Parameters
        ----------
        arg0: signed char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: signed char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: signed char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> signed char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> signed char

        Parameters
        ----------
        v: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: signed char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> signed char

        Parameters
        ----------
        arg0: signed char const *
        arg1: signed char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> signed char **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> signed char *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: signed char **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: signed char *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorSC_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorSC
        __init__(self, arg0) -> vnl_c_vectorSC

        Parameters
        ----------
        arg0: vnl_c_vectorSC const &

        """
        _vnl_c_vectorPython.vnl_c_vectorSC_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorSC(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorSC

# Register vnl_c_vectorSC in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorSC_swigregister(vnl_c_vectorSC)
class vnl_c_vectorSI(object):
    r"""Proxy of C++ vnl_c_vectorSI class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> int

        Parameters
        ----------
        v: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: int *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: int const *
        y: int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: int const *
        y: int *
        arg2: unsigned int
        arg3: int const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const *
        z: int *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const &
        z: int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const *
        z: int *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const &
        z: int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const *
        z: int *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const &
        z: int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const *
        z: int *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: int const *
        y: int const &
        z: int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: int const *
        y: int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: int const *
        y: int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: int const &
        x: int const *
        y: int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: int *
        arg1: unsigned int
        v: int const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: int *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> int

        Parameters
        ----------
        arg0: int const *
        arg1: int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> int

        Parameters
        ----------
        arg0: int const *
        arg1: int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: int const *
        arg1: int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> int

        Parameters
        ----------
        arg0: int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> int

        Parameters
        ----------
        arg0: int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> int

        Parameters
        ----------
        v: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> int

        Parameters
        ----------
        arg0: int const *
        arg1: int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> int **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> int *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: int **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: int *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorSI_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorSI
        __init__(self, arg0) -> vnl_c_vectorSI

        Parameters
        ----------
        arg0: vnl_c_vectorSI const &

        """
        _vnl_c_vectorPython.vnl_c_vectorSI_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorSI(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorSI

# Register vnl_c_vectorSI in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorSI_swigregister(vnl_c_vectorSI)
class vnl_c_vectorSL(object):
    r"""Proxy of C++ vnl_c_vectorSL class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: long *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: long const *
        y: long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: long const *
        y: long *
        arg2: unsigned int
        arg3: long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const *
        z: long *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const &
        z: long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const *
        z: long *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const &
        z: long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const *
        z: long *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const &
        z: long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const *
        z: long *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long const *
        y: long const &
        z: long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: long const *
        y: long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: long const *
        y: long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: long const &
        x: long const *
        y: long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: long *
        arg1: unsigned int
        v: long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: long *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> long

        Parameters
        ----------
        arg0: long const *
        arg1: long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> long

        Parameters
        ----------
        arg0: long const *
        arg1: long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: long const *
        arg1: long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> long

        Parameters
        ----------
        arg0: long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> long

        Parameters
        ----------
        arg0: long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> long

        Parameters
        ----------
        arg0: long const *
        arg1: long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> long **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> long *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorSL_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorSL
        __init__(self, arg0) -> vnl_c_vectorSL

        Parameters
        ----------
        arg0: vnl_c_vectorSL const &

        """
        _vnl_c_vectorPython.vnl_c_vectorSL_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorSL(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorSL

# Register vnl_c_vectorSL in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorSL_swigregister(vnl_c_vectorSL)
class vnl_c_vectorSLL(object):
    r"""Proxy of C++ vnl_c_vectorSLL class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: long long *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: long long const *
        y: long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long *
        arg2: unsigned int
        arg3: long long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const *
        z: long long *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const &
        z: long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const *
        z: long long *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const &
        z: long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const *
        z: long long *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const &
        z: long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const *
        z: long long *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: long long const *
        y: long long const &
        z: long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: long long const *
        y: long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: long long const *
        y: long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: long long const &
        x: long long const *
        y: long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: long long *
        arg1: unsigned int
        v: long long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: long long *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> long long

        Parameters
        ----------
        arg0: long long const *
        arg1: long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> long long

        Parameters
        ----------
        arg0: long long const *
        arg1: long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: long long const *
        arg1: long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> long long

        Parameters
        ----------
        arg0: long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> long long

        Parameters
        ----------
        arg0: long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> long long

        Parameters
        ----------
        arg0: long long const *
        arg1: long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> long long **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> long long *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long long **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: long long *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorSLL_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorSLL
        __init__(self, arg0) -> vnl_c_vectorSLL

        Parameters
        ----------
        arg0: vnl_c_vectorSLL const &

        """
        _vnl_c_vectorPython.vnl_c_vectorSLL_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorSLL(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorSLL

# Register vnl_c_vectorSLL in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorSLL_swigregister(vnl_c_vectorSLL)
class vnl_c_vectorUC(object):
    r"""Proxy of C++ vnl_c_vectorUC class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> unsigned char

        Parameters
        ----------
        v: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: unsigned char *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char *
        arg2: unsigned int
        arg3: unsigned char const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const *
        z: unsigned char *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const &
        z: unsigned char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const *
        z: unsigned char *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const &
        z: unsigned char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const *
        z: unsigned char *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const &
        z: unsigned char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const *
        z: unsigned char *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char const &
        z: unsigned char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: unsigned char const *
        y: unsigned char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: unsigned char const &
        x: unsigned char const *
        y: unsigned char *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: unsigned char *
        arg1: unsigned int
        v: unsigned char const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: unsigned char *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> unsigned char

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> unsigned char

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned char *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> unsigned char

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> unsigned char

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> unsigned char

        Parameters
        ----------
        v: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned char

        Parameters
        ----------
        p: unsigned char const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> unsigned char

        Parameters
        ----------
        arg0: unsigned char const *
        arg1: unsigned char const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> unsigned char **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> unsigned char *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned char **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned char *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorUC_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorUC
        __init__(self, arg0) -> vnl_c_vectorUC

        Parameters
        ----------
        arg0: vnl_c_vectorUC const &

        """
        _vnl_c_vectorPython.vnl_c_vectorUC_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorUC(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorUC

# Register vnl_c_vectorUC in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorUC_swigregister(vnl_c_vectorUC)
class vnl_c_vectorUI(object):
    r"""Proxy of C++ vnl_c_vectorUI class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> unsigned int

        Parameters
        ----------
        v: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: unsigned int *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int *
        arg2: unsigned int
        arg3: unsigned int const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const *
        z: unsigned int *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const &
        z: unsigned int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const *
        z: unsigned int *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const &
        z: unsigned int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const *
        z: unsigned int *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const &
        z: unsigned int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const *
        z: unsigned int *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int const &
        z: unsigned int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: unsigned int const *
        y: unsigned int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: unsigned int const &
        x: unsigned int const *
        y: unsigned int *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: unsigned int *
        arg1: unsigned int
        v: unsigned int const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: unsigned int *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> unsigned int

        Parameters
        ----------
        v: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned int

        Parameters
        ----------
        p: unsigned int const *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> unsigned int

        Parameters
        ----------
        arg0: unsigned int const *
        arg1: unsigned int const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> unsigned int **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> unsigned int *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned int **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned int *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorUI_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorUI
        __init__(self, arg0) -> vnl_c_vectorUI

        Parameters
        ----------
        arg0: vnl_c_vectorUI const &

        """
        _vnl_c_vectorPython.vnl_c_vectorUI_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorUI(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorUI

# Register vnl_c_vectorUI in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorUI_swigregister(vnl_c_vectorUI)
class vnl_c_vectorUL(object):
    r"""Proxy of C++ vnl_c_vectorUL class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: unsigned long *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long *
        arg2: unsigned int
        arg3: unsigned long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const *
        z: unsigned long *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const &
        z: unsigned long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const *
        z: unsigned long *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const &
        z: unsigned long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const *
        z: unsigned long *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const &
        z: unsigned long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const *
        z: unsigned long *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long const &
        z: unsigned long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: unsigned long const *
        y: unsigned long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: unsigned long const &
        x: unsigned long const *
        y: unsigned long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: unsigned long *
        arg1: unsigned int
        v: unsigned long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: unsigned long *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> unsigned long

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> unsigned long

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> unsigned long

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> unsigned long

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> unsigned long

        Parameters
        ----------
        arg0: unsigned long const *
        arg1: unsigned long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> unsigned long **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> unsigned long *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned long **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned long *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorUL_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorUL
        __init__(self, arg0) -> vnl_c_vectorUL

        Parameters
        ----------
        arg0: vnl_c_vectorUL const &

        """
        _vnl_c_vectorPython.vnl_c_vectorUL_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorUL(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorUL

# Register vnl_c_vectorUL in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorUL_swigregister(vnl_c_vectorUL)
class vnl_c_vectorULL(object):
    r"""Proxy of C++ vnl_c_vectorULL class."""

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

    @staticmethod
    def sum(v, n):
        r"""
        sum(v, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_sum(v, n)

    @staticmethod
    def squared_magnitude(p, n):
        r"""
        squared_magnitude(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_squared_magnitude(p, n)

    @staticmethod
    def normalize(arg0, n):
        r"""
        normalize(arg0, n)

        Parameters
        ----------
        arg0: unsigned long long *
        n: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_normalize(arg0, n)

    @staticmethod
    def copy(x, y, arg2):
        r"""
        copy(x, y, arg2)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_copy(x, y, arg2)

    @staticmethod
    def scale(x, y, arg2, arg3):
        r"""
        scale(x, y, arg2, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long *
        arg2: unsigned int
        arg3: unsigned long long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_scale(x, y, arg2, arg3)

    @staticmethod
    def add(*args):
        r"""
        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const *
        z: unsigned long long *
        arg3: unsigned int

        add(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const &
        z: unsigned long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_add(*args)

    @staticmethod
    def subtract(*args):
        r"""
        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const *
        z: unsigned long long *
        arg3: unsigned int

        subtract(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const &
        z: unsigned long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_subtract(*args)

    @staticmethod
    def multiply(*args):
        r"""
        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const *
        z: unsigned long long *
        arg3: unsigned int

        multiply(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const &
        z: unsigned long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_multiply(*args)

    @staticmethod
    def divide(*args):
        r"""
        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const *
        z: unsigned long long *
        arg3: unsigned int

        divide(x, y, z, arg3)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long const &
        z: unsigned long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_divide(*args)

    @staticmethod
    def negate(x, y, arg2):
        r"""
        negate(x, y, arg2)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_negate(x, y, arg2)

    @staticmethod
    def invert(x, y, arg2):
        r"""
        invert(x, y, arg2)

        Parameters
        ----------
        x: unsigned long long const *
        y: unsigned long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_invert(x, y, arg2)

    @staticmethod
    def saxpy(a, x, y, arg3):
        r"""
        saxpy(a, x, y, arg3)

        Parameters
        ----------
        a: unsigned long long const &
        x: unsigned long long const *
        y: unsigned long long *
        arg3: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_saxpy(a, x, y, arg3)

    @staticmethod
    def fill(x, arg1, v):
        r"""
        fill(x, arg1, v)

        Parameters
        ----------
        x: unsigned long long *
        arg1: unsigned int
        v: unsigned long long const &

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_fill(x, arg1, v)

    @staticmethod
    def reverse(x, arg1):
        r"""
        reverse(x, arg1)

        Parameters
        ----------
        x: unsigned long long *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_reverse(x, arg1)

    @staticmethod
    def dot_product(arg0, arg1, arg2):
        r"""
        dot_product(arg0, arg1, arg2) -> unsigned long long

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_dot_product(arg0, arg1, arg2)

    @staticmethod
    def inner_product(arg0, arg1, arg2):
        r"""
        inner_product(arg0, arg1, arg2) -> unsigned long long

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_inner_product(arg0, arg1, arg2)

    @staticmethod
    def conjugate(arg0, arg1, arg2):
        r"""
        conjugate(arg0, arg1, arg2)

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned long long *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_conjugate(arg0, arg1, arg2)

    @staticmethod
    def max_value(arg0, arg1):
        r"""
        max_value(arg0, arg1) -> unsigned long long

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_max_value(arg0, arg1)

    @staticmethod
    def min_value(arg0, arg1):
        r"""
        min_value(arg0, arg1) -> unsigned long long

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_min_value(arg0, arg1)

    @staticmethod
    def arg_max(arg0, arg1):
        r"""
        arg_max(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_arg_max(arg0, arg1)

    @staticmethod
    def arg_min(arg0, arg1):
        r"""
        arg_min(arg0, arg1) -> unsigned int

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_arg_min(arg0, arg1)

    @staticmethod
    def mean(p, n):
        r"""
        mean(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_mean(p, n)

    @staticmethod
    def std(p, n):
        r"""
        std(p, n) -> double

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_std(p, n)

    @staticmethod
    def sum_sq_diff_means(v, n):
        r"""
        sum_sq_diff_means(v, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_sum_sq_diff_means(v, n)

    @staticmethod
    def one_norm(p, n):
        r"""
        one_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_one_norm(p, n)

    @staticmethod
    def two_norm(p, n):
        r"""
        two_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_two_norm(p, n)

    @staticmethod
    def inf_norm(p, n):
        r"""
        inf_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_inf_norm(p, n)

    @staticmethod
    def two_nrm2(p, n):
        r"""
        two_nrm2(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_two_nrm2(p, n)

    @staticmethod
    def rms_norm(p, n):
        r"""
        rms_norm(p, n) -> unsigned long long

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_rms_norm(p, n)

    @staticmethod
    def euclid_dist_sq(arg0, arg1, arg2):
        r"""
        euclid_dist_sq(arg0, arg1, arg2) -> unsigned long long

        Parameters
        ----------
        arg0: unsigned long long const *
        arg1: unsigned long long const *
        arg2: unsigned int

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_euclid_dist_sq(arg0, arg1, arg2)

    @staticmethod
    def allocate_Tptr(n):
        r"""
        allocate_Tptr(n) -> unsigned long long **

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_allocate_Tptr(n)

    @staticmethod
    def allocate_T(n):
        r"""
        allocate_T(n) -> unsigned long long *

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

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_allocate_T(n)

    @staticmethod
    def deallocate(*args):
        r"""
        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned long long **
        n_when_allocated: unsigned long const

        deallocate(arg0, n_when_allocated)

        Parameters
        ----------
        arg0: unsigned long long *
        n_when_allocated: unsigned long const

        """
        return _vnl_c_vectorPython.vnl_c_vectorULL_deallocate(*args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_c_vectorULL
        __init__(self, arg0) -> vnl_c_vectorULL

        Parameters
        ----------
        arg0: vnl_c_vectorULL const &

        """
        _vnl_c_vectorPython.vnl_c_vectorULL_swiginit(self, _vnl_c_vectorPython.new_vnl_c_vectorULL(*args))
    __swig_destroy__ = _vnl_c_vectorPython.delete_vnl_c_vectorULL

# Register vnl_c_vectorULL in _vnl_c_vectorPython:
_vnl_c_vectorPython.vnl_c_vectorULL_swigregister(vnl_c_vectorULL)

