# Copyright 2014-2017 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# 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('_init2', [dirname(__file__)])
        except ImportError:
            import _init2
            return _init2
        if fp is not None:
            try:
                _mod = imp.load_module('_init2', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _init2 = swig_import_helper()
    del swig_import_helper
else:
    import _init2
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 daal.algorithms
import daal.data_management
import daal
import daal.services
import daal.data_management.data_feature_utils

_init2.deterministicDense_swigconstant(_init2)
deterministicDense = _init2.deterministicDense

_init2.defaultDense_swigconstant(_init2)
defaultDense = _init2.defaultDense

_init2.randomDense_swigconstant(_init2)
randomDense = _init2.randomDense

_init2.plusPlusDense_swigconstant(_init2)
plusPlusDense = _init2.plusPlusDense

_init2.parallelPlusDense_swigconstant(_init2)
parallelPlusDense = _init2.parallelPlusDense

_init2.deterministicCSR_swigconstant(_init2)
deterministicCSR = _init2.deterministicCSR

_init2.randomCSR_swigconstant(_init2)
randomCSR = _init2.randomCSR

_init2.plusPlusCSR_swigconstant(_init2)
plusPlusCSR = _init2.plusPlusCSR

_init2.parallelPlusCSR_swigconstant(_init2)
parallelPlusCSR = _init2.parallelPlusCSR

_init2.data_swigconstant(_init2)
data = _init2.data

_init2.partialResults_swigconstant(_init2)
partialResults = _init2.partialResults

_init2.internalInput_swigconstant(_init2)
internalInput = _init2.internalInput

_init2.inputOfStep2_swigconstant(_init2)
inputOfStep2 = _init2.inputOfStep2

_init2.inputOfStep3FromStep2_swigconstant(_init2)
inputOfStep3FromStep2 = _init2.inputOfStep3FromStep2

_init2.inputOfStep4FromStep3_swigconstant(_init2)
inputOfStep4FromStep3 = _init2.inputOfStep4FromStep3

_init2.inputCentroids_swigconstant(_init2)
inputCentroids = _init2.inputCentroids

_init2.inputOfStep5FromStep2_swigconstant(_init2)
inputOfStep5FromStep2 = _init2.inputOfStep5FromStep2

_init2.inputOfStep5FromStep3_swigconstant(_init2)
inputOfStep5FromStep3 = _init2.inputOfStep5FromStep3

_init2.partialClustersNumber_swigconstant(_init2)
partialClustersNumber = _init2.partialClustersNumber

_init2.partialClusters_swigconstant(_init2)
partialClusters = _init2.partialClusters

_init2.outputOfStep2ForStep3_swigconstant(_init2)
outputOfStep2ForStep3 = _init2.outputOfStep2ForStep3

_init2.outputOfStep2ForStep5_swigconstant(_init2)
outputOfStep2ForStep5 = _init2.outputOfStep2ForStep5

_init2.internalResult_swigconstant(_init2)
internalResult = _init2.internalResult

_init2.outputOfStep3ForStep4_swigconstant(_init2)
outputOfStep3ForStep4 = _init2.outputOfStep3ForStep4

_init2.rngState_swigconstant(_init2)
rngState = _init2.rngState

_init2.outputOfStep3ForStep5_swigconstant(_init2)
outputOfStep3ForStep5 = _init2.outputOfStep3ForStep5

_init2.outputOfStep4_swigconstant(_init2)
outputOfStep4 = _init2.outputOfStep4

_init2.candidates_swigconstant(_init2)
candidates = _init2.candidates

_init2.weights_swigconstant(_init2)
weights = _init2.weights

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

    def __init__(self, *args):
        this = _init2.new_Parameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["nClusters"] = _init2.Parameter_nClusters_set
    __swig_getmethods__["nClusters"] = _init2.Parameter_nClusters_get
    if _newclass:
        nClusters = _swig_property(_init2.Parameter_nClusters_get, _init2.Parameter_nClusters_set)
    __swig_setmethods__["nRowsTotal"] = _init2.Parameter_nRowsTotal_set
    __swig_getmethods__["nRowsTotal"] = _init2.Parameter_nRowsTotal_get
    if _newclass:
        nRowsTotal = _swig_property(_init2.Parameter_nRowsTotal_get, _init2.Parameter_nRowsTotal_set)
    __swig_setmethods__["offset"] = _init2.Parameter_offset_set
    __swig_getmethods__["offset"] = _init2.Parameter_offset_get
    if _newclass:
        offset = _swig_property(_init2.Parameter_offset_get, _init2.Parameter_offset_set)
    __swig_setmethods__["seed"] = _init2.Parameter_seed_set
    __swig_getmethods__["seed"] = _init2.Parameter_seed_get
    if _newclass:
        seed = _swig_property(_init2.Parameter_seed_get, _init2.Parameter_seed_set)
    __swig_setmethods__["oversamplingFactor"] = _init2.Parameter_oversamplingFactor_set
    __swig_getmethods__["oversamplingFactor"] = _init2.Parameter_oversamplingFactor_get
    if _newclass:
        oversamplingFactor = _swig_property(_init2.Parameter_oversamplingFactor_get, _init2.Parameter_oversamplingFactor_set)
    __swig_setmethods__["nRounds"] = _init2.Parameter_nRounds_set
    __swig_getmethods__["nRounds"] = _init2.Parameter_nRounds_get
    if _newclass:
        nRounds = _swig_property(_init2.Parameter_nRounds_get, _init2.Parameter_nRounds_set)

    def check(self):
        return _init2.Parameter_check(self)
    __swig_destroy__ = _init2.delete_Parameter
    __del__ = lambda self: None
Parameter_swigregister = _init2.Parameter_swigregister
Parameter_swigregister(Parameter)

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

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

    def getNumberOfFeatures(self):
        return _init2.InputIface_getNumberOfFeatures(self)
    __swig_destroy__ = _init2.delete_InputIface
    __del__ = lambda self: None
InputIface_swigregister = _init2.InputIface_swigregister
InputIface_swigregister(InputIface)

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

    def __init__(self):
        this = _init2.new_Input()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_Input
    __del__ = lambda self: None

    def get(self, id):
        return _init2.Input_get(self, id)

    def set(self, id, ptr):
        return _init2.Input_set(self, id, ptr)

    def getNumberOfFeatures(self):
        return _init2.Input_getNumberOfFeatures(self)

    def check(self, par, method):
        return _init2.Input_check(self, par, method)
Input_swigregister = _init2.Input_swigregister
Input_swigregister(Input)

class PartialResult(daal.algorithms.PartialResult):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PartialResult, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PartialResult, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.PartialResult_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.PartialResult_serializationTag)

    def getSerializationTag(self):
        return _init2.PartialResult_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_PartialResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_PartialResult
    __del__ = lambda self: None

    def get(self, id):
        return _init2.PartialResult_get(self, id)

    def set(self, id, ptr):
        return _init2.PartialResult_set(self, id, ptr)

    def getNumberOfFeatures(self):
        return _init2.PartialResult_getNumberOfFeatures(self)

    def check(self, *args):
        return _init2.PartialResult_check(self, *args)

    def allocate_Float64(self, input, parameter, method):
        r"""
This function is specialized for float64"""
        return _init2.PartialResult_allocate_Float64(self, input, parameter, method)


    def allocate_Float32(self, input, parameter, method):
        r"""
This function is specialized for float32"""
        return _init2.PartialResult_allocate_Float32(self, input, parameter, method)

PartialResult_swigregister = _init2.PartialResult_swigregister
PartialResult_swigregister(PartialResult)

def PartialResult_serializationTag():
    return _init2.PartialResult_serializationTag()
PartialResult_serializationTag = _init2.PartialResult_serializationTag

class Result(daal.algorithms.Result):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Result]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Result, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Result]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Result, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.Result_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.Result_serializationTag)

    def getSerializationTag(self):
        return _init2.Result_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_Result()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_Result
    __del__ = lambda self: None

    def get(self, id):
        return _init2.Result_get(self, id)

    def set(self, id, ptr):
        return _init2.Result_set(self, id, ptr)

    def check(self, *args):
        return _init2.Result_check(self, *args)

    def allocate_Float64(self, *args):
        r"""
This function is specialized for float64"""
        return _init2.Result_allocate_Float64(self, *args)


    def allocate_Float32(self, *args):
        r"""
This function is specialized for float32"""
        return _init2.Result_allocate_Float32(self, *args)

Result_swigregister = _init2.Result_swigregister
Result_swigregister(Result)

def Result_serializationTag():
    return _init2.Result_serializationTag()
