# Copyright 2014-2017 Intel Corporation
# All Rights Reserved.
#
# If this  software was obtained  under the  Intel Simplified  Software License,
# the following terms apply:
#
# The source code,  information  and material  ("Material") contained  herein is
# owned by Intel Corporation or its  suppliers or licensors,  and  title to such
# Material remains with Intel  Corporation or its  suppliers or  licensors.  The
# Material  contains  proprietary  information  of  Intel or  its suppliers  and
# licensors.  The Material is protected by  worldwide copyright  laws and treaty
# provisions.  No part  of  the  Material   may  be  used,  copied,  reproduced,
# modified, published,  uploaded, posted, transmitted,  distributed or disclosed
# in any way without Intel's prior express written permission.  No license under
# any patent,  copyright or other  intellectual property rights  in the Material
# is granted to  or  conferred  upon  you,  either   expressly,  by implication,
# inducement,  estoppel  or  otherwise.  Any  license   under such  intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing,  you may not remove or alter this
# notice or  any  other  notice   embedded  in  Materials  by  Intel  or Intel's
# suppliers or licensors in any way.
#
#
# If this  software  was obtained  under the  Apache License,  Version  2.0 (the
# "License"), the following terms apply:
#
# You may  not use this  file except  in compliance  with  the License.  You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless  required  by   applicable  law  or  agreed  to  in  writing,  software
# distributed under the License  is distributed  on an  "AS IS"  BASIS,  WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the   License  for the   specific  language   governing   permissions  and
# limitations under the License.


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_data_management', [dirname(__file__)])
        except ImportError:
            import _data_management
            return _data_management
        if fp is not None:
            try:
                _mod = imp.load_module('_data_management', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _data_management = swig_import_helper()
    del swig_import_helper
else:
    import _data_management
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


import numpy

import daal
class SerializationIface(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SerializationIface, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SerializationIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_SerializationIface
    __del__ = lambda self: None

    def serialize(self, archive):
        return _data_management.SerializationIface_serialize(self, archive)

    def deserialize(self, archive):
        return _data_management.SerializationIface_deserialize(self, archive)

    def getSerializationTag(self):
        return _data_management.SerializationIface_getSerializationTag(self)
SerializationIface_swigregister = _data_management.SerializationIface_swigregister
SerializationIface_swigregister(SerializationIface)

class SerializationDesc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SerializationDesc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SerializationDesc, name)
    __repr__ = _swig_repr

    def __init__(self, func, tag):
        this = _data_management.new_SerializationDesc(func, tag)
        try:
            self.this.append(this)
        except:
            self.this = this

    def tag(self):
        return _data_management.SerializationDesc_tag(self)

    def creator(self):
        return _data_management.SerializationDesc_creator(self)

    def next(self):
        return _data_management.SerializationDesc_next(self)
    __swig_getmethods__["first"] = lambda x: _data_management.SerializationDesc_first
    if _newclass:
        first = staticmethod(_data_management.SerializationDesc_first)
    __swig_destroy__ = _data_management.delete_SerializationDesc
    __del__ = lambda self: None
SerializationDesc_swigregister = _data_management.SerializationDesc_swigregister
SerializationDesc_swigregister(SerializationDesc)

def SerializationDesc_first():
    return _data_management.SerializationDesc_first()
SerializationDesc_first = _data_management.SerializationDesc_first

class DataBlock(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataBlock, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataBlock
    __del__ = lambda self: None

    def getSize(self):
        return _data_management.DataBlock_getSize(self)

    def __init__(self, *args):
        this = _data_management.new_DataBlock(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getArray(self):
        return _data_management.DataBlock_getArray(self)

    def setArray(self, outBlock):
        return _data_management.DataBlock_setArray(self, outBlock)
DataBlock_swigregister = _data_management.DataBlock_swigregister
DataBlock_swigregister(DataBlock)

import daal.services
import daal.data_management.data_feature_utils

_data_management.defaultLevel_swigconstant(_data_management)
defaultLevel = _data_management.defaultLevel

_data_management.level0_swigconstant(_data_management)
level0 = _data_management.level0

_data_management.level1_swigconstant(_data_management)
level1 = _data_management.level1

_data_management.level2_swigconstant(_data_management)
level2 = _data_management.level2

_data_management.level3_swigconstant(_data_management)
level3 = _data_management.level3

_data_management.level4_swigconstant(_data_management)
level4 = _data_management.level4

_data_management.level5_swigconstant(_data_management)
level5 = _data_management.level5

_data_management.level6_swigconstant(_data_management)
level6 = _data_management.level6

_data_management.level7_swigconstant(_data_management)
level7 = _data_management.level7

_data_management.level8_swigconstant(_data_management)
level8 = _data_management.level8

_data_management.level9_swigconstant(_data_management)
level9 = _data_management.level9

_data_management.lastCompressionLevel_swigconstant(_data_management)
lastCompressionLevel = _data_management.lastCompressionLevel

_data_management.zlib_swigconstant(_data_management)
zlib = _data_management.zlib

_data_management.lzo_swigconstant(_data_management)
lzo = _data_management.lzo

_data_management.rle_swigconstant(_data_management)
rle = _data_management.rle

_data_management.bzip2_swigconstant(_data_management)
bzip2 = _data_management.bzip2
class CompressionParameter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompressionParameter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompressionParameter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["level"] = _data_management.CompressionParameter_level_set
    __swig_getmethods__["level"] = _data_management.CompressionParameter_level_get
    if _newclass:
        level = _swig_property(_data_management.CompressionParameter_level_get, _data_management.CompressionParameter_level_set)

    def __init__(self, *args):
        this = _data_management.new_CompressionParameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CompressionParameter
    __del__ = lambda self: None
CompressionParameter_swigregister = _data_management.CompressionParameter_swigregister
CompressionParameter_swigregister(CompressionParameter)

class CompressionIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompressionIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompressionIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.CompressionIface_setInputDataBlock(self, inBlock, offset)

    def isOutputDataBlockFull(self):
        return _data_management.CompressionIface_isOutputDataBlockFull(self)

    def getUsedOutputDataBlockSize(self):
        return _data_management.CompressionIface_getUsedOutputDataBlockSize(self)

    def run(self, outBlock, offset):
        return _data_management.CompressionIface_run(self, outBlock, offset)
    __swig_destroy__ = _data_management.delete_CompressionIface
    __del__ = lambda self: None
CompressionIface_swigregister = _data_management.CompressionIface_swigregister
CompressionIface_swigregister(CompressionIface)

class Compression(CompressionIface):
    __swig_setmethods__ = {}
    for _s in [CompressionIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compression, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressionIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compression, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Compression_setInputDataBlock(self, inBlock, offset)

    def isOutputDataBlockFull(self):
        return _data_management.Compression_isOutputDataBlockFull(self)

    def getUsedOutputDataBlockSize(self):
        return _data_management.Compression_getUsedOutputDataBlockSize(self)

    def run(self, outBlock, offset):
        return _data_management.Compression_run(self, outBlock, offset)
    __swig_destroy__ = _data_management.delete_Compression
    __del__ = lambda self: None

    def checkInputParams(self, inBlock):
        return _data_management.Compression_checkInputParams(self, inBlock)

    def checkOutputParams(self, outBlock):
        return _data_management.Compression_checkOutputParams(self, outBlock)

    def getErrors(self):
        return _data_management.Compression_getErrors(self)
Compression_swigregister = _data_management.Compression_swigregister
Compression_swigregister(Compression)

class CompressorImpl(Compression):
    __swig_setmethods__ = {}
    for _s in [Compression]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompressorImpl, name, value)
    __swig_getmethods__ = {}
    for _s in [Compression]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompressorImpl, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_CompressorImpl
    __del__ = lambda self: None
CompressorImpl_swigregister = _data_management.CompressorImpl_swigregister
CompressorImpl_swigregister(CompressorImpl)

class DecompressorImpl(Compression):
    __swig_setmethods__ = {}
    for _s in [Compression]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DecompressorImpl, name, value)
    __swig_getmethods__ = {}
    for _s in [Compression]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DecompressorImpl, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DecompressorImpl
    __del__ = lambda self: None
DecompressorImpl_swigregister = _data_management.DecompressorImpl_swigregister
DecompressorImpl_swigregister(DecompressorImpl)

class CompressionStream(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompressionStream, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompressionStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_CompressionStream(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CompressionStream
    __del__ = lambda self: None

    def __lshift__(self, inBlock):
        return _data_management.CompressionStream___lshift__(self, inBlock)

    def getCompressedBlocksCollection(self):
        return _data_management.CompressionStream_getCompressedBlocksCollection(self)

    def getCompressedDataSize(self):
        return _data_management.CompressionStream_getCompressedDataSize(self)

    def copyCompressedArray(self, *args):
        return _data_management.CompressionStream_copyCompressedArray(self, *args)

    def getErrors(self):
        return _data_management.CompressionStream_getErrors(self)

    def push_back(self, inBlock):
        return _data_management.CompressionStream_push_back(self, inBlock)
CompressionStream_swigregister = _data_management.CompressionStream_swigregister
CompressionStream_swigregister(CompressionStream)

class DecompressionStream(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DecompressionStream, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DecompressionStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_DecompressionStream(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DecompressionStream
    __del__ = lambda self: None

    def __lshift__(self, inBlock):
        return _data_management.DecompressionStream___lshift__(self, inBlock)

    def getDecompressedBlocksCollection(self):
        return _data_management.DecompressionStream_getDecompressedBlocksCollection(self)

    def getDecompressedDataSize(self):
        return _data_management.DecompressionStream_getDecompressedDataSize(self)

    def copyDecompressedArray(self, *args):
        return _data_management.DecompressionStream_copyDecompressedArray(self, *args)

    def getErrors(self):
        return _data_management.DecompressionStream_getErrors(self)

    def push_back(self, inBlock):
        return _data_management.DecompressionStream_push_back(self, inBlock)
DecompressionStream_swigregister = _data_management.DecompressionStream_swigregister
DecompressionStream_swigregister(DecompressionStream)

class Bzip2CompressionParameter(CompressionParameter):
    __swig_setmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bzip2CompressionParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Bzip2CompressionParameter, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_Bzip2CompressionParameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Bzip2CompressionParameter
    __del__ = lambda self: None
Bzip2CompressionParameter_swigregister = _data_management.Bzip2CompressionParameter_swigregister
Bzip2CompressionParameter_swigregister(Bzip2CompressionParameter)

class LzoCompressionParameter(CompressionParameter):
    __swig_setmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LzoCompressionParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LzoCompressionParameter, name)
    __repr__ = _swig_repr

    def __init__(self, _preHeadBytes=0, _postHeadBytes=0):
        this = _data_management.new_LzoCompressionParameter(_preHeadBytes, _postHeadBytes)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_LzoCompressionParameter
    __del__ = lambda self: None
    __swig_setmethods__["preHeadBytes"] = _data_management.LzoCompressionParameter_preHeadBytes_set
    __swig_getmethods__["preHeadBytes"] = _data_management.LzoCompressionParameter_preHeadBytes_get
    if _newclass:
        preHeadBytes = _swig_property(_data_management.LzoCompressionParameter_preHeadBytes_get, _data_management.LzoCompressionParameter_preHeadBytes_set)
    __swig_setmethods__["postHeadBytes"] = _data_management.LzoCompressionParameter_postHeadBytes_set
    __swig_getmethods__["postHeadBytes"] = _data_management.LzoCompressionParameter_postHeadBytes_get
    if _newclass:
        postHeadBytes = _swig_property(_data_management.LzoCompressionParameter_postHeadBytes_get, _data_management.LzoCompressionParameter_postHeadBytes_set)
LzoCompressionParameter_swigregister = _data_management.LzoCompressionParameter_swigregister
LzoCompressionParameter_swigregister(LzoCompressionParameter)

class RleCompressionParameter(CompressionParameter):
    __swig_setmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RleCompressionParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RleCompressionParameter, name)
    __repr__ = _swig_repr

    def __init__(self, _isBlockHeader=1):
        this = _data_management.new_RleCompressionParameter(_isBlockHeader)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_RleCompressionParameter
    __del__ = lambda self: None
    __swig_setmethods__["isBlockHeader"] = _data_management.RleCompressionParameter_isBlockHeader_set
    __swig_getmethods__["isBlockHeader"] = _data_management.RleCompressionParameter_isBlockHeader_get
    if _newclass:
        isBlockHeader = _swig_property(_data_management.RleCompressionParameter_isBlockHeader_get, _data_management.RleCompressionParameter_isBlockHeader_set)
RleCompressionParameter_swigregister = _data_management.RleCompressionParameter_swigregister
RleCompressionParameter_swigregister(RleCompressionParameter)

class ZlibCompressionParameter(CompressionParameter):
    __swig_setmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ZlibCompressionParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressionParameter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ZlibCompressionParameter, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_ZlibCompressionParameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_ZlibCompressionParameter
    __del__ = lambda self: None
    __swig_setmethods__["gzHeader"] = _data_management.ZlibCompressionParameter_gzHeader_set
    __swig_getmethods__["gzHeader"] = _data_management.ZlibCompressionParameter_gzHeader_get
    if _newclass:
        gzHeader = _swig_property(_data_management.ZlibCompressionParameter_gzHeader_get, _data_management.ZlibCompressionParameter_gzHeader_set)
ZlibCompressionParameter_swigregister = _data_management.ZlibCompressionParameter_swigregister
ZlibCompressionParameter_swigregister(ZlibCompressionParameter)


_data_management.readOnly_swigconstant(_data_management)
readOnly = _data_management.readOnly

_data_management.writeOnly_swigconstant(_data_management)
writeOnly = _data_management.writeOnly

_data_management.readWrite_swigconstant(_data_management)
readWrite = _data_management.readWrite
class DataArchiveIface(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataArchiveIface, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataArchiveIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataArchiveIface
    __del__ = lambda self: None

    def write(self, ptr):
        return _data_management.DataArchiveIface_write(self, ptr)

    def read(self, ptr):
        return _data_management.DataArchiveIface_read(self, ptr)

    def getSizeOfArchive(self):
        return _data_management.DataArchiveIface_getSizeOfArchive(self)

    def getArchiveAsString(self):
        return _data_management.DataArchiveIface_getArchiveAsString(self)

    def copyArchiveToArray(self, ptr):
        return _data_management.DataArchiveIface_copyArchiveToArray(self, ptr)

    def setMajorVersion(self, majorVersion):
        return _data_management.DataArchiveIface_setMajorVersion(self, majorVersion)

    def setMinorVersion(self, minorVersion):
        return _data_management.DataArchiveIface_setMinorVersion(self, minorVersion)

    def setUpdateVersion(self, updateVersion):
        return _data_management.DataArchiveIface_setUpdateVersion(self, updateVersion)

    def getMajorVersion(self):
        return _data_management.DataArchiveIface_getMajorVersion(self)

    def getMinorVersion(self):
        return _data_management.DataArchiveIface_getMinorVersion(self)

    def getUpdateVersion(self):
        return _data_management.DataArchiveIface_getUpdateVersion(self)
DataArchiveIface_swigregister = _data_management.DataArchiveIface_swigregister
DataArchiveIface_swigregister(DataArchiveIface)

class DataArchiveImpl(DataArchiveIface):
    __swig_setmethods__ = {}
    for _s in [DataArchiveIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataArchiveImpl, name, value)
    __swig_getmethods__ = {}
    for _s in [DataArchiveIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataArchiveImpl, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataArchiveImpl
    __del__ = lambda self: None

    def setMajorVersion(self, majorVersion):
        return _data_management.DataArchiveImpl_setMajorVersion(self, majorVersion)

    def setMinorVersion(self, minorVersion):
        return _data_management.DataArchiveImpl_setMinorVersion(self, minorVersion)

    def setUpdateVersion(self, updateVersion):
        return _data_management.DataArchiveImpl_setUpdateVersion(self, updateVersion)

    def getMajorVersion(self):
        return _data_management.DataArchiveImpl_getMajorVersion(self)

    def getMinorVersion(self):
        return _data_management.DataArchiveImpl_getMinorVersion(self)

    def getUpdateVersion(self):
        return _data_management.DataArchiveImpl_getUpdateVersion(self)
DataArchiveImpl_swigregister = _data_management.DataArchiveImpl_swigregister
DataArchiveImpl_swigregister(DataArchiveImpl)

class DataArchive(DataArchiveImpl):
    __swig_setmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataArchive, name, value)
    __swig_getmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataArchive, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_DataArchive(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DataArchive
    __del__ = lambda self: None

    def write(self, ptr):
        return _data_management.DataArchive_write(self, ptr)

    def read(self, ptr):
        return _data_management.DataArchive_read(self, ptr)

    def getSizeOfArchive(self):
        return _data_management.DataArchive_getSizeOfArchive(self)

    def getArchiveAsString(self):
        return _data_management.DataArchive_getArchiveAsString(self)

    def copyArchiveToArray(self, ptr):
        return _data_management.DataArchive_copyArchiveToArray(self, ptr)

    def getErrors(self):
        return _data_management.DataArchive_getErrors(self)

    def getArchiveAsArray(self):
        return _data_management.DataArchive_getArchiveAsArray(self)
DataArchive_swigregister = _data_management.DataArchive_swigregister
DataArchive_swigregister(DataArchive)

class CompressedDataArchive(DataArchiveImpl):
    __swig_setmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompressedDataArchive, name, value)
    __swig_getmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompressedDataArchive, name)
    __repr__ = _swig_repr

    def __init__(self, compressor):
        this = _data_management.new_CompressedDataArchive(compressor)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CompressedDataArchive
    __del__ = lambda self: None

    def write(self, ptr):
        return _data_management.CompressedDataArchive_write(self, ptr)

    def read(self, ptr):
        return _data_management.CompressedDataArchive_read(self, ptr)

    def getSizeOfArchive(self):
        return _data_management.CompressedDataArchive_getSizeOfArchive(self)

    def getArchiveAsString(self):
        return _data_management.CompressedDataArchive_getArchiveAsString(self)

    def copyArchiveToArray(self, ptr):
        return _data_management.CompressedDataArchive_copyArchiveToArray(self, ptr)

    def getErrors(self):
        return _data_management.CompressedDataArchive_getErrors(self)
CompressedDataArchive_swigregister = _data_management.CompressedDataArchive_swigregister
CompressedDataArchive_swigregister(CompressedDataArchive)

class DecompressedDataArchive(DataArchiveImpl):
    __swig_setmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DecompressedDataArchive, name, value)
    __swig_getmethods__ = {}
    for _s in [DataArchiveImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DecompressedDataArchive, name)
    __repr__ = _swig_repr

    def __init__(self, decompressor):
        this = _data_management.new_DecompressedDataArchive(decompressor)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DecompressedDataArchive
    __del__ = lambda self: None

    def write(self, ptr):
        return _data_management.DecompressedDataArchive_write(self, ptr)

    def read(self, ptr):
        return _data_management.DecompressedDataArchive_read(self, ptr)

    def getSizeOfArchive(self):
        return _data_management.DecompressedDataArchive_getSizeOfArchive(self)

    def getArchiveAsString(self):
        return _data_management.DecompressedDataArchive_getArchiveAsString(self)

    def copyArchiveToArray(self, ptr):
        return _data_management.DecompressedDataArchive_copyArchiveToArray(self, ptr)

    def getErrors(self):
        return _data_management.DecompressedDataArchive_getErrors(self)
DecompressedDataArchive_swigregister = _data_management.DecompressedDataArchive_swigregister
DecompressedDataArchive_swigregister(DecompressedDataArchive)

class InputDataArchive(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputDataArchive, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputDataArchive, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_InputDataArchive(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_InputDataArchive
    __del__ = lambda self: None

    def archiveHeader(self):
        return _data_management.InputDataArchive_archiveHeader(self)

    def archiveFooter(self):
        return _data_management.InputDataArchive_archiveFooter(self)

    def segmentHeader(self, tag=0):
        return _data_management.InputDataArchive_segmentHeader(self, tag)

    def segmentFooter(self):
        return _data_management.InputDataArchive_segmentFooter(self)

    def setSingleObj(self, ptr):
        return _data_management.InputDataArchive_setSingleObj(self, ptr)

    def getSizeOfArchive(self):
        return _data_management.InputDataArchive_getSizeOfArchive(self)

    def getArchiveAsString(self):
        return _data_management.InputDataArchive_getArchiveAsString(self)

    def copyArchiveToArray(self, ptr):
        return _data_management.InputDataArchive_copyArchiveToArray(self, ptr)

    def getDataArchive(self):
        return _data_management.InputDataArchive_getDataArchive(self)

    def getErrors(self):
        return _data_management.InputDataArchive_getErrors(self)

    def getArchiveAsArray(self):
        return _data_management.InputDataArchive_getArchiveAsArray(self)
InputDataArchive_swigregister = _data_management.InputDataArchive_swigregister
InputDataArchive_swigregister(InputDataArchive)

class OutputDataArchive(daal.Base):
    __swig_setmethods__ = {}
    for _s in [daal.Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputDataArchive, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputDataArchive, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_OutputDataArchive(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_OutputDataArchive
    __del__ = lambda self: None

    def archiveHeader(self):
        return _data_management.OutputDataArchive_archiveHeader(self)

    def archiveFooter(self):
        return _data_management.OutputDataArchive_archiveFooter(self)

    def segmentHeader(self):
        return _data_management.OutputDataArchive_segmentHeader(self)

    def segmentFooter(self):
        return _data_management.OutputDataArchive_segmentFooter(self)

    def setSingleObj(self, ptr):
        return _data_management.OutputDataArchive_setSingleObj(self, ptr)

    def get(self):
        return _data_management.OutputDataArchive_get(self)

    def getMajorVersion(self):
        return _data_management.OutputDataArchive_getMajorVersion(self)

    def getMinorVersion(self):
        return _data_management.OutputDataArchive_getMinorVersion(self)

    def getUpdateVersion(self):
        return _data_management.OutputDataArchive_getUpdateVersion(self)

    def getErrors(self):
        return _data_management.OutputDataArchive_getErrors(self)
OutputDataArchive_swigregister = _data_management.OutputDataArchive_swigregister
OutputDataArchive_swigregister(OutputDataArchive)

class DataCollection(SerializationIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataCollection, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.DataCollection_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.DataCollection_serializationTag)

    def getSerializationTag(self):
        return _data_management.DataCollection_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_DataCollection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DataCollection
    __del__ = lambda self: None

    def get(self, *args):
        return _data_management.DataCollection_get(self, *args)

    def push_back(self, x):
        return _data_management.DataCollection_push_back(self, x)

    def __lshift__(self, x):
        return _data_management.DataCollection___lshift__(self, x)

    def size(self):
        return _data_management.DataCollection_size(self)

    def clear(self):
        return _data_management.DataCollection_clear(self)

    def erase(self, pos):
        return _data_management.DataCollection_erase(self, pos)

    def __getitem__(self, i):
        return _data_management.DataCollection___getitem__(self, i)

    def __setitem__(self, i, v):
        return _data_management.DataCollection___setitem__(self, i, v)
DataCollection_swigregister = _data_management.DataCollection_swigregister
DataCollection_swigregister(DataCollection)

def DataCollection_serializationTag():
    return _data_management.DataCollection_serializationTag()
DataCollection_serializationTag = _data_management.DataCollection_serializationTag

class NumericTableFeature(SerializationIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericTableFeature, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericTableFeature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["indexType"] = _data_management.NumericTableFeature_indexType_set
    __swig_getmethods__["indexType"] = _data_management.NumericTableFeature_indexType_get
    if _newclass:
        indexType = _swig_property(_data_management.NumericTableFeature_indexType_get, _data_management.NumericTableFeature_indexType_set)
    __swig_setmethods__["pmmlType"] = _data_management.NumericTableFeature_pmmlType_set
    __swig_getmethods__["pmmlType"] = _data_management.NumericTableFeature_pmmlType_get
    if _newclass:
        pmmlType = _swig_property(_data_management.NumericTableFeature_pmmlType_get, _data_management.NumericTableFeature_pmmlType_set)
    __swig_setmethods__["featureType"] = _data_management.NumericTableFeature_featureType_set
    __swig_getmethods__["featureType"] = _data_management.NumericTableFeature_featureType_get
    if _newclass:
        featureType = _swig_property(_data_management.NumericTableFeature_featureType_get, _data_management.NumericTableFeature_featureType_set)
    __swig_setmethods__["typeSize"] = _data_management.NumericTableFeature_typeSize_set
    __swig_getmethods__["typeSize"] = _data_management.NumericTableFeature_typeSize_get
    if _newclass:
        typeSize = _swig_property(_data_management.NumericTableFeature_typeSize_get, _data_management.NumericTableFeature_typeSize_set)
    __swig_setmethods__["categoryNumber"] = _data_management.NumericTableFeature_categoryNumber_set
    __swig_getmethods__["categoryNumber"] = _data_management.NumericTableFeature_categoryNumber_get
    if _newclass:
        categoryNumber = _swig_property(_data_management.NumericTableFeature_categoryNumber_get, _data_management.NumericTableFeature_categoryNumber_set)

    def __init__(self):
        this = _data_management.new_NumericTableFeature()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_NumericTableFeature
    __del__ = lambda self: None

    def getSerializationTag(self):
        return _data_management.NumericTableFeature_getSerializationTag(self)

    def getIndexType(self):
        return _data_management.NumericTableFeature_getIndexType(self)

    def setType_Float64(self):
        r"""
This function is specialized for float64"""
        return _data_management.NumericTableFeature_setType_Float64(self)


    def setType_Float32(self):
        r"""
This function is specialized for float32"""
        return _data_management.NumericTableFeature_setType_Float32(self)


    def setType_Intc(self):
        r"""
This function is specialized for intc"""
        return _data_management.NumericTableFeature_setType_Intc(self)

NumericTableFeature_swigregister = _data_management.NumericTableFeature_swigregister
NumericTableFeature_swigregister(NumericTableFeature)

class DictionaryIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DictionaryIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DictionaryIface, name)
    __repr__ = _swig_repr
    notEqual = _data_management.DictionaryIface_notEqual
    equal = _data_management.DictionaryIface_equal

    def __init__(self):
        this = _data_management.new_DictionaryIface()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DictionaryIface
    __del__ = lambda self: None
DictionaryIface_swigregister = _data_management.DictionaryIface_swigregister
DictionaryIface_swigregister(DictionaryIface)

class CategoricalFeatureDictionary(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CategoricalFeatureDictionary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CategoricalFeatureDictionary, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_CategoricalFeatureDictionary()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CategoricalFeatureDictionary
    __del__ = lambda self: None
CategoricalFeatureDictionary_swigregister = _data_management.CategoricalFeatureDictionary_swigregister
CategoricalFeatureDictionary_swigregister(CategoricalFeatureDictionary)

class DataSourceFeature(SerializationIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceFeature, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceFeature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ntFeature"] = _data_management.DataSourceFeature_ntFeature_set
    __swig_getmethods__["ntFeature"] = _data_management.DataSourceFeature_ntFeature_get
    if _newclass:
        ntFeature = _swig_property(_data_management.DataSourceFeature_ntFeature_get, _data_management.DataSourceFeature_ntFeature_set)
    __swig_setmethods__["name_length"] = _data_management.DataSourceFeature_name_length_set
    __swig_getmethods__["name_length"] = _data_management.DataSourceFeature_name_length_get
    if _newclass:
        name_length = _swig_property(_data_management.DataSourceFeature_name_length_get, _data_management.DataSourceFeature_name_length_set)
    __swig_setmethods__["name"] = _data_management.DataSourceFeature_name_set
    __swig_getmethods__["name"] = _data_management.DataSourceFeature_name_get
    if _newclass:
        name = _swig_property(_data_management.DataSourceFeature_name_get, _data_management.DataSourceFeature_name_set)
    __swig_setmethods__["cat_dict"] = _data_management.DataSourceFeature_cat_dict_set
    __swig_getmethods__["cat_dict"] = _data_management.DataSourceFeature_cat_dict_get
    if _newclass:
        cat_dict = _swig_property(_data_management.DataSourceFeature_cat_dict_get, _data_management.DataSourceFeature_cat_dict_set)

    def __init__(self):
        this = _data_management.new_DataSourceFeature()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DataSourceFeature
    __del__ = lambda self: None

    def getCategoricalDictionary(self):
        return _data_management.DataSourceFeature_getCategoricalDictionary(self)

    def setFeatureName(self, featureName):
        return _data_management.DataSourceFeature_setFeatureName(self, featureName)

    def getSerializationTag(self):
        return _data_management.DataSourceFeature_getSerializationTag(self)

    def getIndexType(self):
        return _data_management.DataSourceFeature_getIndexType(self)

    def setType_Float64(self):
        r"""
This function is specialized for float64"""
        return _data_management.DataSourceFeature_setType_Float64(self)


    def setType_Float32(self):
        r"""
This function is specialized for float32"""
        return _data_management.DataSourceFeature_setType_Float32(self)


    def setType_Intc(self):
        r"""
This function is specialized for intc"""
        return _data_management.DataSourceFeature_setType_Intc(self)

DataSourceFeature_swigregister = _data_management.DataSourceFeature_swigregister
DataSourceFeature_swigregister(DataSourceFeature)

class NumericTableIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericTableIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericTableIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_NumericTableIface
    __del__ = lambda self: None
    notAllocated = _data_management.NumericTableIface_notAllocated
    userAllocated = _data_management.NumericTableIface_userAllocated
    internallyAllocated = _data_management.NumericTableIface_internallyAllocated
    doNotAllocate = _data_management.NumericTableIface_doNotAllocate
    notAllocate = _data_management.NumericTableIface_notAllocate
    doAllocate = _data_management.NumericTableIface_doAllocate
    minimum = _data_management.NumericTableIface_minimum
    maximum = _data_management.NumericTableIface_maximum
    sum = _data_management.NumericTableIface_sum
    sumSquares = _data_management.NumericTableIface_sumSquares
    counters = _data_management.NumericTableIface_counters
    nonNormalized = _data_management.NumericTableIface_nonNormalized
    standardScoreNormalized = _data_management.NumericTableIface_standardScoreNormalized
    minMaxNormalized = _data_management.NumericTableIface_minMaxNormalized
    soa = _data_management.NumericTableIface_soa
    aos = _data_management.NumericTableIface_aos
    csrArray = _data_management.NumericTableIface_csrArray
    upperPackedSymmetricMatrix = _data_management.NumericTableIface_upperPackedSymmetricMatrix
    lowerPackedSymmetricMatrix = _data_management.NumericTableIface_lowerPackedSymmetricMatrix
    upperPackedTriangularMatrix = _data_management.NumericTableIface_upperPackedTriangularMatrix
    lowerPackedTriangularMatrix = _data_management.NumericTableIface_lowerPackedTriangularMatrix
    layout_unknown = _data_management.NumericTableIface_layout_unknown

    def setDictionary(self, ddict):
        return _data_management.NumericTableIface_setDictionary(self, ddict)

    def getDictionary(self):
        return _data_management.NumericTableIface_getDictionary(self)

    def resetDictionary(self):
        return _data_management.NumericTableIface_resetDictionary(self)

    def getFeatureType(self, feature_idx):
        return _data_management.NumericTableIface_getFeatureType(self, feature_idx)

    def getNumberOfCategories(self, feature_idx):
        return _data_management.NumericTableIface_getNumberOfCategories(self, feature_idx)

    def getDataLayout(self):
        return _data_management.NumericTableIface_getDataLayout(self)

    def resize(self, nrows):
        return _data_management.NumericTableIface_resize(self, nrows)

    def setNumberOfColumns(self, ncol):
        return _data_management.NumericTableIface_setNumberOfColumns(self, ncol)

    def setNumberOfRows(self, nrow):
        return _data_management.NumericTableIface_setNumberOfRows(self, nrow)

    def allocateDataMemory(self, *args):
        return _data_management.NumericTableIface_allocateDataMemory(self, *args)

    def freeDataMemory(self):
        return _data_management.NumericTableIface_freeDataMemory(self)

    def allocateBasicStatistics(self):
        return _data_management.NumericTableIface_allocateBasicStatistics(self)

    def check(self, description, checkDataAllocation=True):
        return _data_management.NumericTableIface_check(self, description, checkDataAllocation)
NumericTableIface_swigregister = _data_management.NumericTableIface_swigregister
NumericTableIface_swigregister(NumericTableIface)

class DenseNumericTableIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DenseNumericTableIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DenseNumericTableIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DenseNumericTableIface
    __del__ = lambda self: None

    def getBlockOfRows(self, *args):
        return _data_management.DenseNumericTableIface_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.DenseNumericTableIface_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.DenseNumericTableIface_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.DenseNumericTableIface_releaseBlockOfColumnValues(self, *args)

    def getBlockOfRowsAsDouble(self, vector_idx, vector_num):
        return _data_management.DenseNumericTableIface_getBlockOfRowsAsDouble(self, vector_idx, vector_num)

    def getBlockOfColumnValuesAsDouble(self, feature_idx, vector_idx, value_num):
        return _data_management.DenseNumericTableIface_getBlockOfColumnValuesAsDouble(self, feature_idx, vector_idx, value_num)

    def getBlockOfRowsAsFloat(self, vector_idx, vector_num):
        return _data_management.DenseNumericTableIface_getBlockOfRowsAsFloat(self, vector_idx, vector_num)

    def getBlockOfColumnValuesAsFloat(self, feature_idx, vector_idx, value_num):
        return _data_management.DenseNumericTableIface_getBlockOfColumnValuesAsFloat(self, feature_idx, vector_idx, value_num)

    def getBlockOfRowsAsInt(self, vector_idx, vector_num):
        return _data_management.DenseNumericTableIface_getBlockOfRowsAsInt(self, vector_idx, vector_num)

    def getBlockOfColumnValuesAsInt(self, feature_idx, vector_idx, value_num):
        return _data_management.DenseNumericTableIface_getBlockOfColumnValuesAsInt(self, feature_idx, vector_idx, value_num)
DenseNumericTableIface_swigregister = _data_management.DenseNumericTableIface_swigregister
DenseNumericTableIface_swigregister(DenseNumericTableIface)
cvar = _data_management.cvar
packed_mask = cvar.packed_mask

class NumericTable(SerializationIface, NumericTableIface, DenseNumericTableIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface, NumericTableIface, DenseNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, NumericTableIface, DenseNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericTable, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_NumericTable
    __del__ = lambda self: None

    def setDictionary(self, ddict):
        return _data_management.NumericTable_setDictionary(self, ddict)

    def getDictionary(self):
        return _data_management.NumericTable_getDictionary(self)

    def resetDictionary(self):
        return _data_management.NumericTable_resetDictionary(self)

    def resize(self, nrows):
        return _data_management.NumericTable_resize(self, nrows)

    def getNumberOfColumns(self):
        return _data_management.NumericTable_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.NumericTable_getNumberOfRows(self)

    def setNumberOfColumns(self, ncol):
        return _data_management.NumericTable_setNumberOfColumns(self, ncol)

    def setNumberOfRows(self, nrow):
        return _data_management.NumericTable_setNumberOfRows(self, nrow)

    def allocateDataMemory(self, *args):
        return _data_management.NumericTable_allocateDataMemory(self, *args)

    def freeDataMemory(self):
        return _data_management.NumericTable_freeDataMemory(self)

    def getDataLayout(self):
        return _data_management.NumericTable_getDataLayout(self)

    def getFeatureType(self, feature_idx):
        return _data_management.NumericTable_getFeatureType(self, feature_idx)

    def getNumberOfCategories(self, feature_idx):
        return _data_management.NumericTable_getNumberOfCategories(self, feature_idx)

    def getDataMemoryStatus(self):
        return _data_management.NumericTable_getDataMemoryStatus(self)

    def isNormalized(self, flag):
        return _data_management.NumericTable_isNormalized(self, flag)

    def setNormalizationFlag(self, flag):
        return _data_management.NumericTable_setNormalizationFlag(self, flag)

    def getErrors(self):
        return _data_management.NumericTable_getErrors(self)

    def allocateBasicStatistics(self):
        return _data_management.NumericTable_allocateBasicStatistics(self)

    def check(self, description, checkDataAllocation=True):
        return _data_management.NumericTable_check(self, description, checkDataAllocation)

    def assign(self, *args):
        return _data_management.NumericTable_assign(self, *args)
    __swig_setmethods__["basicStatistics"] = _data_management.NumericTable_basicStatistics_set
    __swig_getmethods__["basicStatistics"] = _data_management.NumericTable_basicStatistics_get
    if _newclass:
        basicStatistics = _swig_property(_data_management.NumericTable_basicStatistics_get, _data_management.NumericTable_basicStatistics_set)

    def getValue_Float64(self, *args):
        r"""
This function is specialized for float64"""
        return _data_management.NumericTable_getValue_Float64(self, *args)


    def getValue_Float32(self, *args):
        r"""
This function is specialized for float32"""
        return _data_management.NumericTable_getValue_Float32(self, *args)


    def getValue_Intc(self, *args):
        r"""
This function is specialized for intc"""
        return _data_management.NumericTable_getValue_Intc(self, *args)

NumericTable_swigregister = _data_management.NumericTable_swigregister
NumericTable_swigregister(NumericTable)

class BasicStatisticsDataCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasicStatisticsDataCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BasicStatisticsDataCollection, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_BasicStatisticsDataCollection()
        try:
            self.this.append(this)
        except:
            self.this = this

    def get(self, id):
        return _data_management.BasicStatisticsDataCollection_get(self, id)

    def set(self, id, value):
        return _data_management.BasicStatisticsDataCollection_set(self, id, value)
    __swig_destroy__ = _data_management.delete_BasicStatisticsDataCollection
    __del__ = lambda self: None
BasicStatisticsDataCollection_swigregister = _data_management.BasicStatisticsDataCollection_swigregister
BasicStatisticsDataCollection_swigregister(BasicStatisticsDataCollection)


def checkNumericTable(nt, description, unexpectedLayouts=0, expectedLayouts=0, nColumns=0, nRows=0, checkDataAllocation=True):
    return _data_management.checkNumericTable(nt, description, unexpectedLayouts, expectedLayouts, nColumns, nRows, checkDataAllocation)
checkNumericTable = _data_management.checkNumericTable
class TensorIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TensorIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    notAllocated = _data_management.TensorIface_notAllocated
    userAllocated = _data_management.TensorIface_userAllocated
    internallyAllocated = _data_management.TensorIface_internallyAllocated
    doNotAllocate = _data_management.TensorIface_doNotAllocate
    notAllocate = _data_management.TensorIface_notAllocate
    doAllocate = _data_management.TensorIface_doAllocate
    __swig_destroy__ = _data_management.delete_TensorIface
    __del__ = lambda self: None

    def setDimensions(self, *args):
        return _data_management.TensorIface_setDimensions(self, *args)

    def allocateDataMemory(self, *args):
        return _data_management.TensorIface_allocateDataMemory(self, *args)

    def freeDataMemory(self):
        return _data_management.TensorIface_freeDataMemory(self)

    def resize(self, dimensions):
        return _data_management.TensorIface_resize(self, dimensions)

    def check(self, description):
        return _data_management.TensorIface_check(self, description)

    def getSampleTensor(self, firstDimIndex):
        return _data_management.TensorIface_getSampleTensor(self, firstDimIndex)
TensorIface_swigregister = _data_management.TensorIface_swigregister
TensorIface_swigregister(TensorIface)

class TensorLayoutIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorLayoutIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TensorLayoutIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_TensorLayoutIface
    __del__ = lambda self: None

    def shuffleDimensions(self, dimsOrder):
        return _data_management.TensorLayoutIface_shuffleDimensions(self, dimsOrder)
TensorLayoutIface_swigregister = _data_management.TensorLayoutIface_swigregister
TensorLayoutIface_swigregister(TensorLayoutIface)

class TensorLayout(SerializationIface, TensorLayoutIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface, TensorLayoutIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorLayout, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, TensorLayoutIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TensorLayout, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_TensorLayout
    __del__ = lambda self: None

    def getDimensions(self):
        return _data_management.TensorLayout_getDimensions(self)
TensorLayout_swigregister = _data_management.TensorLayout_swigregister
TensorLayout_swigregister(TensorLayout)

class TensorOffsetLayout(TensorLayout):
    __swig_setmethods__ = {}
    for _s in [TensorLayout]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorOffsetLayout, name, value)
    __swig_getmethods__ = {}
    for _s in [TensorLayout]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TensorOffsetLayout, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_TensorOffsetLayout(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_TensorOffsetLayout
    __del__ = lambda self: None

    def getOffsets(self):
        return _data_management.TensorOffsetLayout_getOffsets(self)

    def getIndices(self):
        return _data_management.TensorOffsetLayout_getIndices(self)

    def isLayout(self, layout):
        return _data_management.TensorOffsetLayout_isLayout(self, layout)

    def isDefaultLayout(self):
        return _data_management.TensorOffsetLayout_isDefaultLayout(self)

    def isRawLayout(self):
        return _data_management.TensorOffsetLayout_isRawLayout(self)

    def shuffleDimensions(self, dimsOrder):
        return _data_management.TensorOffsetLayout_shuffleDimensions(self, dimsOrder)

    def sortOffsets(self):
        return _data_management.TensorOffsetLayout_sortOffsets(self)

    def getSerializationTag(self):
        return _data_management.TensorOffsetLayout_getSerializationTag(self)
TensorOffsetLayout_swigregister = _data_management.TensorOffsetLayout_swigregister
TensorOffsetLayout_swigregister(TensorOffsetLayout)

class DenseTensorIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DenseTensorIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DenseTensorIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DenseTensorIface
    __del__ = lambda self: None

    def getSubtensorEx(self, *args):
        return _data_management.DenseTensorIface_getSubtensorEx(self, *args)

    def releaseSubtensor(self, *args):
        return _data_management.DenseTensorIface_releaseSubtensor(self, *args)

    def getSubtensor(self, *args):
        return _data_management.DenseTensorIface_getSubtensor(self, *args)

    def createDefaultSubtensorLayout(self):
        return _data_management.DenseTensorIface_createDefaultSubtensorLayout(self)

    def createRawSubtensorLayout(self):
        return _data_management.DenseTensorIface_createRawSubtensorLayout(self)
DenseTensorIface_swigregister = _data_management.DenseTensorIface_swigregister
DenseTensorIface_swigregister(DenseTensorIface)

class Tensor(SerializationIface, TensorIface, DenseTensorIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface, TensorIface, DenseTensorIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tensor, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, TensorIface, DenseTensorIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tensor, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_Tensor
    __del__ = lambda self: None

    def getDataMemoryStatus(self):
        return _data_management.Tensor_getDataMemoryStatus(self)

    def getNumberOfDimensions(self):
        return _data_management.Tensor_getNumberOfDimensions(self)

    def getDimensionSize(self, dimIdx):
        return _data_management.Tensor_getDimensionSize(self, dimIdx)

    def getDimensions(self):
        return _data_management.Tensor_getDimensions(self)

    def getErrors(self):
        return _data_management.Tensor_getErrors(self)

    def getSize(self, *args):
        return _data_management.Tensor_getSize(self, *args)

    def check(self, description):
        return _data_management.Tensor_check(self, description)

    def getLayoutPtr(self):
        return _data_management.Tensor_getLayoutPtr(self)

    def allocateDataMemory(self, *args):
        return _data_management.Tensor_allocateDataMemory(self, *args)

    def freeDataMemory(self):
        return _data_management.Tensor_freeDataMemory(self)

    def resize(self, dimensions):
        return _data_management.Tensor_resize(self, dimensions)
Tensor_swigregister = _data_management.Tensor_swigregister
Tensor_swigregister(Tensor)


def checkTensor(tensor, description, dims=None):
    return _data_management.checkTensor(tensor, description, dims)
checkTensor = _data_management.checkTensor
class AOSNumericTable(NumericTable):
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AOSNumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AOSNumericTable, name)
    __repr__ = _swig_repr

    def __init__(self, ary):
        this = _data_management.new_AOSNumericTable(ary)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_AOSNumericTable
    __del__ = lambda self: None

    def getSerializationTag(self):
        return _data_management.AOSNumericTable_getSerializationTag(self)

    def getBlockOfRows(self, *args):
        return _data_management.AOSNumericTable_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.AOSNumericTable_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.AOSNumericTable_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.AOSNumericTable_releaseBlockOfColumnValues(self, *args)

    def allocateDataMemory(self, *args):
        return _data_management.AOSNumericTable_allocateDataMemory(self, *args)

    def freeDataMemory(self):
        return _data_management.AOSNumericTable_freeDataMemory(self)
AOSNumericTable_swigregister = _data_management.AOSNumericTable_swigregister
AOSNumericTable_swigregister(AOSNumericTable)

class SOANumericTable(NumericTable):
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SOANumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SOANumericTable, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.SOANumericTable_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.SOANumericTable_serializationTag)

    def getSerializationTag(self):
        return _data_management.SOANumericTable_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_SOANumericTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_SOANumericTable
    __del__ = lambda self: None

    def getBlockOfRows(self, *args):
        return _data_management.SOANumericTable_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.SOANumericTable_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.SOANumericTable_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.SOANumericTable_releaseBlockOfColumnValues(self, *args)

    def setDictionary(self, ddict):
        return _data_management.SOANumericTable_setDictionary(self, ddict)

    def setArray(self, ary, idx):
        return _data_management.SOANumericTable_setArray(self, ary, idx)

    def getArray(self, index):
        return _data_management.SOANumericTable_getArray(self, index)
SOANumericTable_swigregister = _data_management.SOANumericTable_swigregister
SOANumericTable_swigregister(SOANumericTable)

def SOANumericTable_serializationTag():
    return _data_management.SOANumericTable_serializationTag()
SOANumericTable_serializationTag = _data_management.SOANumericTable_serializationTag

class CSRNumericTableIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSRNumericTableIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSRNumericTableIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    zeroBased = _data_management.CSRNumericTableIface_zeroBased
    oneBased = _data_management.CSRNumericTableIface_oneBased
    __swig_destroy__ = _data_management.delete_CSRNumericTableIface
    __del__ = lambda self: None

    def getDataSize(self):
        return _data_management.CSRNumericTableIface_getDataSize(self)

    def getSparseBlock(self, *args):
        return _data_management.CSRNumericTableIface_getSparseBlock(self, *args)

    def releaseSparseBlock(self, *args):
        return _data_management.CSRNumericTableIface_releaseSparseBlock(self, *args)
CSRNumericTableIface_swigregister = _data_management.CSRNumericTableIface_swigregister
CSRNumericTableIface_swigregister(CSRNumericTableIface)

class CSRNumericTable(NumericTable, CSRNumericTableIface):
    __swig_setmethods__ = {}
    for _s in [NumericTable, CSRNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSRNumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, CSRNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSRNumericTable, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.CSRNumericTable_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.CSRNumericTable_serializationTag)

    def getSerializationTag(self):
        return _data_management.CSRNumericTable_getSerializationTag(self)
    __swig_destroy__ = _data_management.delete_CSRNumericTable
    __del__ = lambda self: None

    def resize(self, nrows):
        return _data_management.CSRNumericTable_resize(self, nrows)

    def getBlockOfRows(self, *args):
        return _data_management.CSRNumericTable_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.CSRNumericTable_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.CSRNumericTable_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.CSRNumericTable_releaseBlockOfColumnValues(self, *args)

    def getSparseBlock(self, *args):
        return _data_management.CSRNumericTable_getSparseBlock(self, *args)

    def releaseSparseBlock(self, *args):
        return _data_management.CSRNumericTable_releaseSparseBlock(self, *args)

    def allocateDataMemory(self, *args):
        return _data_management.CSRNumericTable_allocateDataMemory(self, *args)

    def getCSRIndexing(self):
        return _data_management.CSRNumericTable_getCSRIndexing(self)

    def check(self, description, checkDataAllocation=True):
        return _data_management.CSRNumericTable_check(self, description, checkDataAllocation)

    def getDataSize(self):
        return _data_management.CSRNumericTable_getDataSize(self)

    def __init__(self, *args):
        this = _data_management.new_CSRNumericTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setArrays(self, *args):
        return _data_management.CSRNumericTable_setArrays(self, *args)

    def getArrays(self):
        return _data_management.CSRNumericTable_getArrays(self)
CSRNumericTable_swigregister = _data_management.CSRNumericTable_swigregister
CSRNumericTable_swigregister(CSRNumericTable)

def CSRNumericTable_serializationTag():
    return _data_management.CSRNumericTable_serializationTag()
CSRNumericTable_serializationTag = _data_management.CSRNumericTable_serializationTag

class MergedNumericTable(NumericTable):
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MergedNumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MergedNumericTable, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.MergedNumericTable_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.MergedNumericTable_serializationTag)

    def getSerializationTag(self):
        return _data_management.MergedNumericTable_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_MergedNumericTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addNumericTable(self, table):
        return _data_management.MergedNumericTable_addNumericTable(self, table)

    def resize(self, nrow):
        return _data_management.MergedNumericTable_resize(self, nrow)

    def getDataMemoryStatus(self):
        return _data_management.MergedNumericTable_getDataMemoryStatus(self)

    def getBlockOfRows(self, *args):
        return _data_management.MergedNumericTable_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.MergedNumericTable_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.MergedNumericTable_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.MergedNumericTable_releaseBlockOfColumnValues(self, *args)

    def allocateBasicStatistics(self):
        return _data_management.MergedNumericTable_allocateBasicStatistics(self)
    __swig_destroy__ = _data_management.delete_MergedNumericTable
    __del__ = lambda self: None
MergedNumericTable_swigregister = _data_management.MergedNumericTable_swigregister
MergedNumericTable_swigregister(MergedNumericTable)

def MergedNumericTable_serializationTag():
    return _data_management.MergedNumericTable_serializationTag()
MergedNumericTable_serializationTag = _data_management.MergedNumericTable_serializationTag

class RowMergedNumericTable(NumericTable):
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RowMergedNumericTable, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RowMergedNumericTable, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.RowMergedNumericTable_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.RowMergedNumericTable_serializationTag)

    def getSerializationTag(self):
        return _data_management.RowMergedNumericTable_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_RowMergedNumericTable(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addNumericTable(self, table):
        return _data_management.RowMergedNumericTable_addNumericTable(self, table)

    def resize(self, nrows):
        return _data_management.RowMergedNumericTable_resize(self, nrows)

    def getDataMemoryStatus(self):
        return _data_management.RowMergedNumericTable_getDataMemoryStatus(self)

    def getBlockOfRows(self, *args):
        return _data_management.RowMergedNumericTable_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.RowMergedNumericTable_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.RowMergedNumericTable_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.RowMergedNumericTable_releaseBlockOfColumnValues(self, *args)
    __swig_destroy__ = _data_management.delete_RowMergedNumericTable
    __del__ = lambda self: None
RowMergedNumericTable_swigregister = _data_management.RowMergedNumericTable_swigregister
RowMergedNumericTable_swigregister(RowMergedNumericTable)

def RowMergedNumericTable_serializationTag():
    return _data_management.RowMergedNumericTable_serializationTag()
RowMergedNumericTable_serializationTag = _data_management.RowMergedNumericTable_serializationTag

class PackedArrayNumericTableIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedArrayNumericTableIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PackedArrayNumericTableIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_PackedArrayNumericTableIface
    __del__ = lambda self: None

    def getPackedArray(self, *args):
        return _data_management.PackedArrayNumericTableIface_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedArrayNumericTableIface_releasePackedArray(self, *args)
PackedArrayNumericTableIface_swigregister = _data_management.PackedArrayNumericTableIface_swigregister
PackedArrayNumericTableIface_swigregister(PackedArrayNumericTableIface)

class DataSourceIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    readyForLoad = _data_management.DataSourceIface_readyForLoad
    waitingForRows = _data_management.DataSourceIface_waitingForRows
    endOfData = _data_management.DataSourceIface_endOfData
    notReady = _data_management.DataSourceIface_notReady
    notDictionaryFromContext = _data_management.DataSourceIface_notDictionaryFromContext
    doDictionaryFromContext = _data_management.DataSourceIface_doDictionaryFromContext
    notAllocateNumericTable = _data_management.DataSourceIface_notAllocateNumericTable
    doAllocateNumericTable = _data_management.DataSourceIface_doAllocateNumericTable

    def getDictionary(self):
        return _data_management.DataSourceIface_getDictionary(self)

    def setDictionary(self, dict):
        return _data_management.DataSourceIface_setDictionary(self, dict)

    def createDictionaryFromContext(self):
        return _data_management.DataSourceIface_createDictionaryFromContext(self)

    def getStatus(self):
        return _data_management.DataSourceIface_getStatus(self)

    def getNumberOfColumns(self):
        return _data_management.DataSourceIface_getNumberOfColumns(self)

    def getNumericTableNumberOfColumns(self):
        return _data_management.DataSourceIface_getNumericTableNumberOfColumns(self)

    def getNumberOfAvailableRows(self):
        return _data_management.DataSourceIface_getNumberOfAvailableRows(self)

    def allocateNumericTable(self):
        return _data_management.DataSourceIface_allocateNumericTable(self)

    def getNumericTable(self):
        return _data_management.DataSourceIface_getNumericTable(self)

    def freeNumericTable(self):
        return _data_management.DataSourceIface_freeNumericTable(self)

    def loadDataBlock(self, *args):
        return _data_management.DataSourceIface_loadDataBlock(self, *args)
    __swig_destroy__ = _data_management.delete_DataSourceIface
    __del__ = lambda self: None
DataSourceIface_swigregister = _data_management.DataSourceIface_swigregister
DataSourceIface_swigregister(DataSourceIface)

class DataSource(DataSourceIface):
    __swig_setmethods__ = {}
    for _s in [DataSourceIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSource, name, value)
    __swig_getmethods__ = {}
    for _s in [DataSourceIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSource, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataSource
    __del__ = lambda self: None

    def getDictionary(self):
        return _data_management.DataSource_getDictionary(self)

    def setDictionary(self, dict):
        return _data_management.DataSource_setDictionary(self, dict)

    def createDictionaryFromContext(self):
        return _data_management.DataSource_createDictionaryFromContext(self)

    def loadDataBlock(self, *args):
        return _data_management.DataSource_loadDataBlock(self, *args)

    def getNumericTable(self):
        return _data_management.DataSource_getNumericTable(self)

    def getNumberOfColumns(self):
        return _data_management.DataSource_getNumberOfColumns(self)

    def status(self):
        return _data_management.DataSource_status(self)

    def getErrors(self):
        return _data_management.DataSource_getErrors(self)

    def getNumericTableNumberOfColumns(self):
        return _data_management.DataSource_getNumericTableNumberOfColumns(self)
DataSource_swigregister = _data_management.DataSource_swigregister
DataSource_swigregister(DataSource)

class StringRowFeatureManagerIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringRowFeatureManagerIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringRowFeatureManagerIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def parseRowAsDictionary(self, rawRowData, dict):
        return _data_management.StringRowFeatureManagerIface_parseRowAsDictionary(self, rawRowData, dict)

    def parseRowIn(self, rawRowData, dict, nt, ntRowIndex):
        return _data_management.StringRowFeatureManagerIface_parseRowIn(self, rawRowData, dict, nt, ntRowIndex)
    __swig_destroy__ = _data_management.delete_StringRowFeatureManagerIface
    __del__ = lambda self: None
StringRowFeatureManagerIface_swigregister = _data_management.StringRowFeatureManagerIface_swigregister
StringRowFeatureManagerIface_swigregister(StringRowFeatureManagerIface)

class FeatureAuxData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FeatureAuxData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FeatureAuxData, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_FeatureAuxData()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["idx"] = _data_management.FeatureAuxData_idx_set
    __swig_getmethods__["idx"] = _data_management.FeatureAuxData_idx_get
    if _newclass:
        idx = _swig_property(_data_management.FeatureAuxData_idx_get, _data_management.FeatureAuxData_idx_set)
    __swig_setmethods__["wide"] = _data_management.FeatureAuxData_wide_set
    __swig_getmethods__["wide"] = _data_management.FeatureAuxData_wide_get
    if _newclass:
        wide = _swig_property(_data_management.FeatureAuxData_wide_get, _data_management.FeatureAuxData_wide_set)
    __swig_setmethods__["nCats"] = _data_management.FeatureAuxData_nCats_set
    __swig_getmethods__["nCats"] = _data_management.FeatureAuxData_nCats_get
    if _newclass:
        nCats = _swig_property(_data_management.FeatureAuxData_nCats_get, _data_management.FeatureAuxData_nCats_set)
    __swig_setmethods__["dsFeat"] = _data_management.FeatureAuxData_dsFeat_set
    __swig_getmethods__["dsFeat"] = _data_management.FeatureAuxData_dsFeat_get
    if _newclass:
        dsFeat = _swig_property(_data_management.FeatureAuxData_dsFeat_get, _data_management.FeatureAuxData_dsFeat_set)
    __swig_setmethods__["ntFeat"] = _data_management.FeatureAuxData_ntFeat_set
    __swig_getmethods__["ntFeat"] = _data_management.FeatureAuxData_ntFeat_get
    if _newclass:
        ntFeat = _swig_property(_data_management.FeatureAuxData_ntFeat_get, _data_management.FeatureAuxData_ntFeat_set)
    __swig_destroy__ = _data_management.delete_FeatureAuxData
    __del__ = lambda self: None
FeatureAuxData_swigregister = _data_management.FeatureAuxData_swigregister
FeatureAuxData_swigregister(FeatureAuxData)

class ModifierIface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModifierIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModifierIface, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def apply(self, funcList, auxVect):
        return _data_management.ModifierIface_apply(self, funcList, auxVect)
    __swig_getmethods__["contFunc"] = lambda x: _data_management.ModifierIface_contFunc
    if _newclass:
        contFunc = staticmethod(_data_management.ModifierIface_contFunc)
    __swig_getmethods__["catFunc"] = lambda x: _data_management.ModifierIface_catFunc
    if _newclass:
        catFunc = staticmethod(_data_management.ModifierIface_catFunc)
    __swig_destroy__ = _data_management.delete_ModifierIface
    __del__ = lambda self: None
ModifierIface_swigregister = _data_management.ModifierIface_swigregister
ModifierIface_swigregister(ModifierIface)

def ModifierIface_contFunc(word, aux, arr):
    return _data_management.ModifierIface_contFunc(word, aux, arr)
ModifierIface_contFunc = _data_management.ModifierIface_contFunc

def ModifierIface_catFunc(word, aux, arr):
    return _data_management.ModifierIface_catFunc(word, aux, arr)
ModifierIface_catFunc = _data_management.ModifierIface_catFunc

class MakeCategorical(ModifierIface):
    __swig_setmethods__ = {}
    for _s in [ModifierIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MakeCategorical, name, value)
    __swig_getmethods__ = {}
    for _s in [ModifierIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MakeCategorical, name)
    __repr__ = _swig_repr

    def __init__(self, idx):
        this = _data_management.new_MakeCategorical(idx)
        try:
            self.this.append(this)
        except:
            self.this = this

    def apply(self, funcList, auxVect):
        return _data_management.MakeCategorical_apply(self, funcList, auxVect)
    __swig_destroy__ = _data_management.delete_MakeCategorical
    __del__ = lambda self: None
MakeCategorical_swigregister = _data_management.MakeCategorical_swigregister
MakeCategorical_swigregister(MakeCategorical)

class OneHotEncoder(ModifierIface):
    __swig_setmethods__ = {}
    for _s in [ModifierIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OneHotEncoder, name, value)
    __swig_getmethods__ = {}
    for _s in [ModifierIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OneHotEncoder, name)
    __repr__ = _swig_repr

    def __init__(self, idx, nCats):
        this = _data_management.new_OneHotEncoder(idx, nCats)
        try:
            self.this.append(this)
        except:
            self.this = this

    def apply(self, funcList, auxVect):
        return _data_management.OneHotEncoder_apply(self, funcList, auxVect)
    __swig_destroy__ = _data_management.delete_OneHotEncoder
    __del__ = lambda self: None
OneHotEncoder_swigregister = _data_management.OneHotEncoder_swigregister
OneHotEncoder_swigregister(OneHotEncoder)

class ColumnFilter(ModifierIface):
    __swig_setmethods__ = {}
    for _s in [ModifierIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColumnFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [ModifierIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ColumnFilter, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_ColumnFilter()
        try:
            self.this.append(this)
        except:
            self.this = this

    def odd(self):
        return _data_management.ColumnFilter_odd(self)

    def even(self):
        return _data_management.ColumnFilter_even(self)

    def none(self):
        return _data_management.ColumnFilter_none(self)

    def list(self, valid):
        return _data_management.ColumnFilter_list(self, valid)

    def apply(self, funcList, auxVect):
        return _data_management.ColumnFilter_apply(self, funcList, auxVect)
    __swig_destroy__ = _data_management.delete_ColumnFilter
    __del__ = lambda self: None
ColumnFilter_swigregister = _data_management.ColumnFilter_swigregister
ColumnFilter_swigregister(ColumnFilter)

class CSVFeatureManager(StringRowFeatureManagerIface):
    __swig_setmethods__ = {}
    for _s in [StringRowFeatureManagerIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSVFeatureManager, name, value)
    __swig_getmethods__ = {}
    for _s in [StringRowFeatureManagerIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSVFeatureManager, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_CSVFeatureManager()
        try:
            self.this.append(this)
        except:
            self.this = this

    def setDelimiter(self, delimiter):
        return _data_management.CSVFeatureManager_setDelimiter(self, delimiter)

    def getNumericTableNumberOfColumns(self):
        return _data_management.CSVFeatureManager_getNumericTableNumberOfColumns(self)

    def parseRowAsDictionary(self, rawRowData, dict):
        return _data_management.CSVFeatureManager_parseRowAsDictionary(self, rawRowData, dict)

    def setFeatureDetailsFromDictionary(self, dict):
        return _data_management.CSVFeatureManager_setFeatureDetailsFromDictionary(self, dict)

    def addModifier(self, modifier):
        return _data_management.CSVFeatureManager_addModifier(self, modifier)

    def parseRowIn(self, rawRowData, dict, nt, ntRowIndex):
        return _data_management.CSVFeatureManager_parseRowIn(self, rawRowData, dict, nt, ntRowIndex)
    __swig_destroy__ = _data_management.delete_CSVFeatureManager
    __del__ = lambda self: None
CSVFeatureManager_swigregister = _data_management.CSVFeatureManager_swigregister
CSVFeatureManager_swigregister(CSVFeatureManager)


def convertToHomogen_Float64(*args):
    return _data_management.convertToHomogen_Float64(*args)
convertToHomogen_Float64 = _data_management.convertToHomogen_Float64

def convertToHomogen_Float32(*args):
    return _data_management.convertToHomogen_Float32(*args)
convertToHomogen_Float32 = _data_management.convertToHomogen_Float32

def convertToHomogen_Intc(*args):
    return _data_management.convertToHomogen_Intc(*args)
convertToHomogen_Intc = _data_management.convertToHomogen_Intc
class NumericTableDictionary(SerializationIface, DictionaryIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface, DictionaryIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericTableDictionary, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, DictionaryIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericTableDictionary, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.NumericTableDictionary_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.NumericTableDictionary_serializationTag)

    def getSerializationTag(self):
        return _data_management.NumericTableDictionary_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_NumericTableDictionary(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_NumericTableDictionary
    __del__ = lambda self: None

    def resetDictionary(self):
        return _data_management.NumericTableDictionary_resetDictionary(self)

    def setAllFeatures(self, defaultFeature):
        return _data_management.NumericTableDictionary_setAllFeatures(self, defaultFeature)

    def setNumberOfFeatures(self, numberOfFeatures):
        return _data_management.NumericTableDictionary_setNumberOfFeatures(self, numberOfFeatures)

    def getNumberOfFeatures(self):
        return _data_management.NumericTableDictionary_getNumberOfFeatures(self)

    def getFeaturesEqual(self):
        return _data_management.NumericTableDictionary_getFeaturesEqual(self)

    def setFeature(self, feature, idx):
        return _data_management.NumericTableDictionary_setFeature(self, feature, idx)

    def checkDictionary(self):
        return _data_management.NumericTableDictionary_checkDictionary(self)

    def getErrors(self):
        return _data_management.NumericTableDictionary_getErrors(self)

    def __getitem__(self, i):
        return _data_management.NumericTableDictionary___getitem__(self, i)

    def __setitem__(self, i, v):
        return _data_management.NumericTableDictionary___setitem__(self, i, v)
NumericTableDictionary_swigregister = _data_management.NumericTableDictionary_swigregister
NumericTableDictionary_swigregister(NumericTableDictionary)

def NumericTableDictionary_serializationTag():
    return _data_management.NumericTableDictionary_serializationTag()
NumericTableDictionary_serializationTag = _data_management.NumericTableDictionary_serializationTag

class DataSourceDictionary(SerializationIface, DictionaryIface):
    __swig_setmethods__ = {}
    for _s in [SerializationIface, DictionaryIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceDictionary, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, DictionaryIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceDictionary, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.DataSourceDictionary_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.DataSourceDictionary_serializationTag)

    def getSerializationTag(self):
        return _data_management.DataSourceDictionary_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_DataSourceDictionary(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_DataSourceDictionary
    __del__ = lambda self: None

    def resetDictionary(self):
        return _data_management.DataSourceDictionary_resetDictionary(self)

    def setAllFeatures(self, defaultFeature):
        return _data_management.DataSourceDictionary_setAllFeatures(self, defaultFeature)

    def setNumberOfFeatures(self, numberOfFeatures):
        return _data_management.DataSourceDictionary_setNumberOfFeatures(self, numberOfFeatures)

    def getNumberOfFeatures(self):
        return _data_management.DataSourceDictionary_getNumberOfFeatures(self)

    def getFeaturesEqual(self):
        return _data_management.DataSourceDictionary_getFeaturesEqual(self)

    def setFeature(self, feature, idx):
        return _data_management.DataSourceDictionary_setFeature(self, feature, idx)

    def checkDictionary(self):
        return _data_management.DataSourceDictionary_checkDictionary(self)

    def getErrors(self):
        return _data_management.DataSourceDictionary_getErrors(self)

    def __getitem__(self, i):
        return _data_management.DataSourceDictionary___getitem__(self, i)

    def __setitem__(self, i, v):
        return _data_management.DataSourceDictionary___setitem__(self, i, v)
DataSourceDictionary_swigregister = _data_management.DataSourceDictionary_swigregister
DataSourceDictionary_swigregister(DataSourceDictionary)

def DataSourceDictionary_serializationTag():
    return _data_management.DataSourceDictionary_serializationTag()
DataSourceDictionary_serializationTag = _data_management.DataSourceDictionary_serializationTag

class BlockDescriptor_Float64(_object):
    r"""
This class is an alias of BlockDescriptor(ntype=float64)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BlockDescriptor_Float64, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BlockDescriptor_Float64, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_BlockDescriptor_Float64()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_BlockDescriptor_Float64
    __del__ = lambda self: None

    def getBlockSharedPtr(self):
        return _data_management.BlockDescriptor_Float64_getBlockSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.BlockDescriptor_Float64_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.BlockDescriptor_Float64_getNumberOfRows(self)

    def reset(self):
        return _data_management.BlockDescriptor_Float64_reset(self)

    def resizeBuffer(self, nColumns, nRows, auxMemorySize=0):
        return _data_management.BlockDescriptor_Float64_resizeBuffer(self, nColumns, nRows, auxMemorySize)

    def setDetails(self, columnIdx, rowIdx, rwFlag):
        return _data_management.BlockDescriptor_Float64_setDetails(self, columnIdx, rowIdx, rwFlag)

    def getColumnsOffset(self):
        return _data_management.BlockDescriptor_Float64_getColumnsOffset(self)

    def getRowsOffset(self):
        return _data_management.BlockDescriptor_Float64_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.BlockDescriptor_Float64_getRWFlag(self)

    def getAdditionalBufferPtr(self):
        return _data_management.BlockDescriptor_Float64_getAdditionalBufferPtr(self)

    def getAdditionalBufferSharedPtr(self):
        return _data_management.BlockDescriptor_Float64_getAdditionalBufferSharedPtr(self)

    def getArray(self):
        return _data_management.BlockDescriptor_Float64_getArray(self)
BlockDescriptor_Float64_swigregister = _data_management.BlockDescriptor_Float64_swigregister
BlockDescriptor_Float64_swigregister(BlockDescriptor_Float64)

class BlockDescriptor_Float32(_object):
    r"""
This class is an alias of BlockDescriptor(ntype=float32)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BlockDescriptor_Float32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BlockDescriptor_Float32, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_BlockDescriptor_Float32()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_BlockDescriptor_Float32
    __del__ = lambda self: None

    def getBlockSharedPtr(self):
        return _data_management.BlockDescriptor_Float32_getBlockSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.BlockDescriptor_Float32_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.BlockDescriptor_Float32_getNumberOfRows(self)

    def reset(self):
        return _data_management.BlockDescriptor_Float32_reset(self)

    def resizeBuffer(self, nColumns, nRows, auxMemorySize=0):
        return _data_management.BlockDescriptor_Float32_resizeBuffer(self, nColumns, nRows, auxMemorySize)

    def setDetails(self, columnIdx, rowIdx, rwFlag):
        return _data_management.BlockDescriptor_Float32_setDetails(self, columnIdx, rowIdx, rwFlag)

    def getColumnsOffset(self):
        return _data_management.BlockDescriptor_Float32_getColumnsOffset(self)

    def getRowsOffset(self):
        return _data_management.BlockDescriptor_Float32_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.BlockDescriptor_Float32_getRWFlag(self)

    def getAdditionalBufferPtr(self):
        return _data_management.BlockDescriptor_Float32_getAdditionalBufferPtr(self)

    def getAdditionalBufferSharedPtr(self):
        return _data_management.BlockDescriptor_Float32_getAdditionalBufferSharedPtr(self)

    def getArray(self):
        return _data_management.BlockDescriptor_Float32_getArray(self)
BlockDescriptor_Float32_swigregister = _data_management.BlockDescriptor_Float32_swigregister
BlockDescriptor_Float32_swigregister(BlockDescriptor_Float32)

class BlockDescriptor_Intc(_object):
    r"""
This class is an alias of BlockDescriptor(ntype=intc)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BlockDescriptor_Intc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BlockDescriptor_Intc, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_BlockDescriptor_Intc()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_BlockDescriptor_Intc
    __del__ = lambda self: None

    def getBlockSharedPtr(self):
        return _data_management.BlockDescriptor_Intc_getBlockSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.BlockDescriptor_Intc_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.BlockDescriptor_Intc_getNumberOfRows(self)

    def reset(self):
        return _data_management.BlockDescriptor_Intc_reset(self)

    def resizeBuffer(self, nColumns, nRows, auxMemorySize=0):
        return _data_management.BlockDescriptor_Intc_resizeBuffer(self, nColumns, nRows, auxMemorySize)

    def setDetails(self, columnIdx, rowIdx, rwFlag):
        return _data_management.BlockDescriptor_Intc_setDetails(self, columnIdx, rowIdx, rwFlag)

    def getColumnsOffset(self):
        return _data_management.BlockDescriptor_Intc_getColumnsOffset(self)

    def getRowsOffset(self):
        return _data_management.BlockDescriptor_Intc_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.BlockDescriptor_Intc_getRWFlag(self)

    def getAdditionalBufferPtr(self):
        return _data_management.BlockDescriptor_Intc_getAdditionalBufferPtr(self)

    def getAdditionalBufferSharedPtr(self):
        return _data_management.BlockDescriptor_Intc_getAdditionalBufferSharedPtr(self)

    def getArray(self):
        return _data_management.BlockDescriptor_Intc_getArray(self)
BlockDescriptor_Intc_swigregister = _data_management.BlockDescriptor_Intc_swigregister
BlockDescriptor_Intc_swigregister(BlockDescriptor_Intc)

class CSRBlockDescriptor_Float64(_object):
    r"""
This class is an alias of CSRBlockDescriptor(ntype=float64)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSRBlockDescriptor_Float64, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSRBlockDescriptor_Float64, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_CSRBlockDescriptor_Float64()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CSRBlockDescriptor_Float64
    __del__ = lambda self: None

    def getBlockValuesPtr(self):
        return _data_management.CSRBlockDescriptor_Float64_getBlockValuesPtr(self)

    def getBlockValuesSharedPtr(self):
        return _data_management.CSRBlockDescriptor_Float64_getBlockValuesSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.CSRBlockDescriptor_Float64_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.CSRBlockDescriptor_Float64_getNumberOfRows(self)

    def getDataSize(self):
        return _data_management.CSRBlockDescriptor_Float64_getDataSize(self)

    def reset(self):
        return _data_management.CSRBlockDescriptor_Float64_reset(self)

    def resizeValuesBuffer(self, nValues):
        return _data_management.CSRBlockDescriptor_Float64_resizeValuesBuffer(self, nValues)

    def resizeRowsBuffer(self, nRows):
        return _data_management.CSRBlockDescriptor_Float64_resizeRowsBuffer(self, nRows)

    def setDetails(self, nColumns, rowIdx, rwFlag):
        return _data_management.CSRBlockDescriptor_Float64_setDetails(self, nColumns, rowIdx, rwFlag)

    def getRowsOffset(self):
        return _data_management.CSRBlockDescriptor_Float64_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.CSRBlockDescriptor_Float64_getRWFlag(self)

    def getBlockColumnIndices(self):
        return _data_management.CSRBlockDescriptor_Float64_getBlockColumnIndices(self)

    def getBlockRowIndices(self):
        return _data_management.CSRBlockDescriptor_Float64_getBlockRowIndices(self)

    def getBlockValues(self):
        return _data_management.CSRBlockDescriptor_Float64_getBlockValues(self)
CSRBlockDescriptor_Float64_swigregister = _data_management.CSRBlockDescriptor_Float64_swigregister
CSRBlockDescriptor_Float64_swigregister(CSRBlockDescriptor_Float64)

class CSRBlockDescriptor_Float32(_object):
    r"""
This class is an alias of CSRBlockDescriptor(ntype=float32)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSRBlockDescriptor_Float32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSRBlockDescriptor_Float32, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_CSRBlockDescriptor_Float32()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CSRBlockDescriptor_Float32
    __del__ = lambda self: None

    def getBlockValuesPtr(self):
        return _data_management.CSRBlockDescriptor_Float32_getBlockValuesPtr(self)

    def getBlockValuesSharedPtr(self):
        return _data_management.CSRBlockDescriptor_Float32_getBlockValuesSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.CSRBlockDescriptor_Float32_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.CSRBlockDescriptor_Float32_getNumberOfRows(self)

    def getDataSize(self):
        return _data_management.CSRBlockDescriptor_Float32_getDataSize(self)

    def reset(self):
        return _data_management.CSRBlockDescriptor_Float32_reset(self)

    def resizeValuesBuffer(self, nValues):
        return _data_management.CSRBlockDescriptor_Float32_resizeValuesBuffer(self, nValues)

    def resizeRowsBuffer(self, nRows):
        return _data_management.CSRBlockDescriptor_Float32_resizeRowsBuffer(self, nRows)

    def setDetails(self, nColumns, rowIdx, rwFlag):
        return _data_management.CSRBlockDescriptor_Float32_setDetails(self, nColumns, rowIdx, rwFlag)

    def getRowsOffset(self):
        return _data_management.CSRBlockDescriptor_Float32_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.CSRBlockDescriptor_Float32_getRWFlag(self)

    def getBlockColumnIndices(self):
        return _data_management.CSRBlockDescriptor_Float32_getBlockColumnIndices(self)

    def getBlockRowIndices(self):
        return _data_management.CSRBlockDescriptor_Float32_getBlockRowIndices(self)

    def getBlockValues(self):
        return _data_management.CSRBlockDescriptor_Float32_getBlockValues(self)
CSRBlockDescriptor_Float32_swigregister = _data_management.CSRBlockDescriptor_Float32_swigregister
CSRBlockDescriptor_Float32_swigregister(CSRBlockDescriptor_Float32)

class CSRBlockDescriptor_Intc(_object):
    r"""
This class is an alias of CSRBlockDescriptor(ntype=intc)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSRBlockDescriptor_Intc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSRBlockDescriptor_Intc, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_CSRBlockDescriptor_Intc()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_CSRBlockDescriptor_Intc
    __del__ = lambda self: None

    def getBlockValuesPtr(self):
        return _data_management.CSRBlockDescriptor_Intc_getBlockValuesPtr(self)

    def getBlockValuesSharedPtr(self):
        return _data_management.CSRBlockDescriptor_Intc_getBlockValuesSharedPtr(self)

    def getNumberOfColumns(self):
        return _data_management.CSRBlockDescriptor_Intc_getNumberOfColumns(self)

    def getNumberOfRows(self):
        return _data_management.CSRBlockDescriptor_Intc_getNumberOfRows(self)

    def getDataSize(self):
        return _data_management.CSRBlockDescriptor_Intc_getDataSize(self)

    def reset(self):
        return _data_management.CSRBlockDescriptor_Intc_reset(self)

    def resizeValuesBuffer(self, nValues):
        return _data_management.CSRBlockDescriptor_Intc_resizeValuesBuffer(self, nValues)

    def resizeRowsBuffer(self, nRows):
        return _data_management.CSRBlockDescriptor_Intc_resizeRowsBuffer(self, nRows)

    def setDetails(self, nColumns, rowIdx, rwFlag):
        return _data_management.CSRBlockDescriptor_Intc_setDetails(self, nColumns, rowIdx, rwFlag)

    def getRowsOffset(self):
        return _data_management.CSRBlockDescriptor_Intc_getRowsOffset(self)

    def getRWFlag(self):
        return _data_management.CSRBlockDescriptor_Intc_getRWFlag(self)

    def getBlockColumnIndices(self):
        return _data_management.CSRBlockDescriptor_Intc_getBlockColumnIndices(self)

    def getBlockRowIndices(self):
        return _data_management.CSRBlockDescriptor_Intc_getBlockRowIndices(self)

    def getBlockValues(self):
        return _data_management.CSRBlockDescriptor_Intc_getBlockValues(self)
CSRBlockDescriptor_Intc_swigregister = _data_management.CSRBlockDescriptor_Intc_swigregister
CSRBlockDescriptor_Intc_swigregister(CSRBlockDescriptor_Intc)

class Compressor_Bzip2(CompressorImpl):
    r"""
This class is an alias of Compressor(CompressionMethod=daal.data_management.bzip2)
    """
    __swig_setmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compressor_Bzip2, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compressor_Bzip2, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Compressor_Bzip2()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Compressor_Bzip2
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Compressor_Bzip2_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Compressor_Bzip2_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Compressor_Bzip2_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Compressor_Bzip2_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Compressor_Bzip2_parameter_get, _data_management.Compressor_Bzip2_parameter_set)
Compressor_Bzip2_swigregister = _data_management.Compressor_Bzip2_swigregister
Compressor_Bzip2_swigregister(Compressor_Bzip2)

class Compressor_Lzo(CompressorImpl):
    r"""
This class is an alias of Compressor(CompressionMethod=daal.data_management.lzo)
    """
    __swig_setmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compressor_Lzo, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compressor_Lzo, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Compressor_Lzo()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Compressor_Lzo
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Compressor_Lzo_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Compressor_Lzo_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Compressor_Lzo_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Compressor_Lzo_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Compressor_Lzo_parameter_get, _data_management.Compressor_Lzo_parameter_set)
Compressor_Lzo_swigregister = _data_management.Compressor_Lzo_swigregister
Compressor_Lzo_swigregister(Compressor_Lzo)

class Compressor_Rle(CompressorImpl):
    r"""
This class is an alias of Compressor(CompressionMethod=daal.data_management.rle)
    """
    __swig_setmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compressor_Rle, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compressor_Rle, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Compressor_Rle()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Compressor_Rle
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Compressor_Rle_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Compressor_Rle_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Compressor_Rle_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Compressor_Rle_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Compressor_Rle_parameter_get, _data_management.Compressor_Rle_parameter_set)
Compressor_Rle_swigregister = _data_management.Compressor_Rle_swigregister
Compressor_Rle_swigregister(Compressor_Rle)

class Compressor_Zlib(CompressorImpl):
    r"""
This class is an alias of Compressor(CompressionMethod=daal.data_management.zlib)
    """
    __swig_setmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compressor_Zlib, name, value)
    __swig_getmethods__ = {}
    for _s in [CompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compressor_Zlib, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Compressor_Zlib()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Compressor_Zlib
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Compressor_Zlib_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Compressor_Zlib_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Compressor_Zlib_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Compressor_Zlib_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Compressor_Zlib_parameter_get, _data_management.Compressor_Zlib_parameter_set)
Compressor_Zlib_swigregister = _data_management.Compressor_Zlib_swigregister
Compressor_Zlib_swigregister(Compressor_Zlib)

class Decompressor_Bzip2(DecompressorImpl):
    r"""
This class is an alias of Decompressor(CompressionMethod=daal.data_management.bzip2)
    """
    __swig_setmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decompressor_Bzip2, name, value)
    __swig_getmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Decompressor_Bzip2, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Decompressor_Bzip2()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Decompressor_Bzip2
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Decompressor_Bzip2_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Decompressor_Bzip2_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Decompressor_Bzip2_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Decompressor_Bzip2_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Decompressor_Bzip2_parameter_get, _data_management.Decompressor_Bzip2_parameter_set)
Decompressor_Bzip2_swigregister = _data_management.Decompressor_Bzip2_swigregister
Decompressor_Bzip2_swigregister(Decompressor_Bzip2)

class Decompressor_Lzo(DecompressorImpl):
    r"""
This class is an alias of Decompressor(CompressionMethod=daal.data_management.lzo)
    """
    __swig_setmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decompressor_Lzo, name, value)
    __swig_getmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Decompressor_Lzo, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Decompressor_Lzo()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Decompressor_Lzo
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Decompressor_Lzo_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Decompressor_Lzo_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Decompressor_Lzo_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Decompressor_Lzo_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Decompressor_Lzo_parameter_get, _data_management.Decompressor_Lzo_parameter_set)
Decompressor_Lzo_swigregister = _data_management.Decompressor_Lzo_swigregister
Decompressor_Lzo_swigregister(Decompressor_Lzo)

class Decompressor_Rle(DecompressorImpl):
    r"""
This class is an alias of Decompressor(CompressionMethod=daal.data_management.rle)
    """
    __swig_setmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decompressor_Rle, name, value)
    __swig_getmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Decompressor_Rle, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Decompressor_Rle()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Decompressor_Rle
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Decompressor_Rle_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Decompressor_Rle_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Decompressor_Rle_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Decompressor_Rle_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Decompressor_Rle_parameter_get, _data_management.Decompressor_Rle_parameter_set)
Decompressor_Rle_swigregister = _data_management.Decompressor_Rle_swigregister
Decompressor_Rle_swigregister(Decompressor_Rle)

class Decompressor_Zlib(DecompressorImpl):
    r"""
This class is an alias of Decompressor(CompressionMethod=daal.data_management.zlib)
    """
    __swig_setmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decompressor_Zlib, name, value)
    __swig_getmethods__ = {}
    for _s in [DecompressorImpl]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Decompressor_Zlib, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_Decompressor_Zlib()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_Decompressor_Zlib
    __del__ = lambda self: None

    def setInputDataBlock(self, inBlock, offset):
        return _data_management.Decompressor_Zlib_setInputDataBlock(self, inBlock, offset)

    def run(self, outBlock, offset):
        return _data_management.Decompressor_Zlib_run(self, outBlock, offset)
    __swig_setmethods__["parameter"] = _data_management.Decompressor_Zlib_parameter_set
    __swig_getmethods__["parameter"] = _data_management.Decompressor_Zlib_parameter_get
    if _newclass:
        parameter = _swig_property(_data_management.Decompressor_Zlib_parameter_get, _data_management.Decompressor_Zlib_parameter_set)
Decompressor_Zlib_swigregister = _data_management.Decompressor_Zlib_swigregister
Decompressor_Zlib_swigregister(Decompressor_Zlib)

class HomogenNumericTable_Float64(NumericTable):
    r"""
This class is an alias of HomogenNumericTable(ntype=float64)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenNumericTable_Float64, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenNumericTable_Float64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenNumericTable_Float64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenNumericTable_Float64_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenNumericTable_Float64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenNumericTable_Float64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenNumericTable_Float64
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.HomogenNumericTable_Float64_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Float64_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Float64_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Float64_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Float64_releaseBlockOfColumnValues(self, *args)

    def __getitem__(self, i):
        return _data_management.HomogenNumericTable_Float64___getitem__(self, i)

    def getArray(self):
        return _data_management.HomogenNumericTable_Float64_getArray(self)
HomogenNumericTable_Float64_swigregister = _data_management.HomogenNumericTable_Float64_swigregister
HomogenNumericTable_Float64_swigregister(HomogenNumericTable_Float64)

def HomogenNumericTable_Float64_serializationTag():
    return _data_management.HomogenNumericTable_Float64_serializationTag()
HomogenNumericTable_Float64_serializationTag = _data_management.HomogenNumericTable_Float64_serializationTag

class HomogenNumericTable_Float32(NumericTable):
    r"""
This class is an alias of HomogenNumericTable(ntype=float32)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenNumericTable_Float32, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenNumericTable_Float32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenNumericTable_Float32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenNumericTable_Float32_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenNumericTable_Float32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenNumericTable_Float32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenNumericTable_Float32
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.HomogenNumericTable_Float32_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Float32_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Float32_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Float32_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Float32_releaseBlockOfColumnValues(self, *args)

    def __getitem__(self, i):
        return _data_management.HomogenNumericTable_Float32___getitem__(self, i)

    def getArray(self):
        return _data_management.HomogenNumericTable_Float32_getArray(self)
HomogenNumericTable_Float32_swigregister = _data_management.HomogenNumericTable_Float32_swigregister
HomogenNumericTable_Float32_swigregister(HomogenNumericTable_Float32)

def HomogenNumericTable_Float32_serializationTag():
    return _data_management.HomogenNumericTable_Float32_serializationTag()
HomogenNumericTable_Float32_serializationTag = _data_management.HomogenNumericTable_Float32_serializationTag

class HomogenNumericTable_Intc(NumericTable):
    r"""
This class is an alias of HomogenNumericTable(ntype=intc)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenNumericTable_Intc, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenNumericTable_Intc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenNumericTable_Intc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenNumericTable_Intc_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenNumericTable_Intc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenNumericTable_Intc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenNumericTable_Intc
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.HomogenNumericTable_Intc_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Intc_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.HomogenNumericTable_Intc_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Intc_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.HomogenNumericTable_Intc_releaseBlockOfColumnValues(self, *args)

    def __getitem__(self, i):
        return _data_management.HomogenNumericTable_Intc___getitem__(self, i)

    def getArray(self):
        return _data_management.HomogenNumericTable_Intc_getArray(self)
HomogenNumericTable_Intc_swigregister = _data_management.HomogenNumericTable_Intc_swigregister
HomogenNumericTable_Intc_swigregister(HomogenNumericTable_Intc)

def HomogenNumericTable_Intc_serializationTag():
    return _data_management.HomogenNumericTable_Intc_serializationTag()
HomogenNumericTable_Intc_serializationTag = _data_management.HomogenNumericTable_Intc_serializationTag

class HomogenTensor_Float64(Tensor):
    r"""
This class is an alias of HomogenTensor(ntype=float64)
    """
    __swig_setmethods__ = {}
    for _s in [Tensor]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenTensor_Float64, name, value)
    __swig_getmethods__ = {}
    for _s in [Tensor]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenTensor_Float64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenTensor_Float64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenTensor_Float64_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenTensor_Float64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenTensor_Float64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenTensor_Float64
    __del__ = lambda self: None

    def getTensorLayout(self):
        return _data_management.HomogenTensor_Float64_getTensorLayout(self)

    def createDefaultSubtensorLayout(self):
        return _data_management.HomogenTensor_Float64_createDefaultSubtensorLayout(self)

    def createRawSubtensorLayout(self):
        return _data_management.HomogenTensor_Float64_createRawSubtensorLayout(self)

    def setDimensions(self, *args):
        return _data_management.HomogenTensor_Float64_setDimensions(self, *args)

    def assign(self, initValue):
        return _data_management.HomogenTensor_Float64_assign(self, initValue)

    def getSubtensorEx(self, *args):
        return _data_management.HomogenTensor_Float64_getSubtensorEx(self, *args)

    def getSubtensor(self, *args):
        return _data_management.HomogenTensor_Float64_getSubtensor(self, *args)

    def releaseSubtensor(self, *args):
        return _data_management.HomogenTensor_Float64_releaseSubtensor(self, *args)

    def getSampleTensor(self, firstDimIndex):
        return _data_management.HomogenTensor_Float64_getSampleTensor(self, firstDimIndex)

    def getArray(self):
        return _data_management.HomogenTensor_Float64_getArray(self)
HomogenTensor_Float64_swigregister = _data_management.HomogenTensor_Float64_swigregister
HomogenTensor_Float64_swigregister(HomogenTensor_Float64)

def HomogenTensor_Float64_serializationTag():
    return _data_management.HomogenTensor_Float64_serializationTag()
HomogenTensor_Float64_serializationTag = _data_management.HomogenTensor_Float64_serializationTag

class HomogenTensor_Float32(Tensor):
    r"""
This class is an alias of HomogenTensor(ntype=float32)
    """
    __swig_setmethods__ = {}
    for _s in [Tensor]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenTensor_Float32, name, value)
    __swig_getmethods__ = {}
    for _s in [Tensor]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenTensor_Float32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenTensor_Float32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenTensor_Float32_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenTensor_Float32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenTensor_Float32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenTensor_Float32
    __del__ = lambda self: None

    def getTensorLayout(self):
        return _data_management.HomogenTensor_Float32_getTensorLayout(self)

    def createDefaultSubtensorLayout(self):
        return _data_management.HomogenTensor_Float32_createDefaultSubtensorLayout(self)

    def createRawSubtensorLayout(self):
        return _data_management.HomogenTensor_Float32_createRawSubtensorLayout(self)

    def setDimensions(self, *args):
        return _data_management.HomogenTensor_Float32_setDimensions(self, *args)

    def assign(self, initValue):
        return _data_management.HomogenTensor_Float32_assign(self, initValue)

    def getSubtensorEx(self, *args):
        return _data_management.HomogenTensor_Float32_getSubtensorEx(self, *args)

    def getSubtensor(self, *args):
        return _data_management.HomogenTensor_Float32_getSubtensor(self, *args)

    def releaseSubtensor(self, *args):
        return _data_management.HomogenTensor_Float32_releaseSubtensor(self, *args)

    def getSampleTensor(self, firstDimIndex):
        return _data_management.HomogenTensor_Float32_getSampleTensor(self, firstDimIndex)

    def getArray(self):
        return _data_management.HomogenTensor_Float32_getArray(self)
HomogenTensor_Float32_swigregister = _data_management.HomogenTensor_Float32_swigregister
HomogenTensor_Float32_swigregister(HomogenTensor_Float32)

def HomogenTensor_Float32_serializationTag():
    return _data_management.HomogenTensor_Float32_serializationTag()
HomogenTensor_Float32_serializationTag = _data_management.HomogenTensor_Float32_serializationTag

class HomogenTensor_Intc(Tensor):
    r"""
This class is an alias of HomogenTensor(ntype=intc)
    """
    __swig_setmethods__ = {}
    for _s in [Tensor]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HomogenTensor_Intc, name, value)
    __swig_getmethods__ = {}
    for _s in [Tensor]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HomogenTensor_Intc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.HomogenTensor_Intc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.HomogenTensor_Intc_serializationTag)

    def getSerializationTag(self):
        return _data_management.HomogenTensor_Intc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_HomogenTensor_Intc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_HomogenTensor_Intc
    __del__ = lambda self: None

    def getTensorLayout(self):
        return _data_management.HomogenTensor_Intc_getTensorLayout(self)

    def createDefaultSubtensorLayout(self):
        return _data_management.HomogenTensor_Intc_createDefaultSubtensorLayout(self)

    def createRawSubtensorLayout(self):
        return _data_management.HomogenTensor_Intc_createRawSubtensorLayout(self)

    def setDimensions(self, *args):
        return _data_management.HomogenTensor_Intc_setDimensions(self, *args)

    def assign(self, initValue):
        return _data_management.HomogenTensor_Intc_assign(self, initValue)

    def getSubtensorEx(self, *args):
        return _data_management.HomogenTensor_Intc_getSubtensorEx(self, *args)

    def getSubtensor(self, *args):
        return _data_management.HomogenTensor_Intc_getSubtensor(self, *args)

    def releaseSubtensor(self, *args):
        return _data_management.HomogenTensor_Intc_releaseSubtensor(self, *args)

    def getSampleTensor(self, firstDimIndex):
        return _data_management.HomogenTensor_Intc_getSampleTensor(self, firstDimIndex)

    def getArray(self):
        return _data_management.HomogenTensor_Intc_getArray(self)
HomogenTensor_Intc_swigregister = _data_management.HomogenTensor_Intc_swigregister
HomogenTensor_Intc_swigregister(HomogenTensor_Intc)

def HomogenTensor_Intc_serializationTag():
    return _data_management.HomogenTensor_Intc_serializationTag()
HomogenTensor_Intc_serializationTag = _data_management.HomogenTensor_Intc_serializationTag

class KeyValueCollection_SerializationIface(_object):
    r"""
This class is an alias of KeyValueCollection(T=daal.data_management.SerializationIface)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeyValueCollection_SerializationIface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KeyValueCollection_SerializationIface, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_KeyValueCollection_SerializationIface(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_KeyValueCollection_SerializationIface
    __del__ = lambda self: None

    def getKeyByIndex(self, idx):
        return _data_management.KeyValueCollection_SerializationIface_getKeyByIndex(self, idx)

    def getValueByIndex(self, idx):
        return _data_management.KeyValueCollection_SerializationIface_getValueByIndex(self, idx)

    def getValueByIndexConst(self, idx):
        return _data_management.KeyValueCollection_SerializationIface_getValueByIndexConst(self, idx)

    def size(self):
        return _data_management.KeyValueCollection_SerializationIface_size(self)

    def clear(self):
        return _data_management.KeyValueCollection_SerializationIface_clear(self)

    def __getitem__(self, i):
        return _data_management.KeyValueCollection_SerializationIface___getitem__(self, i)

    def __setitem__(self, i, v):
        return _data_management.KeyValueCollection_SerializationIface___setitem__(self, i, v)
KeyValueCollection_SerializationIface_swigregister = _data_management.KeyValueCollection_SerializationIface_swigregister
KeyValueCollection_SerializationIface_swigregister(KeyValueCollection_SerializationIface)

class KeyValueCollection_Input(_object):
    r"""
This class is an alias of KeyValueCollection(T=daal.algorithms.Input)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeyValueCollection_Input, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KeyValueCollection_Input, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _data_management.new_KeyValueCollection_Input(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_KeyValueCollection_Input
    __del__ = lambda self: None

    def getKeyByIndex(self, idx):
        return _data_management.KeyValueCollection_Input_getKeyByIndex(self, idx)

    def getValueByIndex(self, idx):
        return _data_management.KeyValueCollection_Input_getValueByIndex(self, idx)

    def getValueByIndexConst(self, idx):
        return _data_management.KeyValueCollection_Input_getValueByIndexConst(self, idx)

    def size(self):
        return _data_management.KeyValueCollection_Input_size(self)

    def clear(self):
        return _data_management.KeyValueCollection_Input_clear(self)

    def __getitem__(self, i):
        return _data_management.KeyValueCollection_Input___getitem__(self, i)

    def __setitem__(self, i, v):
        return _data_management.KeyValueCollection_Input___setitem__(self, i, v)
KeyValueCollection_Input_swigregister = _data_management.KeyValueCollection_Input_swigregister
KeyValueCollection_Input_swigregister(KeyValueCollection_Input)

class Matrix_Float64(HomogenNumericTable_Float64):
    r"""
This class is an alias of Matrix(ntype=float64)
    """
    __swig_setmethods__ = {}
    for _s in [HomogenNumericTable_Float64]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix_Float64, name, value)
    __swig_getmethods__ = {}
    for _s in [HomogenNumericTable_Float64]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix_Float64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.Matrix_Float64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.Matrix_Float64_serializationTag)

    def getSerializationTag(self):
        return _data_management.Matrix_Float64_getSerializationTag(self)
    __swig_destroy__ = _data_management.delete_Matrix_Float64
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _data_management.new_Matrix_Float64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
Matrix_Float64_swigregister = _data_management.Matrix_Float64_swigregister
Matrix_Float64_swigregister(Matrix_Float64)

def Matrix_Float64_serializationTag():
    return _data_management.Matrix_Float64_serializationTag()
Matrix_Float64_serializationTag = _data_management.Matrix_Float64_serializationTag

class Matrix_Float32(HomogenNumericTable_Float32):
    r"""
This class is an alias of Matrix(ntype=float32)
    """
    __swig_setmethods__ = {}
    for _s in [HomogenNumericTable_Float32]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix_Float32, name, value)
    __swig_getmethods__ = {}
    for _s in [HomogenNumericTable_Float32]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix_Float32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.Matrix_Float32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.Matrix_Float32_serializationTag)

    def getSerializationTag(self):
        return _data_management.Matrix_Float32_getSerializationTag(self)
    __swig_destroy__ = _data_management.delete_Matrix_Float32
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _data_management.new_Matrix_Float32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
Matrix_Float32_swigregister = _data_management.Matrix_Float32_swigregister
Matrix_Float32_swigregister(Matrix_Float32)

def Matrix_Float32_serializationTag():
    return _data_management.Matrix_Float32_serializationTag()
Matrix_Float32_serializationTag = _data_management.Matrix_Float32_serializationTag

class Matrix_Intc(HomogenNumericTable_Intc):
    r"""
This class is an alias of Matrix(ntype=intc)
    """
    __swig_setmethods__ = {}
    for _s in [HomogenNumericTable_Intc]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix_Intc, name, value)
    __swig_getmethods__ = {}
    for _s in [HomogenNumericTable_Intc]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix_Intc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.Matrix_Intc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.Matrix_Intc_serializationTag)

    def getSerializationTag(self):
        return _data_management.Matrix_Intc_getSerializationTag(self)
    __swig_destroy__ = _data_management.delete_Matrix_Intc
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _data_management.new_Matrix_Intc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
Matrix_Intc_swigregister = _data_management.Matrix_Intc_swigregister
Matrix_Intc_swigregister(Matrix_Intc)

def Matrix_Intc_serializationTag():
    return _data_management.Matrix_Intc_serializationTag()
Matrix_Intc_serializationTag = _data_management.Matrix_Intc_serializationTag

class SerializableKeyValueCollection_SerializationIface(SerializationIface, KeyValueCollection_SerializationIface):
    r"""
This class is an alias of SerializableKeyValueCollection(T=daal.data_management.SerializationIface)
    """
    __swig_setmethods__ = {}
    for _s in [SerializationIface, KeyValueCollection_SerializationIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SerializableKeyValueCollection_SerializationIface, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, KeyValueCollection_SerializationIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SerializableKeyValueCollection_SerializationIface, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.SerializableKeyValueCollection_SerializationIface_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.SerializableKeyValueCollection_SerializationIface_serializationTag)

    def getSerializationTag(self):
        return _data_management.SerializableKeyValueCollection_SerializationIface_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_SerializableKeyValueCollection_SerializationIface(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_SerializableKeyValueCollection_SerializationIface
    __del__ = lambda self: None
SerializableKeyValueCollection_SerializationIface_swigregister = _data_management.SerializableKeyValueCollection_SerializationIface_swigregister
SerializableKeyValueCollection_SerializationIface_swigregister(SerializableKeyValueCollection_SerializationIface)

def SerializableKeyValueCollection_SerializationIface_serializationTag():
    return _data_management.SerializableKeyValueCollection_SerializationIface_serializationTag()
SerializableKeyValueCollection_SerializationIface_serializationTag = _data_management.SerializableKeyValueCollection_SerializationIface_serializationTag

class SubtensorDescriptor_Float64(_object):
    r"""
This class is an alias of SubtensorDescriptor(ntype=float64)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubtensorDescriptor_Float64, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubtensorDescriptor_Float64, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_SubtensorDescriptor_Float64()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_SubtensorDescriptor_Float64
    __del__ = lambda self: None

    def getNumberOfDims(self):
        return _data_management.SubtensorDescriptor_Float64_getNumberOfDims(self)

    def getLayout(self):
        return _data_management.SubtensorDescriptor_Float64_getLayout(self)

    def getInplaceFlag(self):
        return _data_management.SubtensorDescriptor_Float64_getInplaceFlag(self)

    def reset(self):
        return _data_management.SubtensorDescriptor_Float64_reset(self)

    def resizeBuffer(self):
        return _data_management.SubtensorDescriptor_Float64_resizeBuffer(self)

    def setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag):
        return _data_management.SubtensorDescriptor_Float64_setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag)

    def saveOffsetLayout(self, layout):
        return _data_management.SubtensorDescriptor_Float64_saveOffsetLayout(self, layout)

    def saveOffsetLayoutCopy(self, layout):
        return _data_management.SubtensorDescriptor_Float64_saveOffsetLayoutCopy(self, layout)

    def getSize(self):
        return _data_management.SubtensorDescriptor_Float64_getSize(self)

    def getFixedDims(self):
        return _data_management.SubtensorDescriptor_Float64_getFixedDims(self)

    def getRangeDimIdx(self):
        return _data_management.SubtensorDescriptor_Float64_getRangeDimIdx(self)

    def getRangeDimNum(self):
        return _data_management.SubtensorDescriptor_Float64_getRangeDimNum(self)

    def getRWFlag(self):
        return _data_management.SubtensorDescriptor_Float64_getRWFlag(self)

    def getArray(self):
        return _data_management.SubtensorDescriptor_Float64_getArray(self)

    def getSubtensorDimSizes(self):
        return _data_management.SubtensorDescriptor_Float64_getSubtensorDimSizes(self)

    def getFixedDimNums(self):
        return _data_management.SubtensorDescriptor_Float64_getFixedDimNums(self)
SubtensorDescriptor_Float64_swigregister = _data_management.SubtensorDescriptor_Float64_swigregister
SubtensorDescriptor_Float64_swigregister(SubtensorDescriptor_Float64)

class SubtensorDescriptor_Float32(_object):
    r"""
This class is an alias of SubtensorDescriptor(ntype=float32)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubtensorDescriptor_Float32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubtensorDescriptor_Float32, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_SubtensorDescriptor_Float32()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_SubtensorDescriptor_Float32
    __del__ = lambda self: None

    def getNumberOfDims(self):
        return _data_management.SubtensorDescriptor_Float32_getNumberOfDims(self)

    def getLayout(self):
        return _data_management.SubtensorDescriptor_Float32_getLayout(self)

    def getInplaceFlag(self):
        return _data_management.SubtensorDescriptor_Float32_getInplaceFlag(self)

    def reset(self):
        return _data_management.SubtensorDescriptor_Float32_reset(self)

    def resizeBuffer(self):
        return _data_management.SubtensorDescriptor_Float32_resizeBuffer(self)

    def setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag):
        return _data_management.SubtensorDescriptor_Float32_setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag)

    def saveOffsetLayout(self, layout):
        return _data_management.SubtensorDescriptor_Float32_saveOffsetLayout(self, layout)

    def saveOffsetLayoutCopy(self, layout):
        return _data_management.SubtensorDescriptor_Float32_saveOffsetLayoutCopy(self, layout)

    def getSize(self):
        return _data_management.SubtensorDescriptor_Float32_getSize(self)

    def getFixedDims(self):
        return _data_management.SubtensorDescriptor_Float32_getFixedDims(self)

    def getRangeDimIdx(self):
        return _data_management.SubtensorDescriptor_Float32_getRangeDimIdx(self)

    def getRangeDimNum(self):
        return _data_management.SubtensorDescriptor_Float32_getRangeDimNum(self)

    def getRWFlag(self):
        return _data_management.SubtensorDescriptor_Float32_getRWFlag(self)

    def getArray(self):
        return _data_management.SubtensorDescriptor_Float32_getArray(self)

    def getSubtensorDimSizes(self):
        return _data_management.SubtensorDescriptor_Float32_getSubtensorDimSizes(self)

    def getFixedDimNums(self):
        return _data_management.SubtensorDescriptor_Float32_getFixedDimNums(self)
SubtensorDescriptor_Float32_swigregister = _data_management.SubtensorDescriptor_Float32_swigregister
SubtensorDescriptor_Float32_swigregister(SubtensorDescriptor_Float32)

class SubtensorDescriptor_Intc(_object):
    r"""
This class is an alias of SubtensorDescriptor(ntype=intc)
    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubtensorDescriptor_Intc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubtensorDescriptor_Intc, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _data_management.new_SubtensorDescriptor_Intc()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_SubtensorDescriptor_Intc
    __del__ = lambda self: None

    def getNumberOfDims(self):
        return _data_management.SubtensorDescriptor_Intc_getNumberOfDims(self)

    def getLayout(self):
        return _data_management.SubtensorDescriptor_Intc_getLayout(self)

    def getInplaceFlag(self):
        return _data_management.SubtensorDescriptor_Intc_getInplaceFlag(self)

    def reset(self):
        return _data_management.SubtensorDescriptor_Intc_reset(self)

    def resizeBuffer(self):
        return _data_management.SubtensorDescriptor_Intc_resizeBuffer(self)

    def setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag):
        return _data_management.SubtensorDescriptor_Intc_setDetails(self, tensorNDims, tensorDimNums, nFixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwFlag)

    def saveOffsetLayout(self, layout):
        return _data_management.SubtensorDescriptor_Intc_saveOffsetLayout(self, layout)

    def saveOffsetLayoutCopy(self, layout):
        return _data_management.SubtensorDescriptor_Intc_saveOffsetLayoutCopy(self, layout)

    def getSize(self):
        return _data_management.SubtensorDescriptor_Intc_getSize(self)

    def getFixedDims(self):
        return _data_management.SubtensorDescriptor_Intc_getFixedDims(self)

    def getRangeDimIdx(self):
        return _data_management.SubtensorDescriptor_Intc_getRangeDimIdx(self)

    def getRangeDimNum(self):
        return _data_management.SubtensorDescriptor_Intc_getRangeDimNum(self)

    def getRWFlag(self):
        return _data_management.SubtensorDescriptor_Intc_getRWFlag(self)

    def getArray(self):
        return _data_management.SubtensorDescriptor_Intc_getArray(self)

    def getSubtensorDimSizes(self):
        return _data_management.SubtensorDescriptor_Intc_getSubtensorDimSizes(self)

    def getFixedDimNums(self):
        return _data_management.SubtensorDescriptor_Intc_getFixedDimNums(self)
SubtensorDescriptor_Intc_swigregister = _data_management.SubtensorDescriptor_Intc_swigregister
SubtensorDescriptor_Intc_swigregister(SubtensorDescriptor_Intc)

class DataSourceTemplate_HomogenNumericTable_Float64Float64(DataSource):
    r"""
This class is an alias of DataSourceTemplate(TableType=daal.data_management.HomogenNumericTable_float64, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [DataSource]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceTemplate_HomogenNumericTable_Float64Float64, name, value)
    __swig_getmethods__ = {}
    for _s in [DataSource]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceTemplate_HomogenNumericTable_Float64Float64, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataSourceTemplate_HomogenNumericTable_Float64Float64
    __del__ = lambda self: None
DataSourceTemplate_HomogenNumericTable_Float64Float64_swigregister = _data_management.DataSourceTemplate_HomogenNumericTable_Float64Float64_swigregister
DataSourceTemplate_HomogenNumericTable_Float64Float64_swigregister(DataSourceTemplate_HomogenNumericTable_Float64Float64)

class DataSourceTemplate_HomogenNumericTable_Float32Float64(DataSource):
    r"""
This class is an alias of DataSourceTemplate(TableType=daal.data_management.HomogenNumericTable_float32, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [DataSource]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceTemplate_HomogenNumericTable_Float32Float64, name, value)
    __swig_getmethods__ = {}
    for _s in [DataSource]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceTemplate_HomogenNumericTable_Float32Float64, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataSourceTemplate_HomogenNumericTable_Float32Float64
    __del__ = lambda self: None
DataSourceTemplate_HomogenNumericTable_Float32Float64_swigregister = _data_management.DataSourceTemplate_HomogenNumericTable_Float32Float64_swigregister
DataSourceTemplate_HomogenNumericTable_Float32Float64_swigregister(DataSourceTemplate_HomogenNumericTable_Float32Float64)

class DataSourceTemplate_HomogenNumericTable_IntcFloat64(DataSource):
    r"""
This class is an alias of DataSourceTemplate(TableType=daal.data_management.HomogenNumericTable_intc, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [DataSource]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataSourceTemplate_HomogenNumericTable_IntcFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [DataSource]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataSourceTemplate_HomogenNumericTable_IntcFloat64, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _data_management.delete_DataSourceTemplate_HomogenNumericTable_IntcFloat64
    __del__ = lambda self: None
DataSourceTemplate_HomogenNumericTable_IntcFloat64_swigregister = _data_management.DataSourceTemplate_HomogenNumericTable_IntcFloat64_swigregister
DataSourceTemplate_HomogenNumericTable_IntcFloat64_swigregister(DataSourceTemplate_HomogenNumericTable_IntcFloat64)

class CsvDataSource_CSVFeatureManagerFloat64(DataSourceTemplate_HomogenNumericTable_Float64Float64):
    r"""
This class is an alias of CsvDataSource(FeatureManager=daal.data_management.CSVFeatureManager, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [DataSourceTemplate_HomogenNumericTable_Float64Float64]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsvDataSource_CSVFeatureManagerFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [DataSourceTemplate_HomogenNumericTable_Float64Float64]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CsvDataSource_CSVFeatureManagerFloat64, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def checkDictionary(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_checkDictionary(self)

    def checkNumericTable(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_checkNumericTable(self)

    def freeNumericTable(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_freeNumericTable(self)
    __swig_setmethods__["_dict"] = _data_management.CsvDataSource_CSVFeatureManagerFloat64__dict_set
    __swig_getmethods__["_dict"] = _data_management.CsvDataSource_CSVFeatureManagerFloat64__dict_get
    if _newclass:
        _dict = _swig_property(_data_management.CsvDataSource_CSVFeatureManagerFloat64__dict_get, _data_management.CsvDataSource_CSVFeatureManagerFloat64__dict_set)
    __swig_setmethods__["_initialMaxRows"] = _data_management.CsvDataSource_CSVFeatureManagerFloat64__initialMaxRows_set
    __swig_getmethods__["_initialMaxRows"] = _data_management.CsvDataSource_CSVFeatureManagerFloat64__initialMaxRows_get
    if _newclass:
        _initialMaxRows = _swig_property(_data_management.CsvDataSource_CSVFeatureManagerFloat64__initialMaxRows_get, _data_management.CsvDataSource_CSVFeatureManagerFloat64__initialMaxRows_set)
    __swig_destroy__ = _data_management.delete_CsvDataSource_CSVFeatureManagerFloat64
    __del__ = lambda self: None

    def getFeatureManager(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_getFeatureManager(self)

    def getNumericTableNumberOfColumns(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_getNumericTableNumberOfColumns(self)

    def setDictionary(self, dict):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_setDictionary(self, dict)

    def loadDataBlock(self, *args):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_loadDataBlock(self, *args)

    def createDictionaryFromContext(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_createDictionaryFromContext(self)

    def getNumberOfAvailableRows(self):
        return _data_management.CsvDataSource_CSVFeatureManagerFloat64_getNumberOfAvailableRows(self)
CsvDataSource_CSVFeatureManagerFloat64_swigregister = _data_management.CsvDataSource_CSVFeatureManagerFloat64_swigregister
CsvDataSource_CSVFeatureManagerFloat64_swigregister(CsvDataSource_CSVFeatureManagerFloat64)

class FileDataSource_CSVFeatureManagerFloat64(CsvDataSource_CSVFeatureManagerFloat64):
    r"""
This class is an alias of FileDataSource(FeatureManager=daal.data_management.CSVFeatureManager, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [CsvDataSource_CSVFeatureManagerFloat64]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileDataSource_CSVFeatureManagerFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [CsvDataSource_CSVFeatureManagerFloat64]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileDataSource_CSVFeatureManagerFloat64, name)
    __repr__ = _swig_repr

    def checkDictionary(self):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_checkDictionary(self)

    def checkNumericTable(self):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_checkNumericTable(self)

    def freeNumericTable(self):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_freeNumericTable(self)
    __swig_setmethods__["_dict"] = _data_management.FileDataSource_CSVFeatureManagerFloat64__dict_set
    __swig_getmethods__["_dict"] = _data_management.FileDataSource_CSVFeatureManagerFloat64__dict_get
    if _newclass:
        _dict = _swig_property(_data_management.FileDataSource_CSVFeatureManagerFloat64__dict_get, _data_management.FileDataSource_CSVFeatureManagerFloat64__dict_set)
    __swig_setmethods__["_initialMaxRows"] = _data_management.FileDataSource_CSVFeatureManagerFloat64__initialMaxRows_set
    __swig_getmethods__["_initialMaxRows"] = _data_management.FileDataSource_CSVFeatureManagerFloat64__initialMaxRows_get
    if _newclass:
        _initialMaxRows = _swig_property(_data_management.FileDataSource_CSVFeatureManagerFloat64__initialMaxRows_get, _data_management.FileDataSource_CSVFeatureManagerFloat64__initialMaxRows_set)

    def loadDataBlock(self, *args):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_loadDataBlock(self, *args)
    __swig_setmethods__["featureManager"] = _data_management.FileDataSource_CSVFeatureManagerFloat64_featureManager_set
    __swig_getmethods__["featureManager"] = _data_management.FileDataSource_CSVFeatureManagerFloat64_featureManager_get
    if _newclass:
        featureManager = _swig_property(_data_management.FileDataSource_CSVFeatureManagerFloat64_featureManager_get, _data_management.FileDataSource_CSVFeatureManagerFloat64_featureManager_set)

    def __init__(self, *args):
        this = _data_management.new_FileDataSource_CSVFeatureManagerFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_FileDataSource_CSVFeatureManagerFloat64
    __del__ = lambda self: None

    def createDictionaryFromContext(self):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_createDictionaryFromContext(self)

    def getStatus(self):
        return _data_management.FileDataSource_CSVFeatureManagerFloat64_getStatus(self)
FileDataSource_CSVFeatureManagerFloat64_swigregister = _data_management.FileDataSource_CSVFeatureManagerFloat64_swigregister
FileDataSource_CSVFeatureManagerFloat64_swigregister(FileDataSource_CSVFeatureManagerFloat64)

class PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedSymmetricMatrix, DataType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_releasePackedArray(self, *args)
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_swigregister = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_swigregister
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_swigregister(PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64)

def PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag():
    return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag()
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64_serializationTag

class PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedSymmetricMatrix, DataType=float32)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_releasePackedArray(self, *args)
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_swigregister = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_swigregister
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_swigregister(PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32)

def PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag():
    return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag()
PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32_serializationTag

class PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedSymmetricMatrix, DataType=intc)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_releasePackedArray(self, *args)
PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_swigregister = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_swigregister
PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_swigregister(PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc)

def PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag():
    return _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag()
PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag = _data_management.PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc_serializationTag

class PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedSymmetricMatrix, DataType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_releasePackedArray(self, *args)
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_swigregister = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_swigregister
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_swigregister(PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64)

def PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag():
    return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag()
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64_serializationTag

class PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedSymmetricMatrix, DataType=float32)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_releasePackedArray(self, *args)
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_swigregister = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_swigregister
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_swigregister(PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32)

def PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag():
    return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag()
PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32_serializationTag

class PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedSymmetricMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedSymmetricMatrix, DataType=intc)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc
    __del__ = lambda self: None

    def assign(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_releasePackedArray(self, *args)
PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_swigregister = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_swigregister
PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_swigregister(PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc)

def PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag():
    return _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag()
PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag = _data_management.PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc_serializationTag

class PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedTriangularMatrix, DataType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_releasePackedArray(self, *args)
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_swigregister = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_swigregister
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_swigregister(PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64)

def PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag():
    return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag()
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64_serializationTag

class PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedTriangularMatrix, DataType=float32)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_releasePackedArray(self, *args)
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_swigregister = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_swigregister
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_swigregister(PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32)

def PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag():
    return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag()
PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32_serializationTag

class PackedTriangularMatrix_UpperPackedTriangularMatrixIntc(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.upperPackedTriangularMatrix, DataType=intc)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixIntc, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_UpperPackedTriangularMatrixIntc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_UpperPackedTriangularMatrixIntc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_UpperPackedTriangularMatrixIntc
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_releasePackedArray(self, *args)
PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_swigregister = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_swigregister
PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_swigregister(PackedTriangularMatrix_UpperPackedTriangularMatrixIntc)

def PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag():
    return _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag()
PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag = _data_management.PackedTriangularMatrix_UpperPackedTriangularMatrixIntc_serializationTag

class PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedTriangularMatrix, DataType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_releasePackedArray(self, *args)
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_swigregister = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_swigregister
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_swigregister(PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64)

def PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag():
    return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag()
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64_serializationTag

class PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedTriangularMatrix, DataType=float32)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_releasePackedArray(self, *args)
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_swigregister = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_swigregister
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_swigregister(PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32)

def PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag():
    return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag()
PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32_serializationTag

class PackedTriangularMatrix_LowerPackedTriangularMatrixIntc(NumericTable, PackedArrayNumericTableIface):
    r"""
This class is an alias of PackedTriangularMatrix(packedLayout=daal.data_management.NumericTableIface.lowerPackedTriangularMatrix, DataType=intc)
    """
    __swig_setmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixIntc, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericTable, PackedArrayNumericTableIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PackedTriangularMatrix_LowerPackedTriangularMatrixIntc, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag)

    def getSerializationTag(self):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_PackedTriangularMatrix_LowerPackedTriangularMatrixIntc(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_PackedTriangularMatrix_LowerPackedTriangularMatrixIntc
    __del__ = lambda self: None

    def setNumberOfColumns(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_setNumberOfColumns(self, nDim)

    def setNumberOfRows(self, nDim):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_setNumberOfRows(self, nDim)

    def assign(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_assign(self, *args)

    def getBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_getBlockOfRows(self, *args)

    def releaseBlockOfRows(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_releaseBlockOfRows(self, *args)

    def getBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_getBlockOfColumnValues(self, *args)

    def releaseBlockOfColumnValues(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_releaseBlockOfColumnValues(self, *args)

    def getPackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_getPackedArray(self, *args)

    def releasePackedArray(self, *args):
        return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_releasePackedArray(self, *args)
PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_swigregister = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_swigregister
PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_swigregister(PackedTriangularMatrix_LowerPackedTriangularMatrixIntc)

def PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag():
    return _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag()
PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag = _data_management.PackedTriangularMatrix_LowerPackedTriangularMatrixIntc_serializationTag

class StringDataSource_CSVFeatureManagerFloat64(CsvDataSource_CSVFeatureManagerFloat64):
    r"""
This class is an alias of StringDataSource(FeatureManager=daal.data_management.CSVFeatureManager, StatsType=float64)
    """
    __swig_setmethods__ = {}
    for _s in [CsvDataSource_CSVFeatureManagerFloat64]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringDataSource_CSVFeatureManagerFloat64, name, value)
    __swig_getmethods__ = {}
    for _s in [CsvDataSource_CSVFeatureManagerFloat64]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StringDataSource_CSVFeatureManagerFloat64, name)
    __repr__ = _swig_repr

    def checkDictionary(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_checkDictionary(self)

    def checkNumericTable(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_checkNumericTable(self)

    def freeNumericTable(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_freeNumericTable(self)
    __swig_setmethods__["_dict"] = _data_management.StringDataSource_CSVFeatureManagerFloat64__dict_set
    __swig_getmethods__["_dict"] = _data_management.StringDataSource_CSVFeatureManagerFloat64__dict_get
    if _newclass:
        _dict = _swig_property(_data_management.StringDataSource_CSVFeatureManagerFloat64__dict_get, _data_management.StringDataSource_CSVFeatureManagerFloat64__dict_set)
    __swig_setmethods__["_initialMaxRows"] = _data_management.StringDataSource_CSVFeatureManagerFloat64__initialMaxRows_set
    __swig_getmethods__["_initialMaxRows"] = _data_management.StringDataSource_CSVFeatureManagerFloat64__initialMaxRows_get
    if _newclass:
        _initialMaxRows = _swig_property(_data_management.StringDataSource_CSVFeatureManagerFloat64__initialMaxRows_get, _data_management.StringDataSource_CSVFeatureManagerFloat64__initialMaxRows_set)

    def loadDataBlock(self, *args):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_loadDataBlock(self, *args)
    __swig_setmethods__["featureManager"] = _data_management.StringDataSource_CSVFeatureManagerFloat64_featureManager_set
    __swig_getmethods__["featureManager"] = _data_management.StringDataSource_CSVFeatureManagerFloat64_featureManager_get
    if _newclass:
        featureManager = _swig_property(_data_management.StringDataSource_CSVFeatureManagerFloat64_featureManager_get, _data_management.StringDataSource_CSVFeatureManagerFloat64_featureManager_set)

    def __init__(self, *args):
        this = _data_management.new_StringDataSource_CSVFeatureManagerFloat64(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_StringDataSource_CSVFeatureManagerFloat64
    __del__ = lambda self: None

    def setData(self, data):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_setData(self, data)

    def getData(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_getData(self)

    def resetData(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_resetData(self)

    def createDictionaryFromContext(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_createDictionaryFromContext(self)

    def getStatus(self):
        return _data_management.StringDataSource_CSVFeatureManagerFloat64_getStatus(self)
StringDataSource_CSVFeatureManagerFloat64_swigregister = _data_management.StringDataSource_CSVFeatureManagerFloat64_swigregister
StringDataSource_CSVFeatureManagerFloat64_swigregister(StringDataSource_CSVFeatureManagerFloat64)

class KeyValueDataCollection(SerializationIface, KeyValueCollection_SerializationIface):
    r"""
This class is an alias of SerializableKeyValueCollection(T=daal.data_management.SerializationIface)
    """
    __swig_setmethods__ = {}
    for _s in [SerializationIface, KeyValueCollection_SerializationIface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeyValueDataCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [SerializationIface, KeyValueCollection_SerializationIface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, KeyValueDataCollection, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _data_management.KeyValueDataCollection_serializationTag
    if _newclass:
        serializationTag = staticmethod(_data_management.KeyValueDataCollection_serializationTag)

    def getSerializationTag(self):
        return _data_management.KeyValueDataCollection_getSerializationTag(self)

    def __init__(self, *args):
        this = _data_management.new_KeyValueDataCollection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _data_management.delete_KeyValueDataCollection
    __del__ = lambda self: None
KeyValueDataCollection_swigregister = _data_management.KeyValueDataCollection_swigregister
KeyValueDataCollection_swigregister(KeyValueDataCollection)

def KeyValueDataCollection_serializationTag():
    return _data_management.KeyValueDataCollection_serializationTag()
KeyValueDataCollection_serializationTag = _data_management.KeyValueDataCollection_serializationTag

from numpy import float64, float32, intc

class HomogenTensor(object):
    r"""Factory class for different types of HomogenTensor."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return HomogenTensor_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return HomogenTensor_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return HomogenTensor_Intc(*args)

        raise RuntimeError("No appropriate constructor found for HomogenTensor")

class KeyValueCollection(object):
    r"""Factory class for different types of KeyValueCollection."""
    def __new__(cls,
                T,
                *args, **kwargs):
        if T == daal.data_management.SerializationIface:
            return KeyValueCollection_SerializationIface(*args)
        if T == daal.algorithms.Input:
            return KeyValueCollection_Input(*args)

        raise RuntimeError("No appropriate constructor found for KeyValueCollection")

class HomogenNumericTable(object):
    r"""Factory class for different types of HomogenNumericTable."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return HomogenNumericTable_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return HomogenNumericTable_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return HomogenNumericTable_Intc(*args)

        raise RuntimeError("No appropriate constructor found for HomogenNumericTable")

class StringDataSource(object):
    r"""Factory class for different types of StringDataSource."""
    def __new__(cls,
                *args, **kwargs):
        if 'FeatureManager' not in kwargs or kwargs['FeatureManager'] == daal.data_management.CSVFeatureManager:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return StringDataSource_CSVFeatureManagerFloat64(*args)

        raise RuntimeError("No appropriate constructor found for StringDataSource")

class PackedTriangularMatrix(object):
    r"""Factory class for different types of PackedTriangularMatrix."""
    def __new__(cls,
                packedLayout,
                *args, **kwargs):
        if packedLayout == daal.data_management.NumericTableIface.upperPackedTriangularMatrix:
            if 'DataType' not in kwargs or kwargs['DataType'] == float64:
                return PackedTriangularMatrix_UpperPackedTriangularMatrixFloat64(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == float32:
                return PackedTriangularMatrix_UpperPackedTriangularMatrixFloat32(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == intc:
                return PackedTriangularMatrix_UpperPackedTriangularMatrixIntc(*args)
        if packedLayout == daal.data_management.NumericTableIface.lowerPackedTriangularMatrix:
            if 'DataType' not in kwargs or kwargs['DataType'] == float64:
                return PackedTriangularMatrix_LowerPackedTriangularMatrixFloat64(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == float32:
                return PackedTriangularMatrix_LowerPackedTriangularMatrixFloat32(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == intc:
                return PackedTriangularMatrix_LowerPackedTriangularMatrixIntc(*args)

        raise RuntimeError("No appropriate constructor found for PackedTriangularMatrix")

class BlockDescriptor(object):
    r"""Factory class for different types of BlockDescriptor."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return BlockDescriptor_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return BlockDescriptor_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return BlockDescriptor_Intc(*args)

        raise RuntimeError("No appropriate constructor found for BlockDescriptor")

class SubtensorDescriptor(object):
    r"""Factory class for different types of SubtensorDescriptor."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return SubtensorDescriptor_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return SubtensorDescriptor_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return SubtensorDescriptor_Intc(*args)

        raise RuntimeError("No appropriate constructor found for SubtensorDescriptor")

class Compressor(object):
    r"""Factory class for different types of Compressor."""
    def __new__(cls,
                CompressionMethod,
                *args, **kwargs):
        if CompressionMethod == daal.data_management.bzip2:
            return Compressor_Bzip2(*args)
        if CompressionMethod == daal.data_management.lzo:
            return Compressor_Lzo(*args)
        if CompressionMethod == daal.data_management.rle:
            return Compressor_Rle(*args)
        if CompressionMethod == daal.data_management.zlib:
            return Compressor_Zlib(*args)

        raise RuntimeError("No appropriate constructor found for Compressor")

class CsvDataSource(object):
    r"""Factory class for different types of CsvDataSource."""
    def __new__(cls,
                *args, **kwargs):
        if 'FeatureManager' not in kwargs or kwargs['FeatureManager'] == daal.data_management.CSVFeatureManager:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return CsvDataSource_CSVFeatureManagerFloat64(*args)

        raise RuntimeError("No appropriate constructor found for CsvDataSource")

class DataSourceTemplate(object):
    r"""Factory class for different types of DataSourceTemplate."""
    def __new__(cls,
                TableType,
                *args, **kwargs):
        if TableType == daal.data_management.HomogenNumericTable_float64:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return DataSourceTemplate_HomogenNumericTable_Float64Float64(*args)
        if TableType == daal.data_management.HomogenNumericTable_float32:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return DataSourceTemplate_HomogenNumericTable_Float32Float64(*args)
        if TableType == daal.data_management.HomogenNumericTable_intc:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return DataSourceTemplate_HomogenNumericTable_IntcFloat64(*args)

        raise RuntimeError("No appropriate constructor found for DataSourceTemplate")

class PackedSymmetricMatrix(object):
    r"""Factory class for different types of PackedSymmetricMatrix."""
    def __new__(cls,
                packedLayout,
                *args, **kwargs):
        if packedLayout == daal.data_management.NumericTableIface.upperPackedSymmetricMatrix:
            if 'DataType' not in kwargs or kwargs['DataType'] == float64:
                return PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat64(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == float32:
                return PackedSymmetricMatrix_UpperPackedSymmetricMatrixFloat32(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == intc:
                return PackedSymmetricMatrix_UpperPackedSymmetricMatrixIntc(*args)
        if packedLayout == daal.data_management.NumericTableIface.lowerPackedSymmetricMatrix:
            if 'DataType' not in kwargs or kwargs['DataType'] == float64:
                return PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat64(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == float32:
                return PackedSymmetricMatrix_LowerPackedSymmetricMatrixFloat32(*args)
            if 'DataType' in kwargs and kwargs['DataType'] == intc:
                return PackedSymmetricMatrix_LowerPackedSymmetricMatrixIntc(*args)

        raise RuntimeError("No appropriate constructor found for PackedSymmetricMatrix")

class SerializableKeyValueCollection(object):
    r"""Factory class for different types of SerializableKeyValueCollection."""
    def __new__(cls,
                T,
                *args, **kwargs):
        if T == daal.data_management.SerializationIface:
            return SerializableKeyValueCollection_SerializationIface(*args)

        raise RuntimeError("No appropriate constructor found for SerializableKeyValueCollection")

class FileDataSource(object):
    r"""Factory class for different types of FileDataSource."""
    def __new__(cls,
                *args, **kwargs):
        if 'FeatureManager' not in kwargs or kwargs['FeatureManager'] == daal.data_management.CSVFeatureManager:
            if 'StatsType' not in kwargs or kwargs['StatsType'] == float64:
                return FileDataSource_CSVFeatureManagerFloat64(*args)

        raise RuntimeError("No appropriate constructor found for FileDataSource")

class CSRBlockDescriptor(object):
    r"""Factory class for different types of CSRBlockDescriptor."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return CSRBlockDescriptor_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return CSRBlockDescriptor_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return CSRBlockDescriptor_Intc(*args)

        raise RuntimeError("No appropriate constructor found for CSRBlockDescriptor")

class Decompressor(object):
    r"""Factory class for different types of Decompressor."""
    def __new__(cls,
                CompressionMethod,
                *args, **kwargs):
        if CompressionMethod == daal.data_management.bzip2:
            return Decompressor_Bzip2(*args)
        if CompressionMethod == daal.data_management.lzo:
            return Decompressor_Lzo(*args)
        if CompressionMethod == daal.data_management.rle:
            return Decompressor_Rle(*args)
        if CompressionMethod == daal.data_management.zlib:
            return Decompressor_Zlib(*args)

        raise RuntimeError("No appropriate constructor found for Decompressor")

class Matrix(object):
    r"""Factory class for different types of Matrix."""
    def __new__(cls,
                *args, **kwargs):
        if 'ntype' not in kwargs or kwargs['ntype'] == float64:
            return Matrix_Float64(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == float32:
            return Matrix_Float32(*args)
        if 'ntype' in kwargs and kwargs['ntype'] == intc:
            return Matrix_Intc(*args)

        raise RuntimeError("No appropriate constructor found for Matrix")


def convertToHomogen(ntable, ntype=float64):
    if ntype == float64:
        return convertToHomogen_Float64(ntable)
    elif ntype == float32:
        return convertToHomogen_Float32(ntable)
    elif ntype == intc:
        return convertToHomogen_Intc(ntable)
    else:
        raise TypeError("Cannot convert to HomogenNumericTable with data type {}".format(ntype))

# This file is compatible with both classic and new-style classes.


