# 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_vector_refPython
else:
    import _vnl_vector_refPython

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refCF

        Parameters
        ----------
        n: unsigned long
        space: stdcomplexF *

        __init__(self, v) -> vnl_vector_refCF

        Parameters
        ----------
        v: vnl_vector_refCF const &

        """
        _vnl_vector_refPython.vnl_vector_refCF_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refCF(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refCF

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refCF"""
        return _vnl_vector_refPython.vnl_vector_refCF_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorCF"""
        return _vnl_vector_refPython.vnl_vector_refCF_as_vector(self)

# Register vnl_vector_refCF in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refCF_swigregister(vnl_vector_refCF)
class vnl_vector_refD(itk.vnl_vectorPython.vnl_vectorD):
    r"""Proxy of C++ vnl_vector_refD class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refD

        Parameters
        ----------
        n: unsigned long
        space: double *

        __init__(self, v) -> vnl_vector_refD

        Parameters
        ----------
        v: vnl_vector_refD const &

        """
        _vnl_vector_refPython.vnl_vector_refD_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refD(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refD

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refD"""
        return _vnl_vector_refPython.vnl_vector_refD_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorD"""
        return _vnl_vector_refPython.vnl_vector_refD_as_vector(self)

# Register vnl_vector_refD in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refD_swigregister(vnl_vector_refD)
class vnl_vector_refF(itk.vnl_vectorPython.vnl_vectorF):
    r"""Proxy of C++ vnl_vector_refF class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refF

        Parameters
        ----------
        n: unsigned long
        space: float *

        __init__(self, v) -> vnl_vector_refF

        Parameters
        ----------
        v: vnl_vector_refF const &

        """
        _vnl_vector_refPython.vnl_vector_refF_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refF(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refF

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refF"""
        return _vnl_vector_refPython.vnl_vector_refF_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorF"""
        return _vnl_vector_refPython.vnl_vector_refF_as_vector(self)

# Register vnl_vector_refF in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refF_swigregister(vnl_vector_refF)
class vnl_vector_refLD(itk.vnl_vectorPython.vnl_vectorLD):
    r"""Proxy of C++ vnl_vector_refLD class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refLD

        Parameters
        ----------
        n: unsigned long
        space: long double *

        __init__(self, v) -> vnl_vector_refLD

        Parameters
        ----------
        v: vnl_vector_refLD const &

        """
        _vnl_vector_refPython.vnl_vector_refLD_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refLD(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refLD

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refLD"""
        return _vnl_vector_refPython.vnl_vector_refLD_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorLD"""
        return _vnl_vector_refPython.vnl_vector_refLD_as_vector(self)

# Register vnl_vector_refLD in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refLD_swigregister(vnl_vector_refLD)
class vnl_vector_refSC(itk.vnl_vectorPython.vnl_vectorSC):
    r"""Proxy of C++ vnl_vector_refSC class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refSC

        Parameters
        ----------
        n: unsigned long
        space: signed char *

        __init__(self, v) -> vnl_vector_refSC

        Parameters
        ----------
        v: vnl_vector_refSC const &

        """
        _vnl_vector_refPython.vnl_vector_refSC_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refSC(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refSC

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refSC"""
        return _vnl_vector_refPython.vnl_vector_refSC_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorSC"""
        return _vnl_vector_refPython.vnl_vector_refSC_as_vector(self)

# Register vnl_vector_refSC in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refSC_swigregister(vnl_vector_refSC)
class vnl_vector_refSI(itk.vnl_vectorPython.vnl_vectorSI):
    r"""Proxy of C++ vnl_vector_refSI class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refSI

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

        __init__(self, v) -> vnl_vector_refSI

        Parameters
        ----------
        v: vnl_vector_refSI const &

        """
        _vnl_vector_refPython.vnl_vector_refSI_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refSI(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refSI

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refSI"""
        return _vnl_vector_refPython.vnl_vector_refSI_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorSI"""
        return _vnl_vector_refPython.vnl_vector_refSI_as_vector(self)

# Register vnl_vector_refSI in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refSI_swigregister(vnl_vector_refSI)
class vnl_vector_refSL(itk.vnl_vectorPython.vnl_vectorSL):
    r"""Proxy of C++ vnl_vector_refSL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refSL

        Parameters
        ----------
        n: unsigned long
        space: long *

        __init__(self, v) -> vnl_vector_refSL

        Parameters
        ----------
        v: vnl_vector_refSL const &

        """
        _vnl_vector_refPython.vnl_vector_refSL_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refSL(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refSL

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refSL"""
        return _vnl_vector_refPython.vnl_vector_refSL_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorSL"""
        return _vnl_vector_refPython.vnl_vector_refSL_as_vector(self)

# Register vnl_vector_refSL in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refSL_swigregister(vnl_vector_refSL)
class vnl_vector_refSLL(itk.vnl_vectorPython.vnl_vectorSLL):
    r"""Proxy of C++ vnl_vector_refSLL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refSLL

        Parameters
        ----------
        n: unsigned long
        space: long long *

        __init__(self, v) -> vnl_vector_refSLL

        Parameters
        ----------
        v: vnl_vector_refSLL const &

        """
        _vnl_vector_refPython.vnl_vector_refSLL_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refSLL(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refSLL

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refSLL"""
        return _vnl_vector_refPython.vnl_vector_refSLL_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorSLL"""
        return _vnl_vector_refPython.vnl_vector_refSLL_as_vector(self)

# Register vnl_vector_refSLL in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refSLL_swigregister(vnl_vector_refSLL)
class vnl_vector_refSS(itk.vnl_vectorPython.vnl_vectorSS):
    r"""Proxy of C++ vnl_vector_refSS class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refSS

        Parameters
        ----------
        n: unsigned long
        space: short *

        __init__(self, v) -> vnl_vector_refSS

        Parameters
        ----------
        v: vnl_vector_refSS const &

        """
        _vnl_vector_refPython.vnl_vector_refSS_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refSS(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refSS

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refSS"""
        return _vnl_vector_refPython.vnl_vector_refSS_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorSS"""
        return _vnl_vector_refPython.vnl_vector_refSS_as_vector(self)

# Register vnl_vector_refSS in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refSS_swigregister(vnl_vector_refSS)
class vnl_vector_refUC(itk.vnl_vectorPython.vnl_vectorUC):
    r"""Proxy of C++ vnl_vector_refUC class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refUC

        Parameters
        ----------
        n: unsigned long
        space: unsigned char *

        __init__(self, v) -> vnl_vector_refUC

        Parameters
        ----------
        v: vnl_vector_refUC const &

        """
        _vnl_vector_refPython.vnl_vector_refUC_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refUC(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refUC

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refUC"""
        return _vnl_vector_refPython.vnl_vector_refUC_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorUC"""
        return _vnl_vector_refPython.vnl_vector_refUC_as_vector(self)

# Register vnl_vector_refUC in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refUC_swigregister(vnl_vector_refUC)
class vnl_vector_refUI(itk.vnl_vectorPython.vnl_vectorUI):
    r"""Proxy of C++ vnl_vector_refUI class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refUI

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

        __init__(self, v) -> vnl_vector_refUI

        Parameters
        ----------
        v: vnl_vector_refUI const &

        """
        _vnl_vector_refPython.vnl_vector_refUI_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refUI(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refUI

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refUI"""
        return _vnl_vector_refPython.vnl_vector_refUI_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorUI"""
        return _vnl_vector_refPython.vnl_vector_refUI_as_vector(self)

# Register vnl_vector_refUI in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refUI_swigregister(vnl_vector_refUI)
class vnl_vector_refUL(itk.vnl_vectorPython.vnl_vectorUL):
    r"""Proxy of C++ vnl_vector_refUL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refUL

        Parameters
        ----------
        n: unsigned long
        space: unsigned long *

        __init__(self, v) -> vnl_vector_refUL

        Parameters
        ----------
        v: vnl_vector_refUL const &

        """
        _vnl_vector_refPython.vnl_vector_refUL_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refUL(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refUL

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refUL"""
        return _vnl_vector_refPython.vnl_vector_refUL_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorUL"""
        return _vnl_vector_refPython.vnl_vector_refUL_as_vector(self)

# Register vnl_vector_refUL in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refUL_swigregister(vnl_vector_refUL)
class vnl_vector_refULL(itk.vnl_vectorPython.vnl_vectorULL):
    r"""Proxy of C++ vnl_vector_refULL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refULL

        Parameters
        ----------
        n: unsigned long
        space: unsigned long long *

        __init__(self, v) -> vnl_vector_refULL

        Parameters
        ----------
        v: vnl_vector_refULL const &

        """
        _vnl_vector_refPython.vnl_vector_refULL_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refULL(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refULL

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refULL"""
        return _vnl_vector_refPython.vnl_vector_refULL_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorULL"""
        return _vnl_vector_refPython.vnl_vector_refULL_as_vector(self)

# Register vnl_vector_refULL in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refULL_swigregister(vnl_vector_refULL)
class vnl_vector_refUS(itk.vnl_vectorPython.vnl_vectorUS):
    r"""Proxy of C++ vnl_vector_refUS class."""

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

    def __init__(self, *args):
        r"""
        __init__(self, n, space) -> vnl_vector_refUS

        Parameters
        ----------
        n: unsigned long
        space: unsigned short *

        __init__(self, v) -> vnl_vector_refUS

        Parameters
        ----------
        v: vnl_vector_refUS const &

        """
        _vnl_vector_refPython.vnl_vector_refUS_swiginit(self, _vnl_vector_refPython.new_vnl_vector_refUS(*args))
    __swig_destroy__ = _vnl_vector_refPython.delete_vnl_vector_refUS

    def non_const(self):
        r"""non_const(self) -> vnl_vector_refUS"""
        return _vnl_vector_refPython.vnl_vector_refUS_non_const(self)

    def as_vector(self):
        r"""as_vector(self) -> vnl_vectorUS"""
        return _vnl_vector_refPython.vnl_vector_refUS_as_vector(self)

# Register vnl_vector_refUS in _vnl_vector_refPython:
_vnl_vector_refPython.vnl_vector_refUS_swigregister(vnl_vector_refUS)