Result_serializationTag = _init2.Result_serializationTag

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

    def __init__(self):
        this = _init2.new_DistributedStep2MasterInput()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep2MasterInput
    __del__ = lambda self: None

    def get(self, id):
        return _init2.DistributedStep2MasterInput_get(self, id)

    def set(self, id, ptr):
        return _init2.DistributedStep2MasterInput_set(self, id, ptr)

    def add(self, id, value):
        return _init2.DistributedStep2MasterInput_add(self, id, value)

    def getNumberOfFeatures(self):
        return _init2.DistributedStep2MasterInput_getNumberOfFeatures(self)

    def check(self, par, method):
        return _init2.DistributedStep2MasterInput_check(self, par, method)
DistributedStep2MasterInput_swigregister = _init2.DistributedStep2MasterInput_swigregister
DistributedStep2MasterInput_swigregister(DistributedStep2MasterInput)

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

    def __init__(self, *args):
        this = _init2.new_DistributedStep2LocalPlusPlusParameter(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["firstIteration"] = _init2.DistributedStep2LocalPlusPlusParameter_firstIteration_set
    __swig_getmethods__["firstIteration"] = _init2.DistributedStep2LocalPlusPlusParameter_firstIteration_get
    if _newclass:
        firstIteration = _swig_property(_init2.DistributedStep2LocalPlusPlusParameter_firstIteration_get, _init2.DistributedStep2LocalPlusPlusParameter_firstIteration_set)
    __swig_setmethods__["outputForStep5Required"] = _init2.DistributedStep2LocalPlusPlusParameter_outputForStep5Required_set
    __swig_getmethods__["outputForStep5Required"] = _init2.DistributedStep2LocalPlusPlusParameter_outputForStep5Required_get
    if _newclass:
        outputForStep5Required = _swig_property(_init2.DistributedStep2LocalPlusPlusParameter_outputForStep5Required_get, _init2.DistributedStep2LocalPlusPlusParameter_outputForStep5Required_set)

    def check(self):
        return _init2.DistributedStep2LocalPlusPlusParameter_check(self)
    __swig_destroy__ = _init2.delete_DistributedStep2LocalPlusPlusParameter
    __del__ = lambda self: None
DistributedStep2LocalPlusPlusParameter_swigregister = _init2.DistributedStep2LocalPlusPlusParameter_swigregister
DistributedStep2LocalPlusPlusParameter_swigregister(DistributedStep2LocalPlusPlusParameter)

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

    def __init__(self, *args):
        this = _init2.new_DistributedStep2LocalPlusPlusInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep2LocalPlusPlusInput
    __del__ = lambda self: None

    def get(self, id):
        return _init2.DistributedStep2LocalPlusPlusInput_get(self, id)

    def getData(self, id):
        return _init2.DistributedStep2LocalPlusPlusInput_getData(self, id)

    def set(self, *args):
        return _init2.DistributedStep2LocalPlusPlusInput_set(self, *args)

    def getTable(self, id):
        return _init2.DistributedStep2LocalPlusPlusInput_getTable(self, id)

    def setTable(self, id, ptr):
        return _init2.DistributedStep2LocalPlusPlusInput_setTable(self, id, ptr)

    def check(self, par, method):
        return _init2.DistributedStep2LocalPlusPlusInput_check(self, par, method)
DistributedStep2LocalPlusPlusInput_swigregister = _init2.DistributedStep2LocalPlusPlusInput_swigregister
DistributedStep2LocalPlusPlusInput_swigregister(DistributedStep2LocalPlusPlusInput)

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

    def __init__(self, *args):
        this = _init2.new_DistributedStep3MasterPlusPlusInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get(self, id):
        return _init2.DistributedStep3MasterPlusPlusInput_get(self, id)

    def set(self, id, ptr):
        return _init2.DistributedStep3MasterPlusPlusInput_set(self, id, ptr)

    def add(self, id, key, ptr):
        return _init2.DistributedStep3MasterPlusPlusInput_add(self, id, key, ptr)

    def check(self, par, method):
        return _init2.DistributedStep3MasterPlusPlusInput_check(self, par, method)
    __swig_destroy__ = _init2.delete_DistributedStep3MasterPlusPlusInput
    __del__ = lambda self: None
DistributedStep3MasterPlusPlusInput_swigregister = _init2.DistributedStep3MasterPlusPlusInput_swigregister
DistributedStep3MasterPlusPlusInput_swigregister(DistributedStep3MasterPlusPlusInput)

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

    def __init__(self, *args):
        this = _init2.new_DistributedStep4LocalPlusPlusInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get(self, id):
        return _init2.DistributedStep4LocalPlusPlusInput_get(self, id)

    def getData(self, id):
        return _init2.DistributedStep4LocalPlusPlusInput_getData(self, id)

    def set(self, *args):
        return _init2.DistributedStep4LocalPlusPlusInput_set(self, *args)

    def getTable(self, id):
        return _init2.DistributedStep4LocalPlusPlusInput_getTable(self, id)

    def setTable(self, id, ptr):
        return _init2.DistributedStep4LocalPlusPlusInput_setTable(self, id, ptr)

    def check(self, par, method):
        return _init2.DistributedStep4LocalPlusPlusInput_check(self, par, method)
    __swig_destroy__ = _init2.delete_DistributedStep4LocalPlusPlusInput
    __del__ = lambda self: None
DistributedStep4LocalPlusPlusInput_swigregister = _init2.DistributedStep4LocalPlusPlusInput_swigregister
DistributedStep4LocalPlusPlusInput_swigregister(DistributedStep4LocalPlusPlusInput)

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

    def __init__(self, *args):
        this = _init2.new_DistributedStep5MasterPlusPlusInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep5MasterPlusPlusInput
    __del__ = lambda self: None

    def get(self, id):
        return _init2.DistributedStep5MasterPlusPlusInput_get(self, id)

    def add(self, id, value):
        return _init2.DistributedStep5MasterPlusPlusInput_add(self, id, value)

    def getData(self, id):
        return _init2.DistributedStep5MasterPlusPlusInput_getData(self, id)

    def set(self, *args):
        return _init2.DistributedStep5MasterPlusPlusInput_set(self, *args)

    def check(self, par, method):
        return _init2.DistributedStep5MasterPlusPlusInput_check(self, par, method)
DistributedStep5MasterPlusPlusInput_swigregister = _init2.DistributedStep5MasterPlusPlusInput_swigregister
DistributedStep5MasterPlusPlusInput_swigregister(DistributedStep5MasterPlusPlusInput)

class DistributedStep2LocalPlusPlusPartialResult(daal.algorithms.PartialResult):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributedStep2LocalPlusPlusPartialResult, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributedStep2LocalPlusPlusPartialResult, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.DistributedStep2LocalPlusPlusPartialResult_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.DistributedStep2LocalPlusPlusPartialResult_serializationTag)

    def getSerializationTag(self):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_DistributedStep2LocalPlusPlusPartialResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep2LocalPlusPlusPartialResult
    __del__ = lambda self: None

    def getTable(self, id):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_getTable(self, id)

    def getData(self, id):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_getData(self, id)

    def set(self, *args):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_set(self, *args)

    def check(self, *args):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_check(self, *args)

    def initialize(self, input, par, method):
        return _init2.DistributedStep2LocalPlusPlusPartialResult_initialize(self, input, par, method)

    def allocate_Float64(self, input, parameter, method):
        r"""
This function is specialized for float64"""
        return _init2.DistributedStep2LocalPlusPlusPartialResult_allocate_Float64(self, input, parameter, method)


    def allocate_Float32(self, input, parameter, method):
        r"""
This function is specialized for float32"""
        return _init2.DistributedStep2LocalPlusPlusPartialResult_allocate_Float32(self, input, parameter, method)

DistributedStep2LocalPlusPlusPartialResult_swigregister = _init2.DistributedStep2LocalPlusPlusPartialResult_swigregister
DistributedStep2LocalPlusPlusPartialResult_swigregister(DistributedStep2LocalPlusPlusPartialResult)

def DistributedStep2LocalPlusPlusPartialResult_serializationTag():
    return _init2.DistributedStep2LocalPlusPlusPartialResult_serializationTag()
DistributedStep2LocalPlusPlusPartialResult_serializationTag = _init2.DistributedStep2LocalPlusPlusPartialResult_serializationTag

