C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

kmeans_init_distributed.h
1 /* file: kmeans_init_distributed.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of the interface for initializing K-Means algorithm
21 // in the distributed processing mode
22 //--
23 */
24 
25 #ifndef __KMEANS_INIT_DISTRIBITED_H__
26 #define __KMEANS_INIT_DISTRIBITED_H__
27 
28 #include "algorithms/algorithm.h"
29 #include "data_management/data/numeric_table.h"
30 #include "services/daal_defines.h"
31 #include "algorithms/kmeans/kmeans_init_types.h"
32 
33 namespace daal
34 {
35 namespace algorithms
36 {
37 namespace kmeans
38 {
39 namespace init
40 {
41 
42 namespace interface2
43 {
58 template<ComputeStep step, typename algorithmFPType, Method method, CpuType cpu>
59 class DistributedContainer;
60 
65 template<typename algorithmFPType, Method method, CpuType cpu>
66 class DistributedContainer<step1Local, algorithmFPType, method, cpu> : public
67  daal::algorithms::AnalysisContainerIface<distributed>
68 {
69 public:
75  DistributedContainer(daal::services::Environment::env *daalEnv);
77  virtual ~DistributedContainer();
82  virtual services::Status compute() DAAL_C11_OVERRIDE;
87  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
88 };
89 
94 template<typename algorithmFPType, Method method, CpuType cpu>
95 class DistributedContainer<step2Master, algorithmFPType, method, cpu> : public
96  daal::algorithms::AnalysisContainerIface<distributed>
97 {
98 public:
104  DistributedContainer(daal::services::Environment::env *daalEnv);
106  virtual ~DistributedContainer();
111  virtual services::Status compute() DAAL_C11_OVERRIDE;
116  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
117 };
118 
124 template<typename algorithmFPType, Method method, CpuType cpu>
125 class DistributedContainer<step2Local, algorithmFPType, method, cpu> : public
126  daal::algorithms::AnalysisContainerIface<distributed>
127 {
128 public:
134  DistributedContainer(daal::services::Environment::env *daalEnv);
136  virtual ~DistributedContainer();
141  virtual services::Status compute() DAAL_C11_OVERRIDE;
146  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
147 };
148 
154 template<typename algorithmFPType, Method method, CpuType cpu>
155 class DistributedContainer<step3Master, algorithmFPType, method, cpu> : public
156  daal::algorithms::AnalysisContainerIface<distributed>
157 {
158 public:
164  DistributedContainer(daal::services::Environment::env *daalEnv);
166  virtual ~DistributedContainer();
171  virtual services::Status compute() DAAL_C11_OVERRIDE;
176  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
177 };
178 
184 template<typename algorithmFPType, Method method, CpuType cpu>
185 class DistributedContainer<step4Local, algorithmFPType, method, cpu> : public
186  daal::algorithms::AnalysisContainerIface<distributed>
187 {
188 public:
194  DistributedContainer(daal::services::Environment::env *daalEnv);
196  virtual ~DistributedContainer();
201  virtual services::Status compute() DAAL_C11_OVERRIDE;
206  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
207 };
208 
214 template<typename algorithmFPType, Method method, CpuType cpu>
215 class DistributedContainer<step5Master, algorithmFPType, method, cpu> : public
216  daal::algorithms::AnalysisContainerIface<distributed>
217 {
218 public:
224  DistributedContainer(daal::services::Environment::env *daalEnv);
226  virtual ~DistributedContainer();
231  virtual services::Status compute() DAAL_C11_OVERRIDE;
236  virtual services::Status finalizeCompute() DAAL_C11_OVERRIDE;
237 };
238 
243 class DAAL_EXPORT DistributedBase : public daal::algorithms::Analysis<distributed>
244 {
245 public:
246  typedef algorithms::kmeans::init::Parameter ParameterType;
248  virtual ~DistributedBase() { }
249 
250 protected:
251  DistributedBase() { }
252 
253  explicit DistributedBase(ParameterType *parameter)
254  {
255  _par = parameter;
256  }
257 };
258 
276 template<ComputeStep step, typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = defaultDense>
277 class DAAL_EXPORT Distributed;
278 
296 template<typename algorithmFPType, Method method>
297 class DAAL_EXPORT Distributed<step1Local, algorithmFPType, method> : public DistributedBase
298 {
299 public:
300  typedef algorithms::kmeans::init::Input InputType;
301  typedef algorithms::kmeans::init::Result ResultType;
302  typedef algorithms::kmeans::init::PartialResult PartialResultType;
303 
310  Distributed(size_t nClusters, size_t nRowsTotal, size_t offset = 0);
316  Distributed(const Distributed<step1Local, algorithmFPType, method> &other);
317 
322  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
323 
328  ResultPtr getResult()
329  {
330  return _result;
331  }
332 
337  services::Status setResult(const ResultPtr& result)
338  {
339  DAAL_CHECK(result, services::ErrorNullResult)
340  _result = result;
341  _res = _result.get();
342  return services::Status();
343  }
344 
349  PartialResultPtr getPartialResult()
350  {
351  return _partialResult;
352  }
353 
358  services::Status setPartialResult(const PartialResultPtr& partialRes)
359  {
360  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
361  _partialResult = partialRes;
362  _pres = _partialResult.get();
363  return services::Status();
364  }
365 
369  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
370  {
371  return services::Status();
372  }
373 
379  services::SharedPtr<Distributed<step1Local, algorithmFPType, method> > clone() const
380  {
381  return services::SharedPtr<Distributed<step1Local, algorithmFPType, method> >(cloneImpl());
382  }
383 
384 protected:
385  virtual Distributed<step1Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
386  {
387  return new Distributed<step1Local, algorithmFPType, method>(*this);
388  }
389 
390  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
391  {
392  _result.reset(new ResultType());
393  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int) method);
394  _res = _result.get();
395  return s;
396  }
397 
398  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
399  {
400  _partialResult.reset(new PartialResultType());
401  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
402  _pres = _partialResult.get();
403  return s;
404  }
405 
406  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
407  {
408  return services::Status();
409  }
410 
411  void initialize()
412  {
413  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step1Local, algorithmFPType, method)(&_env);
414  _in = &input;
415  }
416 
417 public:
418  InputType input;
419  ParameterType &parameter;
421 private:
422  PartialResultPtr _partialResult;
423  ResultPtr _result;
424 };
425 
443 template<typename algorithmFPType, Method method>
444 class DAAL_EXPORT Distributed<step2Master, algorithmFPType, method> : public DistributedBase
445 {
446 public:
447  typedef algorithms::kmeans::init::DistributedStep2MasterInput InputType;
448  typedef algorithms::kmeans::init::Result ResultType;
449  typedef algorithms::kmeans::init::PartialResult PartialResultType;
450 
456  Distributed(size_t nClusters, size_t offset = 0);
457 
462  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
463 
468  ResultPtr getResult()
469  {
470  return _result;
471  }
472 
476  services::Status setResult(const ResultPtr& result)
477  {
478  DAAL_CHECK(result, services::ErrorNullResult)
479  _result = result;
480  _res = _result.get();
481  return services::Status();
482  }
483 
488  PartialResultPtr getPartialResult()
489  {
490  return _partialResult;
491  }
492 
497  services::Status setPartialResult(const PartialResultPtr& partialRes)
498  {
499  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
500  _partialResult = partialRes;
501  _pres = _partialResult.get();
502  return services::Status();
503  }
504 
508  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
509  {
510  services::Status s;
511  if(_partialResult)
512  {
513  s |= _partialResult->check(_par, method);
514  if (!s) { return s; }
515  }
516  else
517  {
518  return services::Status(services::ErrorNullResult);
519  }
520 
521  if(_result)
522  {
523  s |= _result->check(&input, _par, method);
524  }
525  else
526  {
527  return services::Status(services::ErrorNullResult);
528  }
529  return s;
530  }
531 
537  services::SharedPtr<Distributed<step2Master, algorithmFPType, method> > clone() const
538  {
539  return services::SharedPtr<Distributed<step2Master, algorithmFPType, method> >(cloneImpl());
540  }
541 
542 protected:
543  virtual Distributed<step2Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
544  {
545  return new Distributed<step2Master, algorithmFPType, method>(*this);
546  }
547 
548  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
549  {
550  _result.reset(new ResultType());
551  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int)method);
552  _res = _result.get();
553  return s;
554  }
555 
556  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
557  {
558  _partialResult.reset(new PartialResultType());
559  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int)method);
560  if(!s) return s;
561  _pres = _partialResult.get();
562  if(!_res)
563  {
564  _result.reset(new ResultType());
565  s |= _result->allocate<algorithmFPType>(&input, _par, (int)method);
566  _res = _result.get();
567  }
568  return s;
569  }
570 
571  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
572  {
573  return services::Status();
574  }
575 
576  void initialize()
577  {
578  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step2Master, algorithmFPType, method)(&_env);
579  _in = &input;
580  }
581 
582 public:
583  InputType input;
584  ParameterType &parameter;
586 private:
587  PartialResultPtr _partialResult;
588  ResultPtr _result;
589 };
590 
595 class DAAL_EXPORT DistributedStep2LocalPlusPlusBase : public daal::algorithms::Analysis<distributed>
596 {
597 public:
598  typedef algorithms::kmeans::init::DistributedStep2LocalPlusPlusParameter ParameterType;
600  virtual ~DistributedStep2LocalPlusPlusBase() { }
601 
602 protected:
603  DistributedStep2LocalPlusPlusBase() { }
604 
605  explicit DistributedStep2LocalPlusPlusBase(ParameterType *parameter)
606  {
607  _par = parameter;
608  }
609 };
610 
632 template<typename algorithmFPType, Method method>
633 class DAAL_EXPORT Distributed<step2Local, algorithmFPType, method> : public DistributedStep2LocalPlusPlusBase
634 {
635 public:
636  typedef algorithms::kmeans::init::DistributedStep2LocalPlusPlusInput InputType;
637  typedef algorithms::kmeans::init::DistributedStep2LocalPlusPlusPartialResult PartialResultType;
638 
644  Distributed(size_t nClusters, bool bFirstIteration);
645 
651  Distributed(const Distributed<step2Local, algorithmFPType, method> &other);
652 
657  virtual int getMethod() const DAAL_C11_OVERRIDE{ return(int)method; }
658 
663  DistributedStep2LocalPlusPlusPartialResultPtr getPartialResult()
664  {
665  return _partialResult;
666  }
667 
672  services::Status setPartialResult(const DistributedStep2LocalPlusPlusPartialResultPtr& partialRes)
673  {
674  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
675  _partialResult = partialRes;
676  _pres = _partialResult.get();
677  return services::Status();
678  }
679 
683  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
684  {
685  return services::Status();
686  }
687 
693  services::SharedPtr<Distributed<step2Local, algorithmFPType, method> > clone() const
694  {
695  return services::SharedPtr<Distributed<step2Local, algorithmFPType, method> >(cloneImpl());
696  }
697 
698 protected:
699  virtual Distributed<step2Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
700  {
701  return new Distributed<step2Local, algorithmFPType, method>(*this);
702  }
703 
704  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
705  {
706  return services::Status();
707  }
708 
709  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
710  {
711  _partialResult.reset(new DistributedStep2LocalPlusPlusPartialResult());
712  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int)method);
713  _pres = _partialResult.get();
714  return s;
715  }
716 
717  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
718  {
719  _partialResult->initialize(&input, _par, (int)method);
720  return services::Status();
721  }
722 
723  void initialize()
724  {
725  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step2Local, algorithmFPType, method)(&_env);
726  _in = &input;
727  }
728 
729 public:
730  InputType input;
731  ParameterType &parameter;
733 private:
734  DistributedStep2LocalPlusPlusPartialResultPtr _partialResult;
735 };
736 
757 template<typename algorithmFPType, Method method>
758 class DAAL_EXPORT Distributed<step3Master, algorithmFPType, method> : public DistributedBase
759 {
760 public:
761  typedef algorithms::kmeans::init::DistributedStep3MasterPlusPlusInput InputType;
762  typedef algorithms::kmeans::init::DistributedStep3MasterPlusPlusPartialResult PartialResultType;
763 
768  Distributed(size_t nClusters);
774  Distributed(const Distributed<step3Master, algorithmFPType, method> &other);
775 
780  virtual int getMethod() const DAAL_C11_OVERRIDE{ return(int)method; }
781 
786  DistributedStep3MasterPlusPlusPartialResultPtr getPartialResult()
787  {
788  return _partialResult;
789  }
790 
795  services::Status setPartialResult(const DistributedStep3MasterPlusPlusPartialResultPtr& partialRes)
796  {
797  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
798  _partialResult = partialRes;
799  _pres = _partialResult.get();
800  return services::Status();
801  }
802 
806  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
807  {
808  return services::Status();
809  }
810 
816  services::SharedPtr<Distributed<step3Master, algorithmFPType, method> > clone() const
817  {
818  return services::SharedPtr<Distributed<step3Master, algorithmFPType, method> >(cloneImpl());
819  }
820 
821 protected:
822  virtual Distributed<step3Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
823  {
824  return new Distributed<step3Master, algorithmFPType, method>(*this);
825  }
826 
827  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
828  {
829  return services::Status();
830  }
831 
832  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
833  {
834  _partialResult.reset(new PartialResultType());
835  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int)method);
836  _pres = _partialResult.get();
837  return s;
838  }
839 
840  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
841  {
842  _partialResult->initialize(&input, _par, (int)method);
843  return services::Status();
844  }
845 
846  void initialize()
847  {
848  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step3Master, algorithmFPType, method)(&_env);
849  _in = &input;
850  }
851 
852 public:
853  InputType input;
854  ParameterType &parameter;
856 private:
857  DistributedStep3MasterPlusPlusPartialResultPtr _partialResult;
858 };
859 
880 template<typename algorithmFPType, Method method>
881 class DAAL_EXPORT Distributed<step4Local, algorithmFPType, method> : public DistributedBase
882 {
883 public:
884  typedef algorithms::kmeans::init::DistributedStep4LocalPlusPlusInput InputType;
885  typedef algorithms::kmeans::init::DistributedStep4LocalPlusPlusPartialResult PartialResultType;
886 
891  Distributed(size_t nClusters);
897  Distributed(const Distributed<step4Local, algorithmFPType, method> &other);
898 
903  virtual int getMethod() const DAAL_C11_OVERRIDE{ return(int)method; }
904 
909  DistributedStep4LocalPlusPlusPartialResultPtr getPartialResult()
910  {
911  return _partialResult;
912  }
913 
918  services::Status setPartialResult(const DistributedStep4LocalPlusPlusPartialResultPtr& partialRes)
919  {
920  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
921  _partialResult = partialRes;
922  _pres = _partialResult.get();
923  return services::Status();
924  }
925 
929  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
930  {
931  return services::Status();
932  }
933 
939  services::SharedPtr<Distributed<step4Local, algorithmFPType, method> > clone() const
940  {
941  return services::SharedPtr<Distributed<step4Local, algorithmFPType, method> >(cloneImpl());
942  }
943 
944 protected:
945  virtual Distributed<step4Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
946  {
947  return new Distributed<step4Local, algorithmFPType, method>(*this);
948  }
949 
950  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
951  {
952  return services::Status();
953  }
954 
955  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
956  {
957  _partialResult.reset(new PartialResultType());
958  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int)method);
959  _pres = _partialResult.get();
960  return s;
961  }
962 
963  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
964  {
965  return services::Status();
966  }
967 
968  void initialize()
969  {
970  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step4Local, algorithmFPType, method)(&_env);
971  _in = &input;
972  }
973 
974 public:
975  InputType input;
976  ParameterType &parameter;
978 private:
979  DistributedStep4LocalPlusPlusPartialResultPtr _partialResult;
980 };
981 
1002 template<typename algorithmFPType, Method method>
1003 class DAAL_EXPORT Distributed<step5Master, algorithmFPType, method> : public DistributedBase
1004 {
1005 public:
1006  typedef algorithms::kmeans::init::DistributedStep5MasterPlusPlusInput InputType;
1007  typedef algorithms::kmeans::init::Result ResultType;
1008  typedef algorithms::kmeans::init::DistributedStep5MasterPlusPlusPartialResult PartialResultType;
1009 
1014  Distributed(size_t nClusters);
1015 
1021  Distributed(const Distributed<step5Master, algorithmFPType, method> &other);
1022 
1027  virtual int getMethod() const DAAL_C11_OVERRIDE{ return(int)method; }
1028 
1033  ResultPtr getResult()
1034  {
1035  return _result;
1036  }
1037 
1042  services::Status setResult(const ResultPtr& result)
1043  {
1044  DAAL_CHECK(result, services::ErrorNullResult)
1045  _result = result;
1046  _res = _result.get();
1047  return services::Status();
1048  }
1049 
1054  DistributedStep5MasterPlusPlusPartialResultPtr getPartialResult()
1055  {
1056  return _partialResult;
1057  }
1058 
1063  services::Status setPartialResult(const DistributedStep5MasterPlusPlusPartialResultPtr& partialRes)
1064  {
1065  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1066  _partialResult = partialRes;
1067  _pres = _partialResult.get();
1068  return services::Status();
1069  }
1070 
1074  services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
1075  {
1076  return services::Status();
1077  }
1078 
1084  services::SharedPtr<Distributed<step5Master, algorithmFPType, method> > clone() const
1085  {
1086  return services::SharedPtr<Distributed<step5Master, algorithmFPType, method> >(cloneImpl());
1087  }
1088 
1089 protected:
1090  virtual Distributed<step5Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1091  {
1092  return new Distributed<step5Master, algorithmFPType, method>(*this);
1093  }
1094 
1095  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1096  {
1097  _result.reset(new ResultType());
1098  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int)method);
1099  _res = _result.get();
1100  return s;
1101  }
1102 
1103  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1104  {
1105  _partialResult.reset(new PartialResultType());
1106  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int)method);
1107  _pres = _partialResult.get();
1108  return s;
1109  }
1110 
1111  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1112  {
1113  return services::Status();
1114  }
1115 
1116  void initialize()
1117  {
1118  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step5Master, algorithmFPType, method)(&_env);
1119  _in = &input;
1120  }
1121 
1122 public:
1123  InputType input;
1124  ParameterType &parameter;
1126 private:
1127  DistributedStep5MasterPlusPlusPartialResultPtr _partialResult;
1128  ResultPtr _result;
1129 };
1130 } // namespace interface2
1131 using interface2::DistributedContainer;
1132 using interface2::DistributedBase;
1133 using interface2::DistributedStep2LocalPlusPlusBase;
1134 using interface2::Distributed;
1135 } // namespace daal::algorithms::kmeans::init
1136 } // namespace daal::algorithms::kmeans
1137 } // namespace daal::algorithms
1138 } // namespace daal
1139 #endif
daal::step1Local
Definition: daal_defines.h:123
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::input
InputType input
Definition: kmeans_init_distributed.h:418
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::parameter
ParameterType & parameter
Definition: kmeans_init_distributed.h:419
daal::algorithms::kmeans::init::interface2::DistributedBase::~DistributedBase
virtual ~DistributedBase()
Definition: kmeans_init_distributed.h:248
daal::algorithms::kmeans::init::interface2::Distributed< step2Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step2Local, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:693
daal::algorithms::kmeans::init::interface2::Distributed< step4Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step4Local, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:939
daal::algorithms::kmeans::init::interface2::Distributed< step5Master, algorithmFPType, method >::getPartialResult
DistributedStep5MasterPlusPlusPartialResultPtr getPartialResult()
Definition: kmeans_init_distributed.h:1054
daal::algorithms::kmeans::init::interface2::DistributedStep2LocalPlusPlusBase::~DistributedStep2LocalPlusPlusBase
virtual ~DistributedStep2LocalPlusPlusBase()
Definition: kmeans_init_distributed.h:600
daal::algorithms::kmeans::init::interface2::DistributedStep2LocalPlusPlusBase
Base class representing K-Means algorithm initialization in the distributed processing mode...
Definition: kmeans_init_distributed.h:595
daal::step2Master
Definition: daal_defines.h:124
daal::algorithms::kmeans::init::interface2::Distributed< step3Master, algorithmFPType, method >::getPartialResult
DistributedStep3MasterPlusPlusPartialResultPtr getPartialResult()
Definition: kmeans_init_distributed.h:786
daal::algorithms::kmeans::init::interface2::Distributed< step4Local, algorithmFPType, method >::getPartialResult
DistributedStep4LocalPlusPlusPartialResultPtr getPartialResult()
Definition: kmeans_init_distributed.h:909
daal::step3Master
Definition: daal_defines.h:129
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::getResult
ResultPtr getResult()
Definition: kmeans_init_distributed.h:328
daal::services::ErrorNullResult
Definition: error_indexes.h:98
daal::algorithms::AnalysisContainerIface
Abstract interface class that provides virtual methods to access and run implementations of the analy...
Definition: analysis.h:55
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::getPartialResult
PartialResultPtr getPartialResult()
Definition: kmeans_init_distributed.h:349
daal::algorithms::kmeans::init::interface2::Distributed< step3Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step3Master, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:816
daal::algorithms::kmeans::init::interface2::Distributed
class DAAL_EXPORT Distributed
Computes initial clusters for K-Means algorithm in the distributed processing mode.
Definition: kmeans_init_distributed.h:277
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step1Local, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:379
daal_defines.h
daal::algorithms::kmeans::init::interface2::Distributed< step2Master, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the 2nd step of the distributed processing mode...
Definition: kmeans_init_distributed.h:444
daal::step4Local
Definition: daal_defines.h:126
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the first step of the distributed processing mode...
Definition: kmeans_init_distributed.h:297
daal::algorithms::kmeans::init::interface2::DistributedContainer
Provides methods to run implementations of initialization of K-Means algorithm. This class is associa...
Definition: kmeans_init_distributed.h:59
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: kmeans_init_distributed.h:322
daal::algorithms::kmeans::init::interface2::Distributed< step5Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step5Master, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:1084
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::setResult
services::Status setResult(const ResultPtr &result)
Definition: kmeans_init_distributed.h:337
daal::step5Master
Definition: daal_defines.h:130
daal::algorithms::kmeans::init::interface2::Distributed< step3Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedStep3MasterPlusPlusPartialResultPtr &partialRes)
Definition: kmeans_init_distributed.h:795
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::checkFinalizeComputeParams
services::Status checkFinalizeComputeParams() DAAL_C11_OVERRIDE
Definition: kmeans_init_distributed.h:369
daal::algorithms::kmeans::init::interface2::DistributedBase
Base class representing K-Means algorithm initialization in the distributed processing mode...
Definition: kmeans_init_distributed.h:243
daal::algorithms::kmeans::init::interface2::Distributed< step5Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedStep5MasterPlusPlusPartialResultPtr &partialRes)
Definition: kmeans_init_distributed.h:1063
daal::algorithms::kmeans::init::interface2::Distributed< step2Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step2Master, algorithmFPType, method > > clone() const
Definition: kmeans_init_distributed.h:537
daal::algorithms::kmeans::init::interface2::Distributed< step2Local, algorithmFPType, method >::getPartialResult
DistributedStep2LocalPlusPlusPartialResultPtr getPartialResult()
Definition: kmeans_init_distributed.h:663
daal::algorithms::kmeans::init::interface2::Distributed< step5Master, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the 5th step of the distributed processing mode...
Definition: kmeans_init_distributed.h:1003
daal::algorithms::kmeans::init::interface2::Distributed< step4Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedStep4LocalPlusPlusPartialResultPtr &partialRes)
Definition: kmeans_init_distributed.h:918
daal::algorithms::kmeans::init::interface2::Distributed< step1Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const PartialResultPtr &partialRes)
Definition: kmeans_init_distributed.h:358
daal::algorithms::Analysis
Provides methods for execution of operations over data, such as computation of Summary Statistics est...
Definition: analysis.h:70
daal::services::ErrorNullPartialResult
Definition: error_indexes.h:107
daal::distributed
Definition: daal_defines.h:113
daal::algorithms::kmeans::init::interface2::Distributed< step4Local, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the 4th step of the distributed processing mode...
Definition: kmeans_init_distributed.h:881
daal::step2Local
Definition: daal_defines.h:128
daal::algorithms::kmeans::init::interface2::Distributed< step2Local, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the 2nd step of the distributed processing mode...
Definition: kmeans_init_distributed.h:633
daal::algorithms::kmeans::init::interface2::Distributed< step2Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedStep2LocalPlusPlusPartialResultPtr &partialRes)
Definition: kmeans_init_distributed.h:672
daal::algorithms::kmeans::init::interface2::Distributed< step3Master, algorithmFPType, method >
Computes initial clusters for K-Means algorithm in the 3rd step of the distributed processing mode...
Definition: kmeans_init_distributed.h:758

For more complete information about compiler optimizations, see our Optimization Notice.