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


import collections

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

from . import _ITKCommonPython


from . import _ITKCommonPython



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

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
class vnl_matrixCF(object):
    r"""Proxy of C++ vnl_matrixCF class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixCF
        __init__(self, r, c) -> vnl_matrixCF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixCF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: stdcomplexF const &

        __init__(self, r, c, t) -> vnl_matrixCF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixCF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: stdcomplexF const *

        __init__(self, data_block, r, c) -> vnl_matrixCF

        Parameters
        ----------
        data_block: stdcomplexF const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: vnl_matrixCF const &

        """
        _vnl_matrixPython.vnl_matrixCF_swiginit(self, _vnl_matrixPython.new_vnl_matrixCF(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixCF

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: stdcomplexF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> stdcomplexF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: stdcomplexF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: stdcomplexF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixCF

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

        """
        return _vnl_matrixPython.vnl_matrixCF_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixCF

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

        """
        return _vnl_matrixPython.vnl_matrixCF_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixCF

        Parameters
        ----------
        d: stdcomplexF const *

        """
        return _vnl_matrixPython.vnl_matrixCF_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixCF_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixCF___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixCF

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

        __iadd__(self, arg0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixCF

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

        __imul__(self, rhs) -> vnl_matrixCF

        Parameters
        ----------
        rhs: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixCF___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixCF

        Parameters
        ----------
        rhs: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixCF

        Parameters
        ----------
        rhs: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixCF

        Parameters
        ----------
        rhs: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixCF

        Parameters
        ----------
        arg0: vnl_matrixCF const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixCF

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

        set_column(self, i, value) -> vnl_matrixCF

        Parameters
        ----------
        i: unsigned int
        value: stdcomplexF

        set_column(self, j, v) -> vnl_matrixCF

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixCF

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixCF

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

        set_row(self, i, value) -> vnl_matrixCF

        Parameters
        ----------
        i: unsigned int
        value: stdcomplexF

        set_row(self, i, arg1) -> vnl_matrixCF

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixCF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixCF &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorCF

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorCF

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixCF

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixCF_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixCF

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixCF_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixCF

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixCF

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorCF"""
        return _vnl_matrixPython.vnl_matrixCF_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorCF"""
        return _vnl_matrixPython.vnl_matrixCF_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorCF"""
        return _vnl_matrixPython.vnl_matrixCF_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixCF"""
        return _vnl_matrixPython.vnl_matrixCF_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixCF

        Parameters
        ----------
        row: unsigned int
        value: stdcomplexF

        """
        return _vnl_matrixPython.vnl_matrixCF_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixCF

        Parameters
        ----------
        col: unsigned int
        value: stdcomplexF

        """
        return _vnl_matrixPython.vnl_matrixCF_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixCF &

        """
        return _vnl_matrixPython.vnl_matrixCF_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_fro_norm(self)

    def rms(self):
        r"""rms(self) -> float"""
        return _vnl_matrixPython.vnl_matrixCF_rms(self)

    def min_value(self):
        r"""min_value(self) -> stdcomplexF"""
        return _vnl_matrixPython.vnl_matrixCF_min_value(self)

    def max_value(self):
        r"""max_value(self) -> stdcomplexF"""
        return _vnl_matrixPython.vnl_matrixCF_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixCF_arg_max(self)

    def mean(self):
        r"""mean(self) -> stdcomplexF"""
        return _vnl_matrixPython.vnl_matrixCF_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixCF_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixCF_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixCF_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixCF_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixCF_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixCF_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixCF_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixCF_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixCF_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> stdcomplexF
        data_array(self) -> stdcomplexF **
        """
        return _vnl_matrixPython.vnl_matrixCF_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixCF const &

        """
        return _vnl_matrixPython.vnl_matrixCF___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixCF__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixCF_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixCF_set_size(self, r, c)

# Register vnl_matrixCF in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixCF_swigregister(vnl_matrixCF)
class vnl_matrixD(object):
    r"""Proxy of C++ vnl_matrixD class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixD
        __init__(self, r, c) -> vnl_matrixD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: double const &

        __init__(self, r, c, t) -> vnl_matrixD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: double const *

        __init__(self, data_block, r, c) -> vnl_matrixD

        Parameters
        ----------
        data_block: double const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixD

        Parameters
        ----------
        arg0: vnl_matrixD const &

        """
        _vnl_matrixPython.vnl_matrixD_swiginit(self, _vnl_matrixPython.new_vnl_matrixD(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixD

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: double const &

        """
        return _vnl_matrixPython.vnl_matrixD_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> double const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixD

        Parameters
        ----------
        arg0: double const &

        """
        return _vnl_matrixPython.vnl_matrixD_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixD

        Parameters
        ----------
        arg0: double const &

        """
        return _vnl_matrixPython.vnl_matrixD_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixD

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

        """
        return _vnl_matrixPython.vnl_matrixD_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixD

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

        """
        return _vnl_matrixPython.vnl_matrixD_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixD

        Parameters
        ----------
        d: double const *

        """
        return _vnl_matrixPython.vnl_matrixD_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixD_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixD___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixD

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

        __iadd__(self, arg0) -> vnl_matrixD

        Parameters
        ----------
        arg0: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixD

        Parameters
        ----------
        arg0: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixD

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

        __imul__(self, rhs) -> vnl_matrixD

        Parameters
        ----------
        rhs: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixD___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixD

        Parameters
        ----------
        rhs: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixD

        Parameters
        ----------
        rhs: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixD

        Parameters
        ----------
        rhs: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixD

        Parameters
        ----------
        arg0: vnl_matrixD const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixD

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

        set_column(self, i, value) -> vnl_matrixD

        Parameters
        ----------
        i: unsigned int
        value: double

        set_column(self, j, v) -> vnl_matrixD

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorD const &

        """
        return _vnl_matrixPython.vnl_matrixD_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixD

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixD

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

        set_row(self, i, value) -> vnl_matrixD

        Parameters
        ----------
        i: unsigned int
        value: double

        set_row(self, i, arg1) -> vnl_matrixD

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorD const &

        """
        return _vnl_matrixPython.vnl_matrixD_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixD &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorD

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorD

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixD

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixD_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixD

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixD_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixD

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixD

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorD"""
        return _vnl_matrixPython.vnl_matrixD_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorD"""
        return _vnl_matrixPython.vnl_matrixD_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorD"""
        return _vnl_matrixPython.vnl_matrixD_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixD"""
        return _vnl_matrixPython.vnl_matrixD_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixD

        Parameters
        ----------
        row: unsigned int
        value: double

        """
        return _vnl_matrixPython.vnl_matrixD_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixD

        Parameters
        ----------
        col: unsigned int
        value: double

        """
        return _vnl_matrixPython.vnl_matrixD_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixD &

        """
        return _vnl_matrixPython.vnl_matrixD_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_fro_norm(self)

    def rms(self):
        r"""rms(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_rms(self)

    def min_value(self):
        r"""min_value(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_min_value(self)

    def max_value(self):
        r"""max_value(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixD_arg_max(self)

    def mean(self):
        r"""mean(self) -> double"""
        return _vnl_matrixPython.vnl_matrixD_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixD_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixD_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixD_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixD_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixD_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixD_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixD_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixD_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixD_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> double const
        data_array(self) -> double **
        """
        return _vnl_matrixPython.vnl_matrixD_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixD const &

        """
        return _vnl_matrixPython.vnl_matrixD___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixD__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixD_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixD_set_size(self, r, c)

# Register vnl_matrixD in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixD_swigregister(vnl_matrixD)
class vnl_matrixF(object):
    r"""Proxy of C++ vnl_matrixF class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixF
        __init__(self, r, c) -> vnl_matrixF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: float const &

        __init__(self, r, c, t) -> vnl_matrixF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: float const *

        __init__(self, data_block, r, c) -> vnl_matrixF

        Parameters
        ----------
        data_block: float const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixF

        Parameters
        ----------
        arg0: vnl_matrixF const &

        """
        _vnl_matrixPython.vnl_matrixF_swiginit(self, _vnl_matrixPython.new_vnl_matrixF(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixF

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: float const &

        """
        return _vnl_matrixPython.vnl_matrixF_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> float const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixF

        Parameters
        ----------
        arg0: float const &

        """
        return _vnl_matrixPython.vnl_matrixF_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixF

        Parameters
        ----------
        arg0: float const &

        """
        return _vnl_matrixPython.vnl_matrixF_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixF

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

        """
        return _vnl_matrixPython.vnl_matrixF_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixF

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

        """
        return _vnl_matrixPython.vnl_matrixF_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixF

        Parameters
        ----------
        d: float const *

        """
        return _vnl_matrixPython.vnl_matrixF_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixF_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixF___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixF

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

        __iadd__(self, arg0) -> vnl_matrixF

        Parameters
        ----------
        arg0: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixF

        Parameters
        ----------
        arg0: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixF

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

        __imul__(self, rhs) -> vnl_matrixF

        Parameters
        ----------
        rhs: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixF___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixF

        Parameters
        ----------
        rhs: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixF

        Parameters
        ----------
        rhs: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixF

        Parameters
        ----------
        rhs: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixF

        Parameters
        ----------
        arg0: vnl_matrixF const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixF

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

        set_column(self, i, value) -> vnl_matrixF

        Parameters
        ----------
        i: unsigned int
        value: float

        set_column(self, j, v) -> vnl_matrixF

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorF const &

        """
        return _vnl_matrixPython.vnl_matrixF_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixF

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixF

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

        set_row(self, i, value) -> vnl_matrixF

        Parameters
        ----------
        i: unsigned int
        value: float

        set_row(self, i, arg1) -> vnl_matrixF

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorF const &

        """
        return _vnl_matrixPython.vnl_matrixF_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixF

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixF &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorF

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorF

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixF

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixF_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixF

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixF_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixF

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixF

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorF"""
        return _vnl_matrixPython.vnl_matrixF_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorF"""
        return _vnl_matrixPython.vnl_matrixF_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorF"""
        return _vnl_matrixPython.vnl_matrixF_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixF"""
        return _vnl_matrixPython.vnl_matrixF_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixF

        Parameters
        ----------
        row: unsigned int
        value: float

        """
        return _vnl_matrixPython.vnl_matrixF_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixF

        Parameters
        ----------
        col: unsigned int
        value: float

        """
        return _vnl_matrixPython.vnl_matrixF_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixF &

        """
        return _vnl_matrixPython.vnl_matrixF_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_fro_norm(self)

    def rms(self):
        r"""rms(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_rms(self)

    def min_value(self):
        r"""min_value(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_min_value(self)

    def max_value(self):
        r"""max_value(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixF_arg_max(self)

    def mean(self):
        r"""mean(self) -> float"""
        return _vnl_matrixPython.vnl_matrixF_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixF_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixF_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixF_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixF_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixF_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixF_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixF_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixF_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixF_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> float const
        data_array(self) -> float **
        """
        return _vnl_matrixPython.vnl_matrixF_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixF const &

        """
        return _vnl_matrixPython.vnl_matrixF___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixF__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixF_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixF_set_size(self, r, c)

# Register vnl_matrixF in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixF_swigregister(vnl_matrixF)
class vnl_matrixLD(object):
    r"""Proxy of C++ vnl_matrixLD class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixLD
        __init__(self, r, c) -> vnl_matrixLD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixLD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: long double const &

        __init__(self, r, c, t) -> vnl_matrixLD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixLD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: long double const *

        __init__(self, data_block, r, c) -> vnl_matrixLD

        Parameters
        ----------
        data_block: long double const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: vnl_matrixLD const &

        """
        _vnl_matrixPython.vnl_matrixLD_swiginit(self, _vnl_matrixPython.new_vnl_matrixLD(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixLD

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: long double const &

        """
        return _vnl_matrixPython.vnl_matrixLD_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> long double const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: long double const &

        """
        return _vnl_matrixPython.vnl_matrixLD_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: long double const &

        """
        return _vnl_matrixPython.vnl_matrixLD_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixLD

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

        """
        return _vnl_matrixPython.vnl_matrixLD_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixLD

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

        """
        return _vnl_matrixPython.vnl_matrixLD_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixLD

        Parameters
        ----------
        d: long double const *

        """
        return _vnl_matrixPython.vnl_matrixLD_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixLD_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixLD___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixLD

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

        __iadd__(self, arg0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixLD

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

        __imul__(self, rhs) -> vnl_matrixLD

        Parameters
        ----------
        rhs: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixLD___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixLD

        Parameters
        ----------
        rhs: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixLD

        Parameters
        ----------
        rhs: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixLD

        Parameters
        ----------
        rhs: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixLD

        Parameters
        ----------
        arg0: vnl_matrixLD const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixLD

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

        set_column(self, i, value) -> vnl_matrixLD

        Parameters
        ----------
        i: unsigned int
        value: long double

        set_column(self, j, v) -> vnl_matrixLD

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixLD

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixLD

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

        set_row(self, i, value) -> vnl_matrixLD

        Parameters
        ----------
        i: unsigned int
        value: long double

        set_row(self, i, arg1) -> vnl_matrixLD

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixLD

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixLD &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorLD

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorLD

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixLD

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixLD_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixLD

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixLD_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixLD

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixLD

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorLD"""
        return _vnl_matrixPython.vnl_matrixLD_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorLD"""
        return _vnl_matrixPython.vnl_matrixLD_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorLD"""
        return _vnl_matrixPython.vnl_matrixLD_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixLD"""
        return _vnl_matrixPython.vnl_matrixLD_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixLD

        Parameters
        ----------
        row: unsigned int
        value: long double

        """
        return _vnl_matrixPython.vnl_matrixLD_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixLD

        Parameters
        ----------
        col: unsigned int
        value: long double

        """
        return _vnl_matrixPython.vnl_matrixLD_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixLD &

        """
        return _vnl_matrixPython.vnl_matrixLD_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_fro_norm(self)

    def rms(self):
        r"""rms(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_rms(self)

    def min_value(self):
        r"""min_value(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixLD_arg_max(self)

    def mean(self):
        r"""mean(self) -> long double"""
        return _vnl_matrixPython.vnl_matrixLD_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixLD_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixLD_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixLD_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixLD_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixLD_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixLD_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixLD_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixLD_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixLD_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> long double const
        data_array(self) -> long double **
        """
        return _vnl_matrixPython.vnl_matrixLD_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixLD const &

        """
        return _vnl_matrixPython.vnl_matrixLD___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixLD__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixLD_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixLD_set_size(self, r, c)

# Register vnl_matrixLD in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixLD_swigregister(vnl_matrixLD)
class vnl_matrixSC(object):
    r"""Proxy of C++ vnl_matrixSC class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixSC
        __init__(self, r, c) -> vnl_matrixSC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixSC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: signed char const &

        __init__(self, r, c, t) -> vnl_matrixSC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixSC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: signed char const *

        __init__(self, data_block, r, c) -> vnl_matrixSC

        Parameters
        ----------
        data_block: signed char const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: vnl_matrixSC const &

        """
        _vnl_matrixPython.vnl_matrixSC_swiginit(self, _vnl_matrixPython.new_vnl_matrixSC(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixSC

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: signed char const &

        """
        return _vnl_matrixPython.vnl_matrixSC_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> signed char const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: signed char const &

        """
        return _vnl_matrixPython.vnl_matrixSC_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: signed char const &

        """
        return _vnl_matrixPython.vnl_matrixSC_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixSC

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

        """
        return _vnl_matrixPython.vnl_matrixSC_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixSC

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

        """
        return _vnl_matrixPython.vnl_matrixSC_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixSC

        Parameters
        ----------
        d: signed char const *

        """
        return _vnl_matrixPython.vnl_matrixSC_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSC_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSC___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixSC

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

        __iadd__(self, arg0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixSC

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

        __imul__(self, rhs) -> vnl_matrixSC

        Parameters
        ----------
        rhs: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSC___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixSC

        Parameters
        ----------
        rhs: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixSC

        Parameters
        ----------
        rhs: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixSC

        Parameters
        ----------
        rhs: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixSC

        Parameters
        ----------
        arg0: vnl_matrixSC const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixSC

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

        set_column(self, i, value) -> vnl_matrixSC

        Parameters
        ----------
        i: unsigned int
        value: signed char

        set_column(self, j, v) -> vnl_matrixSC

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixSC

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixSC

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

        set_row(self, i, value) -> vnl_matrixSC

        Parameters
        ----------
        i: unsigned int
        value: signed char

        set_row(self, i, arg1) -> vnl_matrixSC

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixSC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixSC &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorSC

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorSC

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixSC

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSC_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixSC

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSC_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixSC

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixSC

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorSC"""
        return _vnl_matrixPython.vnl_matrixSC_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorSC"""
        return _vnl_matrixPython.vnl_matrixSC_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorSC"""
        return _vnl_matrixPython.vnl_matrixSC_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixSC"""
        return _vnl_matrixPython.vnl_matrixSC_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixSC

        Parameters
        ----------
        row: unsigned int
        value: signed char

        """
        return _vnl_matrixPython.vnl_matrixSC_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixSC

        Parameters
        ----------
        col: unsigned int
        value: signed char

        """
        return _vnl_matrixPython.vnl_matrixSC_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixSC &

        """
        return _vnl_matrixPython.vnl_matrixSC_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixSC_rms(self)

    def min_value(self):
        r"""min_value(self) -> signed char"""
        return _vnl_matrixPython.vnl_matrixSC_min_value(self)

    def max_value(self):
        r"""max_value(self) -> signed char"""
        return _vnl_matrixPython.vnl_matrixSC_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSC_arg_max(self)

    def mean(self):
        r"""mean(self) -> signed char"""
        return _vnl_matrixPython.vnl_matrixSC_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSC_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSC_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSC_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSC_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSC_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSC_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixSC_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSC_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSC_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> signed char const
        data_array(self) -> signed char **
        """
        return _vnl_matrixPython.vnl_matrixSC_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixSC const &

        """
        return _vnl_matrixPython.vnl_matrixSC___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixSC__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixSC_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSC_set_size(self, r, c)

# Register vnl_matrixSC in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixSC_swigregister(vnl_matrixSC)
class vnl_matrixSI(object):
    r"""Proxy of C++ vnl_matrixSI class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixSI
        __init__(self, r, c) -> vnl_matrixSI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixSI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: int const &

        __init__(self, r, c, t) -> vnl_matrixSI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixSI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: int const *

        __init__(self, data_block, r, c) -> vnl_matrixSI

        Parameters
        ----------
        data_block: int const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: vnl_matrixSI const &

        """
        _vnl_matrixPython.vnl_matrixSI_swiginit(self, _vnl_matrixPython.new_vnl_matrixSI(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixSI

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: int const &

        """
        return _vnl_matrixPython.vnl_matrixSI_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> int const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: int const &

        """
        return _vnl_matrixPython.vnl_matrixSI_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: int const &

        """
        return _vnl_matrixPython.vnl_matrixSI_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixSI

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

        """
        return _vnl_matrixPython.vnl_matrixSI_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixSI

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

        """
        return _vnl_matrixPython.vnl_matrixSI_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixSI

        Parameters
        ----------
        d: int const *

        """
        return _vnl_matrixPython.vnl_matrixSI_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSI_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSI___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixSI

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

        __iadd__(self, arg0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixSI

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

        __imul__(self, rhs) -> vnl_matrixSI

        Parameters
        ----------
        rhs: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSI___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixSI

        Parameters
        ----------
        rhs: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixSI

        Parameters
        ----------
        rhs: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixSI

        Parameters
        ----------
        rhs: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixSI

        Parameters
        ----------
        arg0: vnl_matrixSI const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixSI

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

        set_column(self, i, value) -> vnl_matrixSI

        Parameters
        ----------
        i: unsigned int
        value: int

        set_column(self, j, v) -> vnl_matrixSI

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixSI

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixSI

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

        set_row(self, i, value) -> vnl_matrixSI

        Parameters
        ----------
        i: unsigned int
        value: int

        set_row(self, i, arg1) -> vnl_matrixSI

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixSI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixSI &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorSI

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorSI

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixSI

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSI_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixSI

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSI_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixSI

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixSI

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorSI"""
        return _vnl_matrixPython.vnl_matrixSI_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorSI"""
        return _vnl_matrixPython.vnl_matrixSI_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorSI"""
        return _vnl_matrixPython.vnl_matrixSI_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixSI"""
        return _vnl_matrixPython.vnl_matrixSI_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixSI

        Parameters
        ----------
        row: unsigned int
        value: int

        """
        return _vnl_matrixPython.vnl_matrixSI_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixSI

        Parameters
        ----------
        col: unsigned int
        value: int

        """
        return _vnl_matrixPython.vnl_matrixSI_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixSI &

        """
        return _vnl_matrixPython.vnl_matrixSI_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_rms(self)

    def min_value(self):
        r"""min_value(self) -> int"""
        return _vnl_matrixPython.vnl_matrixSI_min_value(self)

    def max_value(self):
        r"""max_value(self) -> int"""
        return _vnl_matrixPython.vnl_matrixSI_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSI_arg_max(self)

    def mean(self):
        r"""mean(self) -> int"""
        return _vnl_matrixPython.vnl_matrixSI_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSI_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSI_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSI_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSI_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSI_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSI_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixSI_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSI_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSI_read_ascii(self, s)

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

    def data_array(self, *args):
        r"""
        data_array(self) -> int const
        data_array(self) -> int **
        """
        return _vnl_matrixPython.vnl_matrixSI_data_array(self, *args)

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

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

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

        Parameters
        ----------
        rhs: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixSI const &

        """
        return _vnl_matrixPython.vnl_matrixSI___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixSI__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixSI_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSI_set_size(self, r, c)

# Register vnl_matrixSI in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixSI_swigregister(vnl_matrixSI)
class vnl_matrixSL(object):
    r"""Proxy of C++ vnl_matrixSL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixSL
        __init__(self, r, c) -> vnl_matrixSL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixSL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: long const &

        __init__(self, r, c, t) -> vnl_matrixSL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixSL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: long const *

        __init__(self, data_block, r, c) -> vnl_matrixSL

        Parameters
        ----------
        data_block: long const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: vnl_matrixSL const &

        """
        _vnl_matrixPython.vnl_matrixSL_swiginit(self, _vnl_matrixPython.new_vnl_matrixSL(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixSL

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: long const &

        """
        return _vnl_matrixPython.vnl_matrixSL_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> long const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: long const &

        """
        return _vnl_matrixPython.vnl_matrixSL_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: long const &

        """
        return _vnl_matrixPython.vnl_matrixSL_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: vnl_vectorSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: long const *

        """
        return _vnl_matrixPython.vnl_matrixSL_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixSL

        Parameters
        ----------
        d: long const *

        """
        return _vnl_matrixPython.vnl_matrixSL_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSL_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSL___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixSL

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

        __iadd__(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixSL

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

        __imul__(self, rhs) -> vnl_matrixSL

        Parameters
        ----------
        rhs: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSL___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixSL

        Parameters
        ----------
        rhs: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixSL

        Parameters
        ----------
        rhs: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixSL

        Parameters
        ----------
        rhs: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixSL

        Parameters
        ----------
        arg0: vnl_matrixSL const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixSL

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

        set_column(self, i, value) -> vnl_matrixSL

        Parameters
        ----------
        i: unsigned int
        value: long

        set_column(self, j, v) -> vnl_matrixSL

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixSL

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixSL

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

        set_row(self, i, value) -> vnl_matrixSL

        Parameters
        ----------
        i: unsigned int
        value: long

        set_row(self, i, arg1) -> vnl_matrixSL

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixSL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixSL &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorSL

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorSL

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixSL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSL_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixSL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSL_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixSL

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixSL

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorSL"""
        return _vnl_matrixPython.vnl_matrixSL_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorSL"""
        return _vnl_matrixPython.vnl_matrixSL_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorSL"""
        return _vnl_matrixPython.vnl_matrixSL_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixSL"""
        return _vnl_matrixPython.vnl_matrixSL_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixSL

        Parameters
        ----------
        row: unsigned int
        value: long

        """
        return _vnl_matrixPython.vnl_matrixSL_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixSL

        Parameters
        ----------
        col: unsigned int
        value: long

        """
        return _vnl_matrixPython.vnl_matrixSL_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixSL &

        """
        return _vnl_matrixPython.vnl_matrixSL_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixSL_rms(self)

    def min_value(self):
        r"""min_value(self) -> long"""
        return _vnl_matrixPython.vnl_matrixSL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long"""
        return _vnl_matrixPython.vnl_matrixSL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSL_arg_max(self)

    def mean(self):
        r"""mean(self) -> long"""
        return _vnl_matrixPython.vnl_matrixSL_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSL_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSL_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSL_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSL_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSL_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSL_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixSL_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSL_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSL_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> long const
        data_block(self) -> long *
        """
        return _vnl_matrixPython.vnl_matrixSL_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> long const
        data_array(self) -> long **
        """
        return _vnl_matrixPython.vnl_matrixSL_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> long
        begin(self) -> long const *
        """
        return _vnl_matrixPython.vnl_matrixSL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> long
        end(self) -> long const *
        """
        return _vnl_matrixPython.vnl_matrixSL_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixSL const &

        """
        return _vnl_matrixPython.vnl_matrixSL___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixSL__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixSL_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSL_set_size(self, r, c)

# Register vnl_matrixSL in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixSL_swigregister(vnl_matrixSL)
class vnl_matrixSLL(object):
    r"""Proxy of C++ vnl_matrixSLL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixSLL
        __init__(self, r, c) -> vnl_matrixSLL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixSLL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: long long const &

        __init__(self, r, c, t) -> vnl_matrixSLL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixSLL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: long long const *

        __init__(self, data_block, r, c) -> vnl_matrixSLL

        Parameters
        ----------
        data_block: long long const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: vnl_matrixSLL const &

        """
        _vnl_matrixPython.vnl_matrixSLL_swiginit(self, _vnl_matrixPython.new_vnl_matrixSLL(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixSLL

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: long long const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> long long const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: long long const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: long long const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: vnl_vectorSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: long long const *

        """
        return _vnl_matrixPython.vnl_matrixSLL_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixSLL

        Parameters
        ----------
        d: long long const *

        """
        return _vnl_matrixPython.vnl_matrixSLL_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSLL_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSLL___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixSLL

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

        __iadd__(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixSLL

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

        __imul__(self, rhs) -> vnl_matrixSLL

        Parameters
        ----------
        rhs: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSLL___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixSLL

        Parameters
        ----------
        rhs: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixSLL

        Parameters
        ----------
        rhs: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixSLL

        Parameters
        ----------
        rhs: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixSLL

        Parameters
        ----------
        arg0: vnl_matrixSLL const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixSLL

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

        set_column(self, i, value) -> vnl_matrixSLL

        Parameters
        ----------
        i: unsigned int
        value: long long

        set_column(self, j, v) -> vnl_matrixSLL

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixSLL

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixSLL

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

        set_row(self, i, value) -> vnl_matrixSLL

        Parameters
        ----------
        i: unsigned int
        value: long long

        set_row(self, i, arg1) -> vnl_matrixSLL

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixSLL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixSLL &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorSLL

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorSLL

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixSLL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixSLL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixSLL

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixSLL

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixSLL"""
        return _vnl_matrixPython.vnl_matrixSLL_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixSLL

        Parameters
        ----------
        row: unsigned int
        value: long long

        """
        return _vnl_matrixPython.vnl_matrixSLL_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixSLL

        Parameters
        ----------
        col: unsigned int
        value: long long

        """
        return _vnl_matrixPython.vnl_matrixSLL_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixSLL &

        """
        return _vnl_matrixPython.vnl_matrixSLL_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixSLL_rms(self)

    def min_value(self):
        r"""min_value(self) -> long long"""
        return _vnl_matrixPython.vnl_matrixSLL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> long long"""
        return _vnl_matrixPython.vnl_matrixSLL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSLL_arg_max(self)

    def mean(self):
        r"""mean(self) -> long long"""
        return _vnl_matrixPython.vnl_matrixSLL_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSLL_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSLL_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSLL_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSLL_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSLL_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSLL_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixSLL_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSLL_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSLL_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> long long const
        data_block(self) -> long long *
        """
        return _vnl_matrixPython.vnl_matrixSLL_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> long long const
        data_array(self) -> long long **
        """
        return _vnl_matrixPython.vnl_matrixSLL_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> long long
        begin(self) -> long long const *
        """
        return _vnl_matrixPython.vnl_matrixSLL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> long long
        end(self) -> long long const *
        """
        return _vnl_matrixPython.vnl_matrixSLL_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixSLL const &

        """
        return _vnl_matrixPython.vnl_matrixSLL___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixSLL__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixSLL_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSLL_set_size(self, r, c)

# Register vnl_matrixSLL in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixSLL_swigregister(vnl_matrixSLL)
class vnl_matrixSS(object):
    r"""Proxy of C++ vnl_matrixSS class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixSS
        __init__(self, r, c) -> vnl_matrixSS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixSS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: short const &

        __init__(self, r, c, t) -> vnl_matrixSS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixSS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: short const *

        __init__(self, data_block, r, c) -> vnl_matrixSS

        Parameters
        ----------
        data_block: short const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: vnl_matrixSS const &

        """
        _vnl_matrixPython.vnl_matrixSS_swiginit(self, _vnl_matrixPython.new_vnl_matrixSS(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixSS

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: short const &

        """
        return _vnl_matrixPython.vnl_matrixSS_put(self, r, c, arg2)

    def get(self, r, c):
        r"""
        get(self, r, c) -> short

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_get(self, r, c)

    def __call__(self, *args):
        r"""
        __call__(self, r, c) -> short

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> short const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: short const &

        """
        return _vnl_matrixPython.vnl_matrixSS_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: short const &

        """
        return _vnl_matrixPython.vnl_matrixSS_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: vnl_vectorSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: short const *

        """
        return _vnl_matrixPython.vnl_matrixSS_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixSS

        Parameters
        ----------
        d: short const *

        """
        return _vnl_matrixPython.vnl_matrixSS_set(self, d)

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

        Parameters
        ----------
        arg0: short *

        """
        return _vnl_matrixPython.vnl_matrixSS_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSS___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixSS

        Parameters
        ----------
        value: short

        __iadd__(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___iadd__(self, *args)

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

        Parameters
        ----------
        value: short

        __isub__(self, arg0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixSS

        Parameters
        ----------
        value: short

        __imul__(self, rhs) -> vnl_matrixSS

        Parameters
        ----------
        rhs: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixSS___truediv__(self, *args)
    __div__ = __truediv__



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

        Parameters
        ----------
        v: short const &

        __add__(self, rhs) -> vnl_matrixSS

        Parameters
        ----------
        rhs: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___add__(self, *args)

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

        Parameters
        ----------
        v: short const &

        __sub__(self, rhs) -> vnl_matrixSS

        Parameters
        ----------
        rhs: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___sub__(self, *args)

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

        Parameters
        ----------
        v: short const &

        __mul__(self, rhs) -> vnl_matrixSS

        Parameters
        ----------
        rhs: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixSS

        Parameters
        ----------
        arg0: vnl_matrixSS const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixSS

        Parameters
        ----------
        i: unsigned int
        v: short const *

        set_column(self, i, value) -> vnl_matrixSS

        Parameters
        ----------
        i: unsigned int
        value: short

        set_column(self, j, v) -> vnl_matrixSS

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixSS

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixSS

        Parameters
        ----------
        i: unsigned int
        v: short const *

        set_row(self, i, value) -> vnl_matrixSS

        Parameters
        ----------
        i: unsigned int
        value: short

        set_row(self, i, arg1) -> vnl_matrixSS

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixSS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixSS &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorSS

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorSS

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixSS

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSS_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixSS

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixSS_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixSS

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixSS

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorSS"""
        return _vnl_matrixPython.vnl_matrixSS_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorSS"""
        return _vnl_matrixPython.vnl_matrixSS_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorSS"""
        return _vnl_matrixPython.vnl_matrixSS_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixSS"""
        return _vnl_matrixPython.vnl_matrixSS_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixSS

        Parameters
        ----------
        row: unsigned int
        value: short

        """
        return _vnl_matrixPython.vnl_matrixSS_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixSS

        Parameters
        ----------
        col: unsigned int
        value: short

        """
        return _vnl_matrixPython.vnl_matrixSS_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixSS &

        """
        return _vnl_matrixPython.vnl_matrixSS_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixSS_rms(self)

    def min_value(self):
        r"""min_value(self) -> short"""
        return _vnl_matrixPython.vnl_matrixSS_min_value(self)

    def max_value(self):
        r"""max_value(self) -> short"""
        return _vnl_matrixPython.vnl_matrixSS_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixSS_arg_max(self)

    def mean(self):
        r"""mean(self) -> short"""
        return _vnl_matrixPython.vnl_matrixSS_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSS_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSS_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixSS_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSS_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSS_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixSS_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixSS_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSS_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixSS_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> short const
        data_block(self) -> short *
        """
        return _vnl_matrixPython.vnl_matrixSS_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> short const
        data_array(self) -> short **
        """
        return _vnl_matrixPython.vnl_matrixSS_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> short
        begin(self) -> short const *
        """
        return _vnl_matrixPython.vnl_matrixSS_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> short
        end(self) -> short const *
        """
        return _vnl_matrixPython.vnl_matrixSS_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixSS const &

        """
        return _vnl_matrixPython.vnl_matrixSS___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixSS__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixSS_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixSS_set_size(self, r, c)

# Register vnl_matrixSS in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixSS_swigregister(vnl_matrixSS)
class vnl_matrixUC(object):
    r"""Proxy of C++ vnl_matrixUC class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixUC
        __init__(self, r, c) -> vnl_matrixUC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixUC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: unsigned char const &

        __init__(self, r, c, t) -> vnl_matrixUC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixUC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: unsigned char const *

        __init__(self, data_block, r, c) -> vnl_matrixUC

        Parameters
        ----------
        data_block: unsigned char const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: vnl_matrixUC const &

        """
        _vnl_matrixPython.vnl_matrixUC_swiginit(self, _vnl_matrixPython.new_vnl_matrixUC(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixUC

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: unsigned char const &

        """
        return _vnl_matrixPython.vnl_matrixUC_put(self, r, c, arg2)

    def get(self, r, c):
        r"""
        get(self, r, c) -> unsigned char

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_get(self, r, c)

    def __call__(self, *args):
        r"""
        __call__(self, r, c) -> unsigned char

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> unsigned char const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: unsigned char const &

        """
        return _vnl_matrixPython.vnl_matrixUC_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: unsigned char const &

        """
        return _vnl_matrixPython.vnl_matrixUC_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: vnl_vectorUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: unsigned char const *

        """
        return _vnl_matrixPython.vnl_matrixUC_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixUC

        Parameters
        ----------
        d: unsigned char const *

        """
        return _vnl_matrixPython.vnl_matrixUC_set(self, d)

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

        Parameters
        ----------
        arg0: unsigned char *

        """
        return _vnl_matrixPython.vnl_matrixUC_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUC___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixUC

        Parameters
        ----------
        value: unsigned char

        __iadd__(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___iadd__(self, *args)

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

        Parameters
        ----------
        value: unsigned char

        __isub__(self, arg0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixUC

        Parameters
        ----------
        value: unsigned char

        __imul__(self, rhs) -> vnl_matrixUC

        Parameters
        ----------
        rhs: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUC___truediv__(self, *args)
    __div__ = __truediv__



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

        Parameters
        ----------
        v: unsigned char const &

        __add__(self, rhs) -> vnl_matrixUC

        Parameters
        ----------
        rhs: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___add__(self, *args)

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

        Parameters
        ----------
        v: unsigned char const &

        __sub__(self, rhs) -> vnl_matrixUC

        Parameters
        ----------
        rhs: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___sub__(self, *args)

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

        Parameters
        ----------
        v: unsigned char const &

        __mul__(self, rhs) -> vnl_matrixUC

        Parameters
        ----------
        rhs: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixUC

        Parameters
        ----------
        arg0: vnl_matrixUC const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixUC

        Parameters
        ----------
        i: unsigned int
        v: unsigned char const *

        set_column(self, i, value) -> vnl_matrixUC

        Parameters
        ----------
        i: unsigned int
        value: unsigned char

        set_column(self, j, v) -> vnl_matrixUC

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixUC

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixUC

        Parameters
        ----------
        i: unsigned int
        v: unsigned char const *

        set_row(self, i, value) -> vnl_matrixUC

        Parameters
        ----------
        i: unsigned int
        value: unsigned char

        set_row(self, i, arg1) -> vnl_matrixUC

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixUC

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixUC &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorUC

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorUC

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixUC

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUC_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixUC

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUC_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixUC

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixUC

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorUC"""
        return _vnl_matrixPython.vnl_matrixUC_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorUC"""
        return _vnl_matrixPython.vnl_matrixUC_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorUC"""
        return _vnl_matrixPython.vnl_matrixUC_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixUC"""
        return _vnl_matrixPython.vnl_matrixUC_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixUC

        Parameters
        ----------
        row: unsigned int
        value: unsigned char

        """
        return _vnl_matrixPython.vnl_matrixUC_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixUC

        Parameters
        ----------
        col: unsigned int
        value: unsigned char

        """
        return _vnl_matrixPython.vnl_matrixUC_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixUC &

        """
        return _vnl_matrixPython.vnl_matrixUC_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUC_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned char"""
        return _vnl_matrixPython.vnl_matrixUC_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUC_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUC_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUC_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUC_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUC_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUC_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixUC_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUC_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUC_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned char const
        data_block(self) -> unsigned char *
        """
        return _vnl_matrixPython.vnl_matrixUC_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> unsigned char const
        data_array(self) -> unsigned char **
        """
        return _vnl_matrixPython.vnl_matrixUC_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned char
        begin(self) -> unsigned char const *
        """
        return _vnl_matrixPython.vnl_matrixUC_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned char
        end(self) -> unsigned char const *
        """
        return _vnl_matrixPython.vnl_matrixUC_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixUC const &

        """
        return _vnl_matrixPython.vnl_matrixUC___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixUC__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixUC_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUC_set_size(self, r, c)

# Register vnl_matrixUC in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixUC_swigregister(vnl_matrixUC)
class vnl_matrixUI(object):
    r"""Proxy of C++ vnl_matrixUI class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixUI
        __init__(self, r, c) -> vnl_matrixUI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixUI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: unsigned int const &

        __init__(self, r, c, t) -> vnl_matrixUI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixUI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: unsigned int const *

        __init__(self, data_block, r, c) -> vnl_matrixUI

        Parameters
        ----------
        data_block: unsigned int const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: vnl_matrixUI const &

        """
        _vnl_matrixPython.vnl_matrixUI_swiginit(self, _vnl_matrixPython.new_vnl_matrixUI(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixUI

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: unsigned int const &

        """
        return _vnl_matrixPython.vnl_matrixUI_put(self, r, c, arg2)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_get(self, r, c)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> unsigned int const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: unsigned int const &

        """
        return _vnl_matrixPython.vnl_matrixUI_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: unsigned int const &

        """
        return _vnl_matrixPython.vnl_matrixUI_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: vnl_vectorUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixUI

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

        """
        return _vnl_matrixPython.vnl_matrixUI_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixUI

        Parameters
        ----------
        d: unsigned int const *

        """
        return _vnl_matrixPython.vnl_matrixUI_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUI_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUI___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixUI

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

        __iadd__(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___iadd__(self, *args)

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

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

        __isub__(self, arg0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixUI

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

        __imul__(self, rhs) -> vnl_matrixUI

        Parameters
        ----------
        rhs: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUI___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixUI

        Parameters
        ----------
        rhs: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixUI

        Parameters
        ----------
        rhs: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixUI

        Parameters
        ----------
        rhs: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixUI

        Parameters
        ----------
        arg0: vnl_matrixUI const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixUI

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

        set_column(self, i, value) -> vnl_matrixUI

        Parameters
        ----------
        i: unsigned int
        value: unsigned int

        set_column(self, j, v) -> vnl_matrixUI

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixUI

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixUI

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

        set_row(self, i, value) -> vnl_matrixUI

        Parameters
        ----------
        i: unsigned int
        value: unsigned int

        set_row(self, i, arg1) -> vnl_matrixUI

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixUI

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixUI &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorUI

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorUI

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixUI

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUI_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixUI

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUI_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixUI

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixUI

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorUI"""
        return _vnl_matrixPython.vnl_matrixUI_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorUI"""
        return _vnl_matrixPython.vnl_matrixUI_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorUI"""
        return _vnl_matrixPython.vnl_matrixUI_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixUI"""
        return _vnl_matrixPython.vnl_matrixUI_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixUI

        Parameters
        ----------
        row: unsigned int
        value: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixUI

        Parameters
        ----------
        col: unsigned int
        value: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixUI &

        """
        return _vnl_matrixPython.vnl_matrixUI_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUI_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUI_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUI_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUI_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUI_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUI_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUI_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixUI_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUI_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUI_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned int const
        data_block(self) -> unsigned int *
        """
        return _vnl_matrixPython.vnl_matrixUI_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> unsigned int const
        data_array(self) -> unsigned int **
        """
        return _vnl_matrixPython.vnl_matrixUI_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned int
        begin(self) -> unsigned int const *
        """
        return _vnl_matrixPython.vnl_matrixUI_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned int
        end(self) -> unsigned int const *
        """
        return _vnl_matrixPython.vnl_matrixUI_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixUI const &

        """
        return _vnl_matrixPython.vnl_matrixUI___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixUI__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixUI_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUI_set_size(self, r, c)

# Register vnl_matrixUI in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixUI_swigregister(vnl_matrixUI)
class vnl_matrixUL(object):
    r"""Proxy of C++ vnl_matrixUL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixUL
        __init__(self, r, c) -> vnl_matrixUL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixUL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: unsigned long const &

        __init__(self, r, c, t) -> vnl_matrixUL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixUL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: unsigned long const *

        __init__(self, data_block, r, c) -> vnl_matrixUL

        Parameters
        ----------
        data_block: unsigned long const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixUL

        Parameters
        ----------
        arg0: vnl_matrixUL const &

        """
        _vnl_matrixPython.vnl_matrixUL_swiginit(self, _vnl_matrixPython.new_vnl_matrixUL(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixUL

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: unsigned long const &

        """
        return _vnl_matrixPython.vnl_matrixUL_put(self, r, c, arg2)

    def get(self, r, c):
        r"""
        get(self, r, c) -> unsigned long

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_get(self, r, c)

    def __call__(self, *args):
        r"""
        __call__(self, r, c) -> unsigned long

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> unsigned long const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixUL

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

        """
        return _vnl_matrixPython.vnl_matrixUL_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixUL

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

        """
        return _vnl_matrixPython.vnl_matrixUL_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixUL

        Parameters
        ----------
        arg0: vnl_vectorUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixUL

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

        """
        return _vnl_matrixPython.vnl_matrixUL_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixUL

        Parameters
        ----------
        d: unsigned long const *

        """
        return _vnl_matrixPython.vnl_matrixUL_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUL_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUL___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixUL

        Parameters
        ----------
        value: unsigned long

        __iadd__(self, arg0) -> vnl_matrixUL

        Parameters
        ----------
        arg0: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___iadd__(self, *args)

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

        Parameters
        ----------
        value: unsigned long

        __isub__(self, arg0) -> vnl_matrixUL

        Parameters
        ----------
        arg0: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixUL

        Parameters
        ----------
        value: unsigned long

        __imul__(self, rhs) -> vnl_matrixUL

        Parameters
        ----------
        rhs: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUL___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixUL

        Parameters
        ----------
        rhs: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixUL

        Parameters
        ----------
        rhs: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixUL

        Parameters
        ----------
        rhs: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixUL

        Parameters
        ----------
        arg0: vnl_matrixUL const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixUL

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

        set_column(self, i, value) -> vnl_matrixUL

        Parameters
        ----------
        i: unsigned int
        value: unsigned long

        set_column(self, j, v) -> vnl_matrixUL

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixUL

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixUL

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

        set_row(self, i, value) -> vnl_matrixUL

        Parameters
        ----------
        i: unsigned int
        value: unsigned long

        set_row(self, i, arg1) -> vnl_matrixUL

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixUL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixUL &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorUL

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorUL

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixUL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUL_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixUL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUL_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixUL

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixUL

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorUL"""
        return _vnl_matrixPython.vnl_matrixUL_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorUL"""
        return _vnl_matrixPython.vnl_matrixUL_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorUL"""
        return _vnl_matrixPython.vnl_matrixUL_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixUL"""
        return _vnl_matrixPython.vnl_matrixUL_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixUL

        Parameters
        ----------
        row: unsigned int
        value: unsigned long

        """
        return _vnl_matrixPython.vnl_matrixUL_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixUL

        Parameters
        ----------
        col: unsigned int
        value: unsigned long

        """
        return _vnl_matrixPython.vnl_matrixUL_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixUL &

        """
        return _vnl_matrixPython.vnl_matrixUL_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUL_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned long"""
        return _vnl_matrixPython.vnl_matrixUL_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUL_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUL_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUL_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUL_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUL_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUL_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixUL_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUL_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUL_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned long const
        data_block(self) -> unsigned long *
        """
        return _vnl_matrixPython.vnl_matrixUL_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> unsigned long const
        data_array(self) -> unsigned long **
        """
        return _vnl_matrixPython.vnl_matrixUL_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned long
        begin(self) -> unsigned long const *
        """
        return _vnl_matrixPython.vnl_matrixUL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned long
        end(self) -> unsigned long const *
        """
        return _vnl_matrixPython.vnl_matrixUL_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixUL const &

        """
        return _vnl_matrixPython.vnl_matrixUL___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixUL__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixUL_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUL_set_size(self, r, c)

# Register vnl_matrixUL in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixUL_swigregister(vnl_matrixUL)
class vnl_matrixULL(object):
    r"""Proxy of C++ vnl_matrixULL class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixULL
        __init__(self, r, c) -> vnl_matrixULL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixULL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: unsigned long long const &

        __init__(self, r, c, t) -> vnl_matrixULL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixULL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: unsigned long long const *

        __init__(self, data_block, r, c) -> vnl_matrixULL

        Parameters
        ----------
        data_block: unsigned long long const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixULL

        Parameters
        ----------
        arg0: vnl_matrixULL const &

        """
        _vnl_matrixPython.vnl_matrixULL_swiginit(self, _vnl_matrixPython.new_vnl_matrixULL(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixULL

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: unsigned long long const &

        """
        return _vnl_matrixPython.vnl_matrixULL_put(self, r, c, arg2)

    def get(self, r, c):
        r"""
        get(self, r, c) -> unsigned long long

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_get(self, r, c)

    def __call__(self, *args):
        r"""
        __call__(self, r, c) -> unsigned long long

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> unsigned long long const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixULL

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

        """
        return _vnl_matrixPython.vnl_matrixULL_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixULL

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

        """
        return _vnl_matrixPython.vnl_matrixULL_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixULL

        Parameters
        ----------
        arg0: vnl_vectorULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixULL

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

        """
        return _vnl_matrixPython.vnl_matrixULL_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixULL

        Parameters
        ----------
        d: unsigned long long const *

        """
        return _vnl_matrixPython.vnl_matrixULL_set(self, d)

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

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

        """
        return _vnl_matrixPython.vnl_matrixULL_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixULL___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixULL

        Parameters
        ----------
        value: unsigned long long

        __iadd__(self, arg0) -> vnl_matrixULL

        Parameters
        ----------
        arg0: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___iadd__(self, *args)

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

        Parameters
        ----------
        value: unsigned long long

        __isub__(self, arg0) -> vnl_matrixULL

        Parameters
        ----------
        arg0: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixULL

        Parameters
        ----------
        value: unsigned long long

        __imul__(self, rhs) -> vnl_matrixULL

        Parameters
        ----------
        rhs: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixULL___truediv__(self, *args)
    __div__ = __truediv__



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

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

        __add__(self, rhs) -> vnl_matrixULL

        Parameters
        ----------
        rhs: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___add__(self, *args)

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

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

        __sub__(self, rhs) -> vnl_matrixULL

        Parameters
        ----------
        rhs: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___sub__(self, *args)

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

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

        __mul__(self, rhs) -> vnl_matrixULL

        Parameters
        ----------
        rhs: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixULL

        Parameters
        ----------
        arg0: vnl_matrixULL const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixULL

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

        set_column(self, i, value) -> vnl_matrixULL

        Parameters
        ----------
        i: unsigned int
        value: unsigned long long

        set_column(self, j, v) -> vnl_matrixULL

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixULL

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixULL

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

        set_row(self, i, value) -> vnl_matrixULL

        Parameters
        ----------
        i: unsigned int
        value: unsigned long long

        set_row(self, i, arg1) -> vnl_matrixULL

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixULL

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixULL &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorULL

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorULL

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixULL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixULL_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixULL

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixULL_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixULL

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixULL

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorULL"""
        return _vnl_matrixPython.vnl_matrixULL_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorULL"""
        return _vnl_matrixPython.vnl_matrixULL_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorULL"""
        return _vnl_matrixPython.vnl_matrixULL_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixULL"""
        return _vnl_matrixPython.vnl_matrixULL_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixULL

        Parameters
        ----------
        row: unsigned int
        value: unsigned long long

        """
        return _vnl_matrixPython.vnl_matrixULL_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixULL

        Parameters
        ----------
        col: unsigned int
        value: unsigned long long

        """
        return _vnl_matrixPython.vnl_matrixULL_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixULL &

        """
        return _vnl_matrixPython.vnl_matrixULL_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixULL_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned long long"""
        return _vnl_matrixPython.vnl_matrixULL_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixULL_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixULL_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixULL_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixULL_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixULL_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixULL_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixULL_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixULL_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixULL_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned long long const
        data_block(self) -> unsigned long long *
        """
        return _vnl_matrixPython.vnl_matrixULL_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> unsigned long long const
        data_array(self) -> unsigned long long **
        """
        return _vnl_matrixPython.vnl_matrixULL_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned long long
        begin(self) -> unsigned long long const *
        """
        return _vnl_matrixPython.vnl_matrixULL_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned long long
        end(self) -> unsigned long long const *
        """
        return _vnl_matrixPython.vnl_matrixULL_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixULL const &

        """
        return _vnl_matrixPython.vnl_matrixULL___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixULL__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixULL_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixULL_set_size(self, r, c)

# Register vnl_matrixULL in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixULL_swigregister(vnl_matrixULL)
class vnl_matrixUS(object):
    r"""Proxy of C++ vnl_matrixUS class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> vnl_matrixUS
        __init__(self, r, c) -> vnl_matrixUS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __init__(self, r, c, v0) -> vnl_matrixUS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        v0: unsigned short const &

        __init__(self, r, c, t) -> vnl_matrixUS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        t: vnl_matrix_type

        __init__(self, r, c, n, values) -> vnl_matrixUS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        n: unsigned int
        values: unsigned short const *

        __init__(self, data_block, r, c) -> vnl_matrixUS

        Parameters
        ----------
        data_block: unsigned short const *
        r: unsigned int
        c: unsigned int

        __init__(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: vnl_matrixUS const &

        """
        _vnl_matrixPython.vnl_matrixUS_swiginit(self, _vnl_matrixPython.new_vnl_matrixUS(*args))
    __swig_destroy__ = _vnl_matrixPython.delete_vnl_matrixUS

    def size(self):
        r"""size(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_size(self)

    def rows(self):
        r"""rows(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_rows(self)

    def cols(self):
        r"""cols(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_cols(self)

    def columns(self):
        r"""columns(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_columns(self)

    def put(self, r, c, arg2):
        r"""
        put(self, r, c, arg2)

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        arg2: unsigned short const &

        """
        return _vnl_matrixPython.vnl_matrixUS_put(self, r, c, arg2)

    def get(self, r, c):
        r"""
        get(self, r, c) -> unsigned short

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_get(self, r, c)

    def __call__(self, *args):
        r"""
        __call__(self, r, c) -> unsigned short

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        __call__(self, r, c) -> unsigned short const &

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS___call__(self, *args)

    def fill(self, arg0):
        r"""
        fill(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: unsigned short const &

        """
        return _vnl_matrixPython.vnl_matrixUS_fill(self, arg0)

    def fill_diagonal(self, arg0):
        r"""
        fill_diagonal(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: unsigned short const &

        """
        return _vnl_matrixPython.vnl_matrixUS_fill_diagonal(self, arg0)

    def set_diagonal(self, arg0):
        r"""
        set_diagonal(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: vnl_vectorUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS_set_diagonal(self, arg0)

    def copy_in(self, arg0):
        r"""
        copy_in(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: unsigned short const *

        """
        return _vnl_matrixPython.vnl_matrixUS_copy_in(self, arg0)

    def set(self, d):
        r"""
        set(self, d) -> vnl_matrixUS

        Parameters
        ----------
        d: unsigned short const *

        """
        return _vnl_matrixPython.vnl_matrixUS_set(self, d)

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

        Parameters
        ----------
        arg0: unsigned short *

        """
        return _vnl_matrixPython.vnl_matrixUS_copy_out(self, arg0)

    def __itruediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUS___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, *args):
        r"""
        __iadd__(self, value) -> vnl_matrixUS

        Parameters
        ----------
        value: unsigned short

        __iadd__(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___iadd__(self, *args)

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

        Parameters
        ----------
        value: unsigned short

        __isub__(self, arg0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___isub__(self, *args)

    def __imul__(self, *args):
        r"""
        __imul__(self, value) -> vnl_matrixUS

        Parameters
        ----------
        value: unsigned short

        __imul__(self, rhs) -> vnl_matrixUS

        Parameters
        ----------
        rhs: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___imul__(self, *args)

    def __neg__(self):
        r"""__neg__(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS___neg__(self)

    def __truediv__(self, *args):
        return _vnl_matrixPython.vnl_matrixUS___truediv__(self, *args)
    __div__ = __truediv__



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

        Parameters
        ----------
        v: unsigned short const &

        __add__(self, rhs) -> vnl_matrixUS

        Parameters
        ----------
        rhs: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___add__(self, *args)

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

        Parameters
        ----------
        v: unsigned short const &

        __sub__(self, rhs) -> vnl_matrixUS

        Parameters
        ----------
        rhs: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___sub__(self, *args)

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

        Parameters
        ----------
        v: unsigned short const &

        __mul__(self, rhs) -> vnl_matrixUS

        Parameters
        ----------
        rhs: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___mul__(self, *args)

    def transpose(self):
        r"""transpose(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_transpose(self)

    def conjugate_transpose(self):
        r"""conjugate_transpose(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_conjugate_transpose(self)

    def update(self, arg0, top=0, left=0):
        r"""
        update(self, arg0, top=0, left=0) -> vnl_matrixUS

        Parameters
        ----------
        arg0: vnl_matrixUS const &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_update(self, arg0, top, left)

    def set_column(self, *args):
        r"""
        set_column(self, i, v) -> vnl_matrixUS

        Parameters
        ----------
        i: unsigned int
        v: unsigned short const *

        set_column(self, i, value) -> vnl_matrixUS

        Parameters
        ----------
        i: unsigned int
        value: unsigned short

        set_column(self, j, v) -> vnl_matrixUS

        Parameters
        ----------
        j: unsigned int
        v: vnl_vectorUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS_set_column(self, *args)

    def set_columns(self, starting_column, M):
        r"""
        set_columns(self, starting_column, M) -> vnl_matrixUS

        Parameters
        ----------
        starting_column: unsigned int
        M: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS_set_columns(self, starting_column, M)

    def set_row(self, *args):
        r"""
        set_row(self, i, v) -> vnl_matrixUS

        Parameters
        ----------
        i: unsigned int
        v: unsigned short const *

        set_row(self, i, value) -> vnl_matrixUS

        Parameters
        ----------
        i: unsigned int
        value: unsigned short

        set_row(self, i, arg1) -> vnl_matrixUS

        Parameters
        ----------
        i: unsigned int
        arg1: vnl_vectorUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS_set_row(self, *args)

    def extract(self, *args):
        r"""
        extract(self, r, c, top=0, left=0) -> vnl_matrixUS

        Parameters
        ----------
        r: unsigned int
        c: unsigned int
        top: unsigned int
        left: unsigned int

        extract(self, sub_matrix, top=0, left=0)

        Parameters
        ----------
        sub_matrix: vnl_matrixUS &
        top: unsigned int
        left: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_extract(self, *args)

    def get_row(self, r):
        r"""
        get_row(self, r) -> vnl_vectorUS

        Parameters
        ----------
        r: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_get_row(self, r)

    def get_column(self, c):
        r"""
        get_column(self, c) -> vnl_vectorUS

        Parameters
        ----------
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_get_column(self, c)

    def get_rows(self, i):
        r"""
        get_rows(self, i) -> vnl_matrixUS

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUS_get_rows(self, i)

    def get_columns(self, i):
        r"""
        get_columns(self, i) -> vnl_matrixUS

        Parameters
        ----------
        i: vnl_vectorUI

        """
        return _vnl_matrixPython.vnl_matrixUS_get_columns(self, i)

    def get_n_rows(self, rowstart, n):
        r"""
        get_n_rows(self, rowstart, n) -> vnl_matrixUS

        Parameters
        ----------
        rowstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_get_n_rows(self, rowstart, n)

    def get_n_columns(self, colstart, n):
        r"""
        get_n_columns(self, colstart, n) -> vnl_matrixUS

        Parameters
        ----------
        colstart: unsigned int
        n: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_get_n_columns(self, colstart, n)

    def get_diagonal(self):
        r"""get_diagonal(self) -> vnl_vectorUS"""
        return _vnl_matrixPython.vnl_matrixUS_get_diagonal(self)

    def flatten_row_major(self):
        r"""flatten_row_major(self) -> vnl_vectorUS"""
        return _vnl_matrixPython.vnl_matrixUS_flatten_row_major(self)

    def flatten_column_major(self):
        r"""flatten_column_major(self) -> vnl_vectorUS"""
        return _vnl_matrixPython.vnl_matrixUS_flatten_column_major(self)

    def set_identity(self):
        r"""set_identity(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_set_identity(self)

    def inplace_transpose(self):
        r"""inplace_transpose(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_inplace_transpose(self)

    def flipud(self):
        r"""flipud(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_flipud(self)

    def fliplr(self):
        r"""fliplr(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_fliplr(self)

    def normalize_rows(self):
        r"""normalize_rows(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_normalize_rows(self)

    def normalize_columns(self):
        r"""normalize_columns(self) -> vnl_matrixUS"""
        return _vnl_matrixPython.vnl_matrixUS_normalize_columns(self)

    def scale_row(self, row, value):
        r"""
        scale_row(self, row, value) -> vnl_matrixUS

        Parameters
        ----------
        row: unsigned int
        value: unsigned short

        """
        return _vnl_matrixPython.vnl_matrixUS_scale_row(self, row, value)

    def scale_column(self, col, value):
        r"""
        scale_column(self, col, value) -> vnl_matrixUS

        Parameters
        ----------
        col: unsigned int
        value: unsigned short

        """
        return _vnl_matrixPython.vnl_matrixUS_scale_column(self, col, value)

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

        Parameters
        ----------
        that: vnl_matrixUS &

        """
        return _vnl_matrixPython.vnl_matrixUS_swap(self, that)

    def array_one_norm(self):
        r"""array_one_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_array_one_norm(self)

    def array_two_norm(self):
        r"""array_two_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_array_two_norm(self)

    def array_inf_norm(self):
        r"""array_inf_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_array_inf_norm(self)

    def absolute_value_sum(self):
        r"""absolute_value_sum(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_absolute_value_sum(self)

    def absolute_value_max(self):
        r"""absolute_value_max(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_absolute_value_max(self)

    def operator_one_norm(self):
        r"""operator_one_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_operator_one_norm(self)

    def operator_inf_norm(self):
        r"""operator_inf_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_operator_inf_norm(self)

    def frobenius_norm(self):
        r"""frobenius_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_frobenius_norm(self)

    def fro_norm(self):
        r"""fro_norm(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_fro_norm(self)

    def rms(self):
        r"""rms(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_rms(self)

    def min_value(self):
        r"""min_value(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_min_value(self)

    def max_value(self):
        r"""max_value(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_max_value(self)

    def arg_min(self):
        r"""arg_min(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_arg_min(self)

    def arg_max(self):
        r"""arg_max(self) -> unsigned int"""
        return _vnl_matrixPython.vnl_matrixUS_arg_max(self)

    def mean(self):
        r"""mean(self) -> unsigned short"""
        return _vnl_matrixPython.vnl_matrixUS_mean(self)

    def empty(self):
        r"""empty(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUS_empty(self)

    def is_identity(self, *args):
        r"""
        is_identity(self) -> bool
        is_identity(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUS_is_identity(self, *args)

    def is_zero(self, *args):
        r"""
        is_zero(self) -> bool
        is_zero(self, tol) -> bool

        Parameters
        ----------
        tol: double

        """
        return _vnl_matrixPython.vnl_matrixUS_is_zero(self, *args)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUS_is_equal(self, rhs, tol)

    def is_finite(self):
        r"""is_finite(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUS_is_finite(self)

    def has_nans(self):
        r"""has_nans(self) -> bool"""
        return _vnl_matrixPython.vnl_matrixUS_has_nans(self)

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

        Parameters
        ----------
        arg0: unsigned int
        arg1: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_assert_size(self, arg0, arg1)

    def assert_finite(self):
        r"""assert_finite(self)"""
        return _vnl_matrixPython.vnl_matrixUS_assert_finite(self)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUS_read(s)

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

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

        """
        return _vnl_matrixPython.vnl_matrixUS_read_ascii(self, s)

    def data_block(self, *args):
        r"""
        data_block(self) -> unsigned short const
        data_block(self) -> unsigned short *
        """
        return _vnl_matrixPython.vnl_matrixUS_data_block(self, *args)

    def data_array(self, *args):
        r"""
        data_array(self) -> unsigned short const
        data_array(self) -> unsigned short **
        """
        return _vnl_matrixPython.vnl_matrixUS_data_array(self, *args)

    def begin(self, *args):
        r"""
        begin(self) -> unsigned short
        begin(self) -> unsigned short const *
        """
        return _vnl_matrixPython.vnl_matrixUS_begin(self, *args)

    def end(self, *args):
        r"""
        end(self) -> unsigned short
        end(self) -> unsigned short const *
        """
        return _vnl_matrixPython.vnl_matrixUS_end(self, *args)

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

        Parameters
        ----------
        rhs: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS_operator_eq(self, rhs)

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

        Parameters
        ----------
        that: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___eq__(self, that)

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

        Parameters
        ----------
        that: vnl_matrixUS const &

        """
        return _vnl_matrixPython.vnl_matrixUS___ne__(self, that)

    def _print(self, os):
        r"""
        _print(self, os)

        Parameters
        ----------
        os: std::basic_ostream< char,std::char_traits< char > > &

        """
        return _vnl_matrixPython.vnl_matrixUS__print(self, os)

    def clear(self):
        r"""clear(self)"""
        return _vnl_matrixPython.vnl_matrixUS_clear(self)

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

        Parameters
        ----------
        r: unsigned int
        c: unsigned int

        """
        return _vnl_matrixPython.vnl_matrixUS_set_size(self, r, c)

# Register vnl_matrixUS in _vnl_matrixPython:
_vnl_matrixPython.vnl_matrixUS_swigregister(vnl_matrixUS)