class DistributedStep3MasterPlusPlusPartialResult(daal.algorithms.PartialResult):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributedStep3MasterPlusPlusPartialResult, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributedStep3MasterPlusPlusPartialResult, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.DistributedStep3MasterPlusPlusPartialResult_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.DistributedStep3MasterPlusPlusPartialResult_serializationTag)

    def getSerializationTag(self):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_DistributedStep3MasterPlusPlusPartialResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep3MasterPlusPlusPartialResult
    __del__ = lambda self: None

    def get(self, *args):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_get(self, *args)

    def getData(self, id):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_getData(self, id)

    def add(self, id, key, ptr):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_add(self, id, key, ptr)

    def check(self, *args):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_check(self, *args)

    def initialize(self, input, par, method):
        return _init2.DistributedStep3MasterPlusPlusPartialResult_initialize(self, input, par, method)

    def allocate_Float64(self, input, parameter, method):
        r"""
This function is specialized for float64"""
        return _init2.DistributedStep3MasterPlusPlusPartialResult_allocate_Float64(self, input, parameter, method)


    def allocate_Float32(self, input, parameter, method):
        r"""
This function is specialized for float32"""
        return _init2.DistributedStep3MasterPlusPlusPartialResult_allocate_Float32(self, input, parameter, method)

DistributedStep3MasterPlusPlusPartialResult_swigregister = _init2.DistributedStep3MasterPlusPlusPartialResult_swigregister
DistributedStep3MasterPlusPlusPartialResult_swigregister(DistributedStep3MasterPlusPlusPartialResult)

def DistributedStep3MasterPlusPlusPartialResult_serializationTag():
    return _init2.DistributedStep3MasterPlusPlusPartialResult_serializationTag()
DistributedStep3MasterPlusPlusPartialResult_serializationTag = _init2.DistributedStep3MasterPlusPlusPartialResult_serializationTag

class DistributedStep4LocalPlusPlusPartialResult(daal.algorithms.PartialResult):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributedStep4LocalPlusPlusPartialResult, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributedStep4LocalPlusPlusPartialResult, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.DistributedStep4LocalPlusPlusPartialResult_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.DistributedStep4LocalPlusPlusPartialResult_serializationTag)

    def getSerializationTag(self):
        return _init2.DistributedStep4LocalPlusPlusPartialResult_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_DistributedStep4LocalPlusPlusPartialResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep4LocalPlusPlusPartialResult
    __del__ = lambda self: None

    def get(self, id):
        return _init2.DistributedStep4LocalPlusPlusPartialResult_get(self, id)

    def set(self, id, ptr):
        return _init2.DistributedStep4LocalPlusPlusPartialResult_set(self, id, ptr)

    def check(self, *args):
        return _init2.DistributedStep4LocalPlusPlusPartialResult_check(self, *args)

    def allocate_Float64(self, input, parameter, method):
        r"""
This function is specialized for float64"""
        return _init2.DistributedStep4LocalPlusPlusPartialResult_allocate_Float64(self, input, parameter, method)


    def allocate_Float32(self, input, parameter, method):
        r"""
This function is specialized for float32"""
        return _init2.DistributedStep4LocalPlusPlusPartialResult_allocate_Float32(self, input, parameter, method)

DistributedStep4LocalPlusPlusPartialResult_swigregister = _init2.DistributedStep4LocalPlusPlusPartialResult_swigregister
DistributedStep4LocalPlusPlusPartialResult_swigregister(DistributedStep4LocalPlusPlusPartialResult)

def DistributedStep4LocalPlusPlusPartialResult_serializationTag():
    return _init2.DistributedStep4LocalPlusPlusPartialResult_serializationTag()
DistributedStep4LocalPlusPlusPartialResult_serializationTag = _init2.DistributedStep4LocalPlusPlusPartialResult_serializationTag

class DistributedStep5MasterPlusPlusPartialResult(daal.algorithms.PartialResult):
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributedStep5MasterPlusPlusPartialResult, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.PartialResult]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributedStep5MasterPlusPlusPartialResult, name)
    __repr__ = _swig_repr
    __swig_getmethods__["serializationTag"] = lambda x: _init2.DistributedStep5MasterPlusPlusPartialResult_serializationTag
    if _newclass:
        serializationTag = staticmethod(_init2.DistributedStep5MasterPlusPlusPartialResult_serializationTag)

    def getSerializationTag(self):
        return _init2.DistributedStep5MasterPlusPlusPartialResult_getSerializationTag(self)

    def __init__(self):
        this = _init2.new_DistributedStep5MasterPlusPlusPartialResult()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _init2.delete_DistributedStep5MasterPlusPlusPartialResult
    __del__ = lambda self: None

    def get(self, id):
        return _init2.DistributedStep5MasterPlusPlusPartialResult_get(self, id)

    def set(self, id, ptr):
        return _init2.DistributedStep5MasterPlusPlusPartialResult_set(self, id, ptr)

    def check(self, *args):
        return _init2.DistributedStep5MasterPlusPlusPartialResult_check(self, *args)

    def allocate_Float64(self, input, parameter, method):
        r"""
This function is specialized for float64"""
        return _init2.DistributedStep5MasterPlusPlusPartialResult_allocate_Float64(self, input, parameter, method)


    def allocate_Float32(self, input, parameter, method):
        r"""
This function is specialized for float32"""
        return _init2.DistributedStep5MasterPlusPlusPartialResult_allocate_Float32(self, input, parameter, method)

DistributedStep5MasterPlusPlusPartialResult_swigregister = _init2.DistributedStep5MasterPlusPlusPartialResult_swigregister
DistributedStep5MasterPlusPlusPartialResult_swigregister(DistributedStep5MasterPlusPlusPartialResult)

def DistributedStep5MasterPlusPlusPartialResult_serializationTag():
    return _init2.DistributedStep5MasterPlusPlusPartialResult_serializationTag()
DistributedStep5MasterPlusPlusPartialResult_serializationTag = _init2.DistributedStep5MasterPlusPlusPartialResult_serializationTag

class Batch_Float64DeterministicDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64DeterministicDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64DeterministicDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64DeterministicDense_input_get, _init2.Batch_Float64DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64DeterministicDense_parameter_get, _init2.Batch_Float64DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float64DeterministicDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64DeterministicDense
    __del__ = lambda self: None
Batch_Float64DeterministicDense_swigregister = _init2.Batch_Float64DeterministicDense_swigregister
Batch_Float64DeterministicDense_swigregister(Batch_Float64DeterministicDense)

class Batch_Float64RandomDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64RandomDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64RandomDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64RandomDense_input_get, _init2.Batch_Float64RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64RandomDense_parameter_get, _init2.Batch_Float64RandomDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float64RandomDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64RandomDense
    __del__ = lambda self: None
Batch_Float64RandomDense_swigregister = _init2.Batch_Float64RandomDense_swigregister
Batch_Float64RandomDense_swigregister(Batch_Float64RandomDense)

class Batch_Float64PlusPlusDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64PlusPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64PlusPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64PlusPlusDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64PlusPlusDense_input_get, _init2.Batch_Float64PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64PlusPlusDense_parameter_get, _init2.Batch_Float64PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float64PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64PlusPlusDense
    __del__ = lambda self: None
Batch_Float64PlusPlusDense_swigregister = _init2.Batch_Float64PlusPlusDense_swigregister
Batch_Float64PlusPlusDense_swigregister(Batch_Float64PlusPlusDense)

class Batch_Float64RandomCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64RandomCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64RandomCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64RandomCSR_input_get, _init2.Batch_Float64RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64RandomCSR_parameter_get, _init2.Batch_Float64RandomCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float64RandomCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64RandomCSR
    __del__ = lambda self: None
Batch_Float64RandomCSR_swigregister = _init2.Batch_Float64RandomCSR_swigregister
Batch_Float64RandomCSR_swigregister(Batch_Float64RandomCSR)

class Batch_Float64ParallelPlusDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64ParallelPlusDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64ParallelPlusDense_input_get, _init2.Batch_Float64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64ParallelPlusDense_parameter_get, _init2.Batch_Float64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float64ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64ParallelPlusDense
    __del__ = lambda self: None
Batch_Float64ParallelPlusDense_swigregister = _init2.Batch_Float64ParallelPlusDense_swigregister
Batch_Float64ParallelPlusDense_swigregister(Batch_Float64ParallelPlusDense)

class Batch_Float64ParallelPlusCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64ParallelPlusCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64ParallelPlusCSR_input_get, _init2.Batch_Float64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64ParallelPlusCSR_parameter_get, _init2.Batch_Float64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float64ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64ParallelPlusCSR
    __del__ = lambda self: None
Batch_Float64ParallelPlusCSR_swigregister = _init2.Batch_Float64ParallelPlusCSR_swigregister
Batch_Float64ParallelPlusCSR_swigregister(Batch_Float64ParallelPlusCSR)

class Batch_Float64DeterministicCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64DeterministicCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64DeterministicCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64DeterministicCSR_input_get, _init2.Batch_Float64DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64DeterministicCSR_parameter_get, _init2.Batch_Float64DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float64DeterministicCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64DeterministicCSR
    __del__ = lambda self: None
Batch_Float64DeterministicCSR_swigregister = _init2.Batch_Float64DeterministicCSR_swigregister
Batch_Float64DeterministicCSR_swigregister(Batch_Float64DeterministicCSR)

class Batch_Float64PlusPlusCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float64PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float64PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float64PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float64PlusPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float64PlusPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float64PlusPlusCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float64PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float64PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float64PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float64PlusPlusCSR_input_get, _init2.Batch_Float64PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float64PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float64PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float64PlusPlusCSR_parameter_get, _init2.Batch_Float64PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float64PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float64PlusPlusCSR
    __del__ = lambda self: None
Batch_Float64PlusPlusCSR_swigregister = _init2.Batch_Float64PlusPlusCSR_swigregister
Batch_Float64PlusPlusCSR_swigregister(Batch_Float64PlusPlusCSR)

class Batch_Float32DeterministicDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32DeterministicDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32DeterministicDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32DeterministicDense_input_get, _init2.Batch_Float32DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32DeterministicDense_parameter_get, _init2.Batch_Float32DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float32DeterministicDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32DeterministicDense
    __del__ = lambda self: None
Batch_Float32DeterministicDense_swigregister = _init2.Batch_Float32DeterministicDense_swigregister
Batch_Float32DeterministicDense_swigregister(Batch_Float32DeterministicDense)

class Batch_Float32RandomDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32RandomDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32RandomDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32RandomDense_input_get, _init2.Batch_Float32RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32RandomDense_parameter_get, _init2.Batch_Float32RandomDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float32RandomDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32RandomDense
    __del__ = lambda self: None
Batch_Float32RandomDense_swigregister = _init2.Batch_Float32RandomDense_swigregister
Batch_Float32RandomDense_swigregister(Batch_Float32RandomDense)

class Batch_Float32PlusPlusDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32PlusPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32PlusPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32PlusPlusDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32PlusPlusDense_input_get, _init2.Batch_Float32PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32PlusPlusDense_parameter_get, _init2.Batch_Float32PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float32PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32PlusPlusDense
    __del__ = lambda self: None
Batch_Float32PlusPlusDense_swigregister = _init2.Batch_Float32PlusPlusDense_swigregister
Batch_Float32PlusPlusDense_swigregister(Batch_Float32PlusPlusDense)

class Batch_Float32RandomCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32RandomCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32RandomCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32RandomCSR_input_get, _init2.Batch_Float32RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32RandomCSR_parameter_get, _init2.Batch_Float32RandomCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float32RandomCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32RandomCSR
    __del__ = lambda self: None
Batch_Float32RandomCSR_swigregister = _init2.Batch_Float32RandomCSR_swigregister
Batch_Float32RandomCSR_swigregister(Batch_Float32RandomCSR)

class Batch_Float32ParallelPlusDense(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32ParallelPlusDense_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32ParallelPlusDense_input_get, _init2.Batch_Float32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32ParallelPlusDense_parameter_get, _init2.Batch_Float32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Batch_Float32ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32ParallelPlusDense
    __del__ = lambda self: None
Batch_Float32ParallelPlusDense_swigregister = _init2.Batch_Float32ParallelPlusDense_swigregister
Batch_Float32ParallelPlusDense_swigregister(Batch_Float32ParallelPlusDense)

class Batch_Float32ParallelPlusCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32ParallelPlusCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32ParallelPlusCSR_input_get, _init2.Batch_Float32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32ParallelPlusCSR_parameter_get, _init2.Batch_Float32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float32ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32ParallelPlusCSR
    __del__ = lambda self: None
Batch_Float32ParallelPlusCSR_swigregister = _init2.Batch_Float32ParallelPlusCSR_swigregister
Batch_Float32ParallelPlusCSR_swigregister(Batch_Float32ParallelPlusCSR)

class Batch_Float32DeterministicCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32DeterministicCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32DeterministicCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32DeterministicCSR_input_get, _init2.Batch_Float32DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32DeterministicCSR_parameter_get, _init2.Batch_Float32DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float32DeterministicCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32DeterministicCSR
    __del__ = lambda self: None
Batch_Float32DeterministicCSR_swigregister = _init2.Batch_Float32DeterministicCSR_swigregister
Batch_Float32DeterministicCSR_swigregister(Batch_Float32DeterministicCSR)

class Batch_Float32PlusPlusCSR(daal.algorithms.Analysis_Batch):
    r"""
This class is an alias of Batch(fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Batch_Float32PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Batch]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Batch_Float32PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Batch_Float32PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Batch_Float32PlusPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Batch_Float32PlusPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Batch_Float32PlusPlusCSR_setResult(self, result)

    def clone(self):
        return _init2.Batch_Float32PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Batch_Float32PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Batch_Float32PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Batch_Float32PlusPlusCSR_input_get, _init2.Batch_Float32PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Batch_Float32PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Batch_Float32PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Batch_Float32PlusPlusCSR_parameter_get, _init2.Batch_Float32PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Batch_Float32PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Batch_Float32PlusPlusCSR
    __del__ = lambda self: None
Batch_Float32PlusPlusCSR_swigregister = _init2.Batch_Float32PlusPlusCSR_swigregister
Batch_Float32PlusPlusCSR_swigregister(Batch_Float32PlusPlusCSR)

class Distributed_Step1LocalFloat64DeterministicDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64DeterministicDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64DeterministicDense_input_get, _init2.Distributed_Step1LocalFloat64DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64DeterministicDense_parameter_get, _init2.Distributed_Step1LocalFloat64DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64DeterministicDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat64DeterministicDense_swigregister = _init2.Distributed_Step1LocalFloat64DeterministicDense_swigregister
Distributed_Step1LocalFloat64DeterministicDense_swigregister(Distributed_Step1LocalFloat64DeterministicDense)

class Distributed_Step1LocalFloat64DeterministicCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64DeterministicCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64DeterministicCSR_input_get, _init2.Distributed_Step1LocalFloat64DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64DeterministicCSR_parameter_get, _init2.Distributed_Step1LocalFloat64DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64DeterministicCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64DeterministicCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat64DeterministicCSR_swigregister = _init2.Distributed_Step1LocalFloat64DeterministicCSR_swigregister
Distributed_Step1LocalFloat64DeterministicCSR_swigregister(Distributed_Step1LocalFloat64DeterministicCSR)

class Distributed_Step1LocalFloat64RandomDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64RandomDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64RandomDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64RandomDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64RandomDense_input_get, _init2.Distributed_Step1LocalFloat64RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64RandomDense_parameter_get, _init2.Distributed_Step1LocalFloat64RandomDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64RandomDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64RandomDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat64RandomDense_swigregister = _init2.Distributed_Step1LocalFloat64RandomDense_swigregister
Distributed_Step1LocalFloat64RandomDense_swigregister(Distributed_Step1LocalFloat64RandomDense)

class Distributed_Step1LocalFloat64RandomCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64RandomCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64RandomCSR_input_get, _init2.Distributed_Step1LocalFloat64RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64RandomCSR_parameter_get, _init2.Distributed_Step1LocalFloat64RandomCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64RandomCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64RandomCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat64RandomCSR_swigregister = _init2.Distributed_Step1LocalFloat64RandomCSR_swigregister
Distributed_Step1LocalFloat64RandomCSR_swigregister(Distributed_Step1LocalFloat64RandomCSR)

class Distributed_Step1LocalFloat64PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64PlusPlusDense_input_get, _init2.Distributed_Step1LocalFloat64PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64PlusPlusDense_parameter_get, _init2.Distributed_Step1LocalFloat64PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64PlusPlusDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat64PlusPlusDense_swigregister = _init2.Distributed_Step1LocalFloat64PlusPlusDense_swigregister
Distributed_Step1LocalFloat64PlusPlusDense_swigregister(Distributed_Step1LocalFloat64PlusPlusDense)

class Distributed_Step1LocalFloat64PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64PlusPlusCSR_input_get, _init2.Distributed_Step1LocalFloat64PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64PlusPlusCSR_parameter_get, _init2.Distributed_Step1LocalFloat64PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64PlusPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat64PlusPlusCSR_swigregister = _init2.Distributed_Step1LocalFloat64PlusPlusCSR_swigregister
Distributed_Step1LocalFloat64PlusPlusCSR_swigregister(Distributed_Step1LocalFloat64PlusPlusCSR)

class Distributed_Step1LocalFloat64ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64ParallelPlusDense_input_get, _init2.Distributed_Step1LocalFloat64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64ParallelPlusDense_parameter_get, _init2.Distributed_Step1LocalFloat64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat64ParallelPlusDense_swigregister = _init2.Distributed_Step1LocalFloat64ParallelPlusDense_swigregister
Distributed_Step1LocalFloat64ParallelPlusDense_swigregister(Distributed_Step1LocalFloat64ParallelPlusDense)

class Distributed_Step1LocalFloat64ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat64ParallelPlusCSR_input_get, _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat64ParallelPlusCSR_parameter_get, _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat64ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat64ParallelPlusCSR_swigregister = _init2.Distributed_Step1LocalFloat64ParallelPlusCSR_swigregister
Distributed_Step1LocalFloat64ParallelPlusCSR_swigregister(Distributed_Step1LocalFloat64ParallelPlusCSR)

class Distributed_Step1LocalFloat32DeterministicDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32DeterministicDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32DeterministicDense_input_get, _init2.Distributed_Step1LocalFloat32DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32DeterministicDense_parameter_get, _init2.Distributed_Step1LocalFloat32DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32DeterministicDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat32DeterministicDense_swigregister = _init2.Distributed_Step1LocalFloat32DeterministicDense_swigregister
Distributed_Step1LocalFloat32DeterministicDense_swigregister(Distributed_Step1LocalFloat32DeterministicDense)

class Distributed_Step1LocalFloat32DeterministicCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32DeterministicCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32DeterministicCSR_input_get, _init2.Distributed_Step1LocalFloat32DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32DeterministicCSR_parameter_get, _init2.Distributed_Step1LocalFloat32DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32DeterministicCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32DeterministicCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat32DeterministicCSR_swigregister = _init2.Distributed_Step1LocalFloat32DeterministicCSR_swigregister
Distributed_Step1LocalFloat32DeterministicCSR_swigregister(Distributed_Step1LocalFloat32DeterministicCSR)

class Distributed_Step1LocalFloat32RandomDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32RandomDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32RandomDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32RandomDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32RandomDense_input_get, _init2.Distributed_Step1LocalFloat32RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32RandomDense_parameter_get, _init2.Distributed_Step1LocalFloat32RandomDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32RandomDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32RandomDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat32RandomDense_swigregister = _init2.Distributed_Step1LocalFloat32RandomDense_swigregister
Distributed_Step1LocalFloat32RandomDense_swigregister(Distributed_Step1LocalFloat32RandomDense)

class Distributed_Step1LocalFloat32RandomCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32RandomCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32RandomCSR_input_get, _init2.Distributed_Step1LocalFloat32RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32RandomCSR_parameter_get, _init2.Distributed_Step1LocalFloat32RandomCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32RandomCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32RandomCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat32RandomCSR_swigregister = _init2.Distributed_Step1LocalFloat32RandomCSR_swigregister
Distributed_Step1LocalFloat32RandomCSR_swigregister(Distributed_Step1LocalFloat32RandomCSR)

class Distributed_Step1LocalFloat32PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32PlusPlusDense_input_get, _init2.Distributed_Step1LocalFloat32PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32PlusPlusDense_parameter_get, _init2.Distributed_Step1LocalFloat32PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32PlusPlusDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat32PlusPlusDense_swigregister = _init2.Distributed_Step1LocalFloat32PlusPlusDense_swigregister
Distributed_Step1LocalFloat32PlusPlusDense_swigregister(Distributed_Step1LocalFloat32PlusPlusDense)

class Distributed_Step1LocalFloat32PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32PlusPlusCSR_input_get, _init2.Distributed_Step1LocalFloat32PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32PlusPlusCSR_parameter_get, _init2.Distributed_Step1LocalFloat32PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32PlusPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat32PlusPlusCSR_swigregister = _init2.Distributed_Step1LocalFloat32PlusPlusCSR_swigregister
Distributed_Step1LocalFloat32PlusPlusCSR_swigregister(Distributed_Step1LocalFloat32PlusPlusCSR)

class Distributed_Step1LocalFloat32ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32ParallelPlusDense_input_get, _init2.Distributed_Step1LocalFloat32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32ParallelPlusDense_parameter_get, _init2.Distributed_Step1LocalFloat32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step1LocalFloat32ParallelPlusDense_swigregister = _init2.Distributed_Step1LocalFloat32ParallelPlusDense_swigregister
Distributed_Step1LocalFloat32ParallelPlusDense_swigregister(Distributed_Step1LocalFloat32ParallelPlusDense)

class Distributed_Step1LocalFloat32ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step1Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step1LocalFloat32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step1LocalFloat32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step1LocalFloat32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step1LocalFloat32ParallelPlusCSR_input_get, _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step1LocalFloat32ParallelPlusCSR_parameter_get, _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step1LocalFloat32ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step1LocalFloat32ParallelPlusCSR_swigregister = _init2.Distributed_Step1LocalFloat32ParallelPlusCSR_swigregister
Distributed_Step1LocalFloat32ParallelPlusCSR_swigregister(Distributed_Step1LocalFloat32ParallelPlusCSR)

class Distributed_Step2MasterFloat64DeterministicDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat64DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat64DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat64DeterministicDense(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat64DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat64DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat64DeterministicDense_input_get, _init2.Distributed_Step2MasterFloat64DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat64DeterministicDense_parameter_get, _init2.Distributed_Step2MasterFloat64DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat64DeterministicDense
    __del__ = lambda self: None
Distributed_Step2MasterFloat64DeterministicDense_swigregister = _init2.Distributed_Step2MasterFloat64DeterministicDense_swigregister
Distributed_Step2MasterFloat64DeterministicDense_swigregister(Distributed_Step2MasterFloat64DeterministicDense)

class Distributed_Step2MasterFloat64DeterministicCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat64DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat64DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat64DeterministicCSR(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat64DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat64DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat64DeterministicCSR_input_get, _init2.Distributed_Step2MasterFloat64DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat64DeterministicCSR_parameter_get, _init2.Distributed_Step2MasterFloat64DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat64DeterministicCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat64DeterministicCSR
    __del__ = lambda self: None
Distributed_Step2MasterFloat64DeterministicCSR_swigregister = _init2.Distributed_Step2MasterFloat64DeterministicCSR_swigregister
Distributed_Step2MasterFloat64DeterministicCSR_swigregister(Distributed_Step2MasterFloat64DeterministicCSR)

class Distributed_Step2MasterFloat64RandomDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat64RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat64RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat64RandomDense(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat64RandomDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat64RandomDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat64RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat64RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat64RandomDense_input_get, _init2.Distributed_Step2MasterFloat64RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat64RandomDense_parameter_get, _init2.Distributed_Step2MasterFloat64RandomDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat64RandomDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat64RandomDense
    __del__ = lambda self: None
Distributed_Step2MasterFloat64RandomDense_swigregister = _init2.Distributed_Step2MasterFloat64RandomDense_swigregister
Distributed_Step2MasterFloat64RandomDense_swigregister(Distributed_Step2MasterFloat64RandomDense)

class Distributed_Step2MasterFloat64RandomCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float64, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat64RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat64RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat64RandomCSR(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat64RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat64RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat64RandomCSR_input_get, _init2.Distributed_Step2MasterFloat64RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat64RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat64RandomCSR_parameter_get, _init2.Distributed_Step2MasterFloat64RandomCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat64RandomCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat64RandomCSR
    __del__ = lambda self: None
Distributed_Step2MasterFloat64RandomCSR_swigregister = _init2.Distributed_Step2MasterFloat64RandomCSR_swigregister
Distributed_Step2MasterFloat64RandomCSR_swigregister(Distributed_Step2MasterFloat64RandomCSR)

class Distributed_Step2MasterFloat32DeterministicDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat32DeterministicDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat32DeterministicDense, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat32DeterministicDense(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat32DeterministicDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat32DeterministicDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat32DeterministicDense_input_get, _init2.Distributed_Step2MasterFloat32DeterministicDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32DeterministicDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32DeterministicDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat32DeterministicDense_parameter_get, _init2.Distributed_Step2MasterFloat32DeterministicDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat32DeterministicDense
    __del__ = lambda self: None
Distributed_Step2MasterFloat32DeterministicDense_swigregister = _init2.Distributed_Step2MasterFloat32DeterministicDense_swigregister
Distributed_Step2MasterFloat32DeterministicDense_swigregister(Distributed_Step2MasterFloat32DeterministicDense)

class Distributed_Step2MasterFloat32DeterministicCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.deterministicCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat32DeterministicCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat32DeterministicCSR, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat32DeterministicCSR(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat32DeterministicCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat32DeterministicCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat32DeterministicCSR_input_get, _init2.Distributed_Step2MasterFloat32DeterministicCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32DeterministicCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32DeterministicCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat32DeterministicCSR_parameter_get, _init2.Distributed_Step2MasterFloat32DeterministicCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat32DeterministicCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat32DeterministicCSR
    __del__ = lambda self: None
Distributed_Step2MasterFloat32DeterministicCSR_swigregister = _init2.Distributed_Step2MasterFloat32DeterministicCSR_swigregister
Distributed_Step2MasterFloat32DeterministicCSR_swigregister(Distributed_Step2MasterFloat32DeterministicCSR)

class Distributed_Step2MasterFloat32RandomDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat32RandomDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat32RandomDense, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat32RandomDense(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat32RandomDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat32RandomDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat32RandomDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat32RandomDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat32RandomDense_input_get, _init2.Distributed_Step2MasterFloat32RandomDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32RandomDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32RandomDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat32RandomDense_parameter_get, _init2.Distributed_Step2MasterFloat32RandomDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat32RandomDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat32RandomDense
    __del__ = lambda self: None
Distributed_Step2MasterFloat32RandomDense_swigregister = _init2.Distributed_Step2MasterFloat32RandomDense_swigregister
Distributed_Step2MasterFloat32RandomDense_swigregister(Distributed_Step2MasterFloat32RandomDense)

class Distributed_Step2MasterFloat32RandomCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR, step=daal.step2Master, fptype=float32, method=daal.algorithms.kmeans.init.randomCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2MasterFloat32RandomCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2MasterFloat32RandomCSR, name)
    __repr__ = _swig_repr

    def __init__(self, nClusters, offset=0):
        this = _init2.new_Distributed_Step2MasterFloat32RandomCSR(nClusters, offset)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2MasterFloat32RandomCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2MasterFloat32RandomCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2MasterFloat32RandomCSR_input_get, _init2.Distributed_Step2MasterFloat32RandomCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32RandomCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2MasterFloat32RandomCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2MasterFloat32RandomCSR_parameter_get, _init2.Distributed_Step2MasterFloat32RandomCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step2MasterFloat32RandomCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2MasterFloat32RandomCSR
    __del__ = lambda self: None
Distributed_Step2MasterFloat32RandomCSR_swigregister = _init2.Distributed_Step2MasterFloat32RandomCSR_swigregister
Distributed_Step2MasterFloat32RandomCSR_swigregister(Distributed_Step2MasterFloat32RandomCSR)

class Distributed_Step2LocalFloat64PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat64PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat64PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat64PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat64PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat64PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat64PlusPlusDense_input_get, _init2.Distributed_Step2LocalFloat64PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat64PlusPlusDense_parameter_get, _init2.Distributed_Step2LocalFloat64PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat64PlusPlusDense
    __del__ = lambda self: None
Distributed_Step2LocalFloat64PlusPlusDense_swigregister = _init2.Distributed_Step2LocalFloat64PlusPlusDense_swigregister
Distributed_Step2LocalFloat64PlusPlusDense_swigregister(Distributed_Step2LocalFloat64PlusPlusDense)

class Distributed_Step2LocalFloat64ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat64ParallelPlusDense_input_get, _init2.Distributed_Step2LocalFloat64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat64ParallelPlusDense_parameter_get, _init2.Distributed_Step2LocalFloat64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat64ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step2LocalFloat64ParallelPlusDense_swigregister = _init2.Distributed_Step2LocalFloat64ParallelPlusDense_swigregister
Distributed_Step2LocalFloat64ParallelPlusDense_swigregister(Distributed_Step2LocalFloat64ParallelPlusDense)

class Distributed_Step2LocalFloat64PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat64PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat64PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat64PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat64PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat64PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat64PlusPlusCSR_input_get, _init2.Distributed_Step2LocalFloat64PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat64PlusPlusCSR_parameter_get, _init2.Distributed_Step2LocalFloat64PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat64PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat64PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step2LocalFloat64PlusPlusCSR_swigregister = _init2.Distributed_Step2LocalFloat64PlusPlusCSR_swigregister
Distributed_Step2LocalFloat64PlusPlusCSR_swigregister(Distributed_Step2LocalFloat64PlusPlusCSR)

class Distributed_Step2LocalFloat64ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat64ParallelPlusCSR_input_get, _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat64ParallelPlusCSR_parameter_get, _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat64ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step2LocalFloat64ParallelPlusCSR_swigregister = _init2.Distributed_Step2LocalFloat64ParallelPlusCSR_swigregister
Distributed_Step2LocalFloat64ParallelPlusCSR_swigregister(Distributed_Step2LocalFloat64ParallelPlusCSR)

class Distributed_Step2LocalFloat32PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat32PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat32PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat32PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat32PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat32PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat32PlusPlusDense_input_get, _init2.Distributed_Step2LocalFloat32PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat32PlusPlusDense_parameter_get, _init2.Distributed_Step2LocalFloat32PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat32PlusPlusDense
    __del__ = lambda self: None
Distributed_Step2LocalFloat32PlusPlusDense_swigregister = _init2.Distributed_Step2LocalFloat32PlusPlusDense_swigregister
Distributed_Step2LocalFloat32PlusPlusDense_swigregister(Distributed_Step2LocalFloat32PlusPlusDense)

class Distributed_Step2LocalFloat32ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat32ParallelPlusDense_input_get, _init2.Distributed_Step2LocalFloat32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat32ParallelPlusDense_parameter_get, _init2.Distributed_Step2LocalFloat32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat32ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step2LocalFloat32ParallelPlusDense_swigregister = _init2.Distributed_Step2LocalFloat32ParallelPlusDense_swigregister
Distributed_Step2LocalFloat32ParallelPlusDense_swigregister(Distributed_Step2LocalFloat32ParallelPlusDense)

class Distributed_Step2LocalFloat32PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat32PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat32PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat32PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat32PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat32PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat32PlusPlusCSR_input_get, _init2.Distributed_Step2LocalFloat32PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat32PlusPlusCSR_parameter_get, _init2.Distributed_Step2LocalFloat32PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat32PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat32PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step2LocalFloat32PlusPlusCSR_swigregister = _init2.Distributed_Step2LocalFloat32PlusPlusCSR_swigregister
Distributed_Step2LocalFloat32PlusPlusCSR_swigregister(Distributed_Step2LocalFloat32PlusPlusCSR)

class Distributed_Step2LocalFloat32ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step2Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step2LocalFloat32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step2LocalFloat32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step2LocalFloat32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step2LocalFloat32ParallelPlusCSR_input_get, _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step2LocalFloat32ParallelPlusCSR_parameter_get, _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step2LocalFloat32ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step2LocalFloat32ParallelPlusCSR_swigregister = _init2.Distributed_Step2LocalFloat32ParallelPlusCSR_swigregister
Distributed_Step2LocalFloat32ParallelPlusCSR_swigregister(Distributed_Step2LocalFloat32ParallelPlusCSR)

class Distributed_Step3MasterFloat64PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat64PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat64PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat64PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat64PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat64PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat64PlusPlusDense_input_get, _init2.Distributed_Step3MasterFloat64PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat64PlusPlusDense_parameter_get, _init2.Distributed_Step3MasterFloat64PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat64PlusPlusDense
    __del__ = lambda self: None
Distributed_Step3MasterFloat64PlusPlusDense_swigregister = _init2.Distributed_Step3MasterFloat64PlusPlusDense_swigregister
Distributed_Step3MasterFloat64PlusPlusDense_swigregister(Distributed_Step3MasterFloat64PlusPlusDense)

class Distributed_Step3MasterFloat64ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat64ParallelPlusDense_input_get, _init2.Distributed_Step3MasterFloat64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat64ParallelPlusDense_parameter_get, _init2.Distributed_Step3MasterFloat64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat64ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step3MasterFloat64ParallelPlusDense_swigregister = _init2.Distributed_Step3MasterFloat64ParallelPlusDense_swigregister
Distributed_Step3MasterFloat64ParallelPlusDense_swigregister(Distributed_Step3MasterFloat64ParallelPlusDense)

class Distributed_Step3MasterFloat64PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat64PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat64PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat64PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat64PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat64PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat64PlusPlusCSR_input_get, _init2.Distributed_Step3MasterFloat64PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat64PlusPlusCSR_parameter_get, _init2.Distributed_Step3MasterFloat64PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat64PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat64PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step3MasterFloat64PlusPlusCSR_swigregister = _init2.Distributed_Step3MasterFloat64PlusPlusCSR_swigregister
Distributed_Step3MasterFloat64PlusPlusCSR_swigregister(Distributed_Step3MasterFloat64PlusPlusCSR)

class Distributed_Step3MasterFloat64ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat64ParallelPlusCSR_input_get, _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat64ParallelPlusCSR_parameter_get, _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat64ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step3MasterFloat64ParallelPlusCSR_swigregister = _init2.Distributed_Step3MasterFloat64ParallelPlusCSR_swigregister
Distributed_Step3MasterFloat64ParallelPlusCSR_swigregister(Distributed_Step3MasterFloat64ParallelPlusCSR)

class Distributed_Step3MasterFloat32PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat32PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat32PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat32PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat32PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat32PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat32PlusPlusDense_input_get, _init2.Distributed_Step3MasterFloat32PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat32PlusPlusDense_parameter_get, _init2.Distributed_Step3MasterFloat32PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat32PlusPlusDense
    __del__ = lambda self: None
Distributed_Step3MasterFloat32PlusPlusDense_swigregister = _init2.Distributed_Step3MasterFloat32PlusPlusDense_swigregister
Distributed_Step3MasterFloat32PlusPlusDense_swigregister(Distributed_Step3MasterFloat32PlusPlusDense)

class Distributed_Step3MasterFloat32ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat32ParallelPlusDense_input_get, _init2.Distributed_Step3MasterFloat32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat32ParallelPlusDense_parameter_get, _init2.Distributed_Step3MasterFloat32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat32ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step3MasterFloat32ParallelPlusDense_swigregister = _init2.Distributed_Step3MasterFloat32ParallelPlusDense_swigregister
Distributed_Step3MasterFloat32ParallelPlusDense_swigregister(Distributed_Step3MasterFloat32ParallelPlusDense)

class Distributed_Step3MasterFloat32PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat32PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat32PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat32PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat32PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat32PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat32PlusPlusCSR_input_get, _init2.Distributed_Step3MasterFloat32PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat32PlusPlusCSR_parameter_get, _init2.Distributed_Step3MasterFloat32PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat32PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat32PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step3MasterFloat32PlusPlusCSR_swigregister = _init2.Distributed_Step3MasterFloat32PlusPlusCSR_swigregister
Distributed_Step3MasterFloat32PlusPlusCSR_swigregister(Distributed_Step3MasterFloat32PlusPlusCSR)

class Distributed_Step3MasterFloat32ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step3Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step3MasterFloat32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step3MasterFloat32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step3MasterFloat32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step3MasterFloat32ParallelPlusCSR_input_get, _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step3MasterFloat32ParallelPlusCSR_parameter_get, _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step3MasterFloat32ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step3MasterFloat32ParallelPlusCSR_swigregister = _init2.Distributed_Step3MasterFloat32ParallelPlusCSR_swigregister
Distributed_Step3MasterFloat32ParallelPlusCSR_swigregister(Distributed_Step3MasterFloat32ParallelPlusCSR)

class Distributed_Step4LocalFloat64PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat64PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat64PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat64PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat64PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat64PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat64PlusPlusDense_input_get, _init2.Distributed_Step4LocalFloat64PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat64PlusPlusDense_parameter_get, _init2.Distributed_Step4LocalFloat64PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat64PlusPlusDense
    __del__ = lambda self: None
Distributed_Step4LocalFloat64PlusPlusDense_swigregister = _init2.Distributed_Step4LocalFloat64PlusPlusDense_swigregister
Distributed_Step4LocalFloat64PlusPlusDense_swigregister(Distributed_Step4LocalFloat64PlusPlusDense)

class Distributed_Step4LocalFloat64ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat64ParallelPlusDense_input_get, _init2.Distributed_Step4LocalFloat64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat64ParallelPlusDense_parameter_get, _init2.Distributed_Step4LocalFloat64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat64ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step4LocalFloat64ParallelPlusDense_swigregister = _init2.Distributed_Step4LocalFloat64ParallelPlusDense_swigregister
Distributed_Step4LocalFloat64ParallelPlusDense_swigregister(Distributed_Step4LocalFloat64ParallelPlusDense)

class Distributed_Step4LocalFloat64PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat64PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat64PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat64PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat64PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat64PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat64PlusPlusCSR_input_get, _init2.Distributed_Step4LocalFloat64PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat64PlusPlusCSR_parameter_get, _init2.Distributed_Step4LocalFloat64PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat64PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat64PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step4LocalFloat64PlusPlusCSR_swigregister = _init2.Distributed_Step4LocalFloat64PlusPlusCSR_swigregister
Distributed_Step4LocalFloat64PlusPlusCSR_swigregister(Distributed_Step4LocalFloat64PlusPlusCSR)

class Distributed_Step4LocalFloat64ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat64ParallelPlusCSR_input_get, _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat64ParallelPlusCSR_parameter_get, _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat64ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step4LocalFloat64ParallelPlusCSR_swigregister = _init2.Distributed_Step4LocalFloat64ParallelPlusCSR_swigregister
Distributed_Step4LocalFloat64ParallelPlusCSR_swigregister(Distributed_Step4LocalFloat64ParallelPlusCSR)

class Distributed_Step4LocalFloat32PlusPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat32PlusPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat32PlusPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat32PlusPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat32PlusPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat32PlusPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat32PlusPlusDense_input_get, _init2.Distributed_Step4LocalFloat32PlusPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32PlusPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32PlusPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat32PlusPlusDense_parameter_get, _init2.Distributed_Step4LocalFloat32PlusPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat32PlusPlusDense
    __del__ = lambda self: None
Distributed_Step4LocalFloat32PlusPlusDense_swigregister = _init2.Distributed_Step4LocalFloat32PlusPlusDense_swigregister
Distributed_Step4LocalFloat32PlusPlusDense_swigregister(Distributed_Step4LocalFloat32PlusPlusDense)

class Distributed_Step4LocalFloat32ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat32ParallelPlusDense_input_get, _init2.Distributed_Step4LocalFloat32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat32ParallelPlusDense_parameter_get, _init2.Distributed_Step4LocalFloat32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusDense_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat32ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step4LocalFloat32ParallelPlusDense_swigregister = _init2.Distributed_Step4LocalFloat32ParallelPlusDense_swigregister
Distributed_Step4LocalFloat32ParallelPlusDense_swigregister(Distributed_Step4LocalFloat32ParallelPlusDense)

class Distributed_Step4LocalFloat32PlusPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.plusPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat32PlusPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat32PlusPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat32PlusPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat32PlusPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat32PlusPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat32PlusPlusCSR_input_get, _init2.Distributed_Step4LocalFloat32PlusPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32PlusPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32PlusPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat32PlusPlusCSR_parameter_get, _init2.Distributed_Step4LocalFloat32PlusPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat32PlusPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat32PlusPlusCSR
    __del__ = lambda self: None
Distributed_Step4LocalFloat32PlusPlusCSR_swigregister = _init2.Distributed_Step4LocalFloat32PlusPlusCSR_swigregister
Distributed_Step4LocalFloat32PlusPlusCSR_swigregister(Distributed_Step4LocalFloat32PlusPlusCSR)

class Distributed_Step4LocalFloat32ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step4Local, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step4LocalFloat32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step4LocalFloat32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step4LocalFloat32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_getMethod(self)

    def getPartialResult(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step4LocalFloat32ParallelPlusCSR_input_get, _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step4LocalFloat32ParallelPlusCSR_parameter_get, _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_compute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step4LocalFloat32ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step4LocalFloat32ParallelPlusCSR_swigregister = _init2.Distributed_Step4LocalFloat32ParallelPlusCSR_swigregister
Distributed_Step4LocalFloat32ParallelPlusCSR_swigregister(Distributed_Step4LocalFloat32ParallelPlusCSR)

class Distributed_Step5MasterFloat64ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step5MasterFloat64ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step5MasterFloat64ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step5MasterFloat64ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step5MasterFloat64ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step5MasterFloat64ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step5MasterFloat64ParallelPlusDense_input_get, _init2.Distributed_Step5MasterFloat64ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step5MasterFloat64ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step5MasterFloat64ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step5MasterFloat64ParallelPlusDense_parameter_get, _init2.Distributed_Step5MasterFloat64ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step5MasterFloat64ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step5MasterFloat64ParallelPlusDense_swigregister = _init2.Distributed_Step5MasterFloat64ParallelPlusDense_swigregister
Distributed_Step5MasterFloat64ParallelPlusDense_swigregister(Distributed_Step5MasterFloat64ParallelPlusDense)

class Distributed_Step5MasterFloat64ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float64, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step5MasterFloat64ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step5MasterFloat64ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step5MasterFloat64ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step5MasterFloat64ParallelPlusCSR_input_get, _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step5MasterFloat64ParallelPlusCSR_parameter_get, _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step5MasterFloat64ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step5MasterFloat64ParallelPlusCSR_swigregister = _init2.Distributed_Step5MasterFloat64ParallelPlusCSR_swigregister
Distributed_Step5MasterFloat64ParallelPlusCSR_swigregister(Distributed_Step5MasterFloat64ParallelPlusCSR)

class Distributed_Step5MasterFloat32ParallelPlusDense(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusDense)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step5MasterFloat32ParallelPlusDense, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step5MasterFloat32ParallelPlusDense, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step5MasterFloat32ParallelPlusDense(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step5MasterFloat32ParallelPlusDense_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step5MasterFloat32ParallelPlusDense_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step5MasterFloat32ParallelPlusDense_input_get, _init2.Distributed_Step5MasterFloat32ParallelPlusDense_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step5MasterFloat32ParallelPlusDense_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step5MasterFloat32ParallelPlusDense_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step5MasterFloat32ParallelPlusDense_parameter_get, _init2.Distributed_Step5MasterFloat32ParallelPlusDense_parameter_set)

    def compute(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusDense_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step5MasterFloat32ParallelPlusDense
    __del__ = lambda self: None
Distributed_Step5MasterFloat32ParallelPlusDense_swigregister = _init2.Distributed_Step5MasterFloat32ParallelPlusDense_swigregister
Distributed_Step5MasterFloat32ParallelPlusDense_swigregister(Distributed_Step5MasterFloat32ParallelPlusDense)

class Distributed_Step5MasterFloat32ParallelPlusCSR(daal.algorithms.Analysis_Distributed):
    r"""
This class is an alias of Distributed(step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR, step=daal.step5Master, fptype=float32, method=daal.algorithms.kmeans.init.parallelPlusCSR)
    """
    __swig_setmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distributed_Step5MasterFloat32ParallelPlusCSR, name, value)
    __swig_getmethods__ = {}
    for _s in [daal.algorithms.Analysis_Distributed]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Distributed_Step5MasterFloat32ParallelPlusCSR, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _init2.new_Distributed_Step5MasterFloat32ParallelPlusCSR(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getMethod(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_getMethod(self)

    def getResult(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_getResult(self)

    def setResult(self, result):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_setResult(self, result)

    def getPartialResult(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_getPartialResult(self)

    def setPartialResult(self, partialRes):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_setPartialResult(self, partialRes)

    def checkFinalizeComputeParams(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_checkFinalizeComputeParams(self)

    def clone(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_clone(self)
    __swig_setmethods__["input"] = _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_input_set
    __swig_getmethods__["input"] = _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_input_get
    if _newclass:
        input = _swig_property(_init2.Distributed_Step5MasterFloat32ParallelPlusCSR_input_get, _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_input_set)
    __swig_setmethods__["parameter"] = _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_parameter_set
    __swig_getmethods__["parameter"] = _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_parameter_get
    if _newclass:
        parameter = _swig_property(_init2.Distributed_Step5MasterFloat32ParallelPlusCSR_parameter_get, _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_parameter_set)

    def compute(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_compute(self)

    def finalizeCompute(self):
        return _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_finalizeCompute(self)
    __swig_destroy__ = _init2.delete_Distributed_Step5MasterFloat32ParallelPlusCSR
    __del__ = lambda self: None
Distributed_Step5MasterFloat32ParallelPlusCSR_swigregister = _init2.Distributed_Step5MasterFloat32ParallelPlusCSR_swigregister
Distributed_Step5MasterFloat32ParallelPlusCSR_swigregister(Distributed_Step5MasterFloat32ParallelPlusCSR)

from numpy import float64, float32, intc

class Distributed(object):
    r"""Factory class for different types of Distributed."""
    def __new__(cls,
                step,
                *args, **kwargs):
        if step == daal.step1Local:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == deterministicDense:
                        return Distributed_Step1LocalFloat64DeterministicDense(*args)
                    if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                        return Distributed_Step1LocalFloat64DeterministicCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == randomDense:
                        return Distributed_Step1LocalFloat64RandomDense(*args)
                    if 'method' in kwargs and kwargs['method'] == randomCSR:
                        return Distributed_Step1LocalFloat64RandomCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step1LocalFloat64PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step1LocalFloat64PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step1LocalFloat64ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step1LocalFloat64ParallelPlusCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == deterministicDense:
                        return Distributed_Step1LocalFloat32DeterministicDense(*args)
                    if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                        return Distributed_Step1LocalFloat32DeterministicCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == randomDense:
                        return Distributed_Step1LocalFloat32RandomDense(*args)
                    if 'method' in kwargs and kwargs['method'] == randomCSR:
                        return Distributed_Step1LocalFloat32RandomCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step1LocalFloat32PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step1LocalFloat32PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step1LocalFloat32ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step1LocalFloat32ParallelPlusCSR(*args)
        if step == daal.step2Master:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == deterministicDense:
                        return Distributed_Step2MasterFloat64DeterministicDense(*args)
                    if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                        return Distributed_Step2MasterFloat64DeterministicCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == randomDense:
                        return Distributed_Step2MasterFloat64RandomDense(*args)
                    if 'method' in kwargs and kwargs['method'] == randomCSR:
                        return Distributed_Step2MasterFloat64RandomCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == deterministicDense:
                        return Distributed_Step2MasterFloat32DeterministicDense(*args)
                    if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                        return Distributed_Step2MasterFloat32DeterministicCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == randomDense:
                        return Distributed_Step2MasterFloat32RandomDense(*args)
                    if 'method' in kwargs and kwargs['method'] == randomCSR:
                        return Distributed_Step2MasterFloat32RandomCSR(*args)
        if step == daal.step2Local:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step2LocalFloat64PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step2LocalFloat64ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step2LocalFloat64PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step2LocalFloat64ParallelPlusCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step2LocalFloat32PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step2LocalFloat32ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step2LocalFloat32PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step2LocalFloat32ParallelPlusCSR(*args)
        if step == daal.step3Master:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step3MasterFloat64PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step3MasterFloat64ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step3MasterFloat64PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step3MasterFloat64ParallelPlusCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step3MasterFloat32PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step3MasterFloat32ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step3MasterFloat32PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step3MasterFloat32ParallelPlusCSR(*args)
        if step == daal.step4Local:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step4LocalFloat64PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step4LocalFloat64ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step4LocalFloat64PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step4LocalFloat64ParallelPlusCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                        return Distributed_Step4LocalFloat32PlusPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step4LocalFloat32ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                        return Distributed_Step4LocalFloat32PlusPlusCSR(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step4LocalFloat32ParallelPlusCSR(*args)
        if step == daal.step5Master:
            if 'fptype' not in kwargs or kwargs['fptype'] == float64:
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step5MasterFloat64ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step5MasterFloat64ParallelPlusCSR(*args)
            if 'fptype' in kwargs and kwargs['fptype'] == float32:
                    if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                        return Distributed_Step5MasterFloat32ParallelPlusDense(*args)
                    if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                        return Distributed_Step5MasterFloat32ParallelPlusCSR(*args)

        return None

class Batch(object):
    r"""Factory class for different types of Batch."""
    def __new__(cls,
                *args, **kwargs):
        if 'fptype' not in kwargs or kwargs['fptype'] == float64:
            if 'method' not in kwargs or kwargs['method'] == deterministicDense:
                return Batch_Float64DeterministicDense(*args)
            if 'method' in kwargs and kwargs['method'] == randomDense:
                return Batch_Float64RandomDense(*args)
            if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                return Batch_Float64PlusPlusDense(*args)
            if 'method' in kwargs and kwargs['method'] == randomCSR:
                return Batch_Float64RandomCSR(*args)
            if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                return Batch_Float64ParallelPlusDense(*args)
            if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                return Batch_Float64ParallelPlusCSR(*args)
            if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                return Batch_Float64DeterministicCSR(*args)
            if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                return Batch_Float64PlusPlusCSR(*args)
        if 'fptype' in kwargs and kwargs['fptype'] == float32:
            if 'method' not in kwargs or kwargs['method'] == deterministicDense:
                return Batch_Float32DeterministicDense(*args)
            if 'method' in kwargs and kwargs['method'] == randomDense:
                return Batch_Float32RandomDense(*args)
            if 'method' in kwargs and kwargs['method'] == plusPlusDense:
                return Batch_Float32PlusPlusDense(*args)
            if 'method' in kwargs and kwargs['method'] == randomCSR:
                return Batch_Float32RandomCSR(*args)
            if 'method' in kwargs and kwargs['method'] == parallelPlusDense:
                return Batch_Float32ParallelPlusDense(*args)
            if 'method' in kwargs and kwargs['method'] == parallelPlusCSR:
                return Batch_Float32ParallelPlusCSR(*args)
            if 'method' in kwargs and kwargs['method'] == deterministicCSR:
                return Batch_Float32DeterministicCSR(*args)
            if 'method' in kwargs and kwargs['method'] == plusPlusCSR:
                return Batch_Float32PlusPlusCSR(*args)

        return None


# This file is compatible with both classic and new-style classes.


