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

dbscan_distributed.h
1 /* file: dbscan_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 the DBSCAN algorithm in the distributed
21 // processing mode
22 //--
23 */
24 
25 #ifndef __DBSCAN_DISTRIBUTED_H__
26 #define __DBSCAN_DISTRIBUTED_H__
27 
28 #include "algorithms/algorithm.h"
29 #include "data_management/data/numeric_table.h"
30 #include "services/daal_defines.h"
31 #include "algorithms/dbscan/dbscan_types.h"
32 
33 namespace daal
34 {
35 namespace algorithms
36 {
37 namespace dbscan
38 {
39 
40 namespace interface1
41 {
53 template<ComputeStep step, typename algorithmFPType, Method method, CpuType cpu>
54 class DistributedContainer
55 {};
56 
61 template<typename algorithmFPType, Method method, CpuType cpu>
62 class DistributedContainer<step1Local, algorithmFPType, method, cpu> : public
63  TrainingContainerIface<distributed>
64 {
65 public:
71  DistributedContainer(daal::services::Environment::env *daalEnv);
73  ~DistributedContainer();
74 
79  services::Status compute() DAAL_C11_OVERRIDE;
84  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
85 };
86 
91 template<typename algorithmFPType, Method method, CpuType cpu>
92 class DistributedContainer<step2Local, algorithmFPType, method, cpu> : public
93  TrainingContainerIface<distributed>
94 {
95 public:
101  DistributedContainer(daal::services::Environment::env *daalEnv);
103  ~DistributedContainer();
104 
109  services::Status compute() DAAL_C11_OVERRIDE;
114  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
115 };
116 
117 
122 template<typename algorithmFPType, Method method, CpuType cpu>
123 class DistributedContainer<step3Local, algorithmFPType, method, cpu> : public
124  TrainingContainerIface<distributed>
125 {
126 public:
132  DistributedContainer(daal::services::Environment::env *daalEnv);
134  ~DistributedContainer();
135 
140  services::Status compute() DAAL_C11_OVERRIDE;
145  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
146 };
147 
148 
153 template<typename algorithmFPType, Method method, CpuType cpu>
154 class DistributedContainer<step4Local, algorithmFPType, method, cpu> : public
155  TrainingContainerIface<distributed>
156 {
157 public:
163  DistributedContainer(daal::services::Environment::env *daalEnv);
165  ~DistributedContainer();
166 
171  services::Status compute() DAAL_C11_OVERRIDE;
176  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
177 };
178 
179 
184 template<typename algorithmFPType, Method method, CpuType cpu>
185 class DistributedContainer<step5Local, algorithmFPType, method, cpu> : public
186  TrainingContainerIface<distributed>
187 {
188 public:
194  DistributedContainer(daal::services::Environment::env *daalEnv);
196  ~DistributedContainer();
197 
202  services::Status compute() DAAL_C11_OVERRIDE;
207  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
208 };
209 
210 
215 template<typename algorithmFPType, Method method, CpuType cpu>
216 class DistributedContainer<step6Local, algorithmFPType, method, cpu> : public
217  TrainingContainerIface<distributed>
218 {
219 public:
225  DistributedContainer(daal::services::Environment::env *daalEnv);
227  ~DistributedContainer();
228 
233  services::Status compute() DAAL_C11_OVERRIDE;
238  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
239 };
240 
241 
246 template<typename algorithmFPType, Method method, CpuType cpu>
247 class DistributedContainer<step7Master, algorithmFPType, method, cpu> : public
248  TrainingContainerIface<distributed>
249 {
250 public:
256  DistributedContainer(daal::services::Environment::env *daalEnv);
258  ~DistributedContainer();
259 
264  services::Status compute() DAAL_C11_OVERRIDE;
269  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
270 };
271 
272 
277 template<typename algorithmFPType, Method method, CpuType cpu>
278 class DistributedContainer<step8Local, algorithmFPType, method, cpu> : public
279  TrainingContainerIface<distributed>
280 {
281 public:
287  DistributedContainer(daal::services::Environment::env *daalEnv);
289  ~DistributedContainer();
290 
295  services::Status compute() DAAL_C11_OVERRIDE;
300  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
301 };
302 
303 
308 template<typename algorithmFPType, Method method, CpuType cpu>
309 class DistributedContainer<step9Master, algorithmFPType, method, cpu> : public
310  TrainingContainerIface<distributed>
311 {
312 public:
318  DistributedContainer(daal::services::Environment::env *daalEnv);
320  ~DistributedContainer();
321 
326  services::Status compute() DAAL_C11_OVERRIDE;
331  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
332 };
333 
334 
339 template<typename algorithmFPType, Method method, CpuType cpu>
340 class DistributedContainer<step10Local, algorithmFPType, method, cpu> : public
341  TrainingContainerIface<distributed>
342 {
343 public:
349  DistributedContainer(daal::services::Environment::env *daalEnv);
351  ~DistributedContainer();
352 
357  services::Status compute() DAAL_C11_OVERRIDE;
362  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
363 };
364 
365 
370 template<typename algorithmFPType, Method method, CpuType cpu>
371 class DistributedContainer<step11Local, algorithmFPType, method, cpu> : public
372  TrainingContainerIface<distributed>
373 {
374 public:
380  DistributedContainer(daal::services::Environment::env *daalEnv);
382  ~DistributedContainer();
383 
388  services::Status compute() DAAL_C11_OVERRIDE;
393  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
394 };
395 
396 
401 template<typename algorithmFPType, Method method, CpuType cpu>
402 class DistributedContainer<step12Local, algorithmFPType, method, cpu> : public
403  TrainingContainerIface<distributed>
404 {
405 public:
411  DistributedContainer(daal::services::Environment::env *daalEnv);
413  ~DistributedContainer();
414 
419  services::Status compute() DAAL_C11_OVERRIDE;
424  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
425 };
426 
427 
432 template<typename algorithmFPType, Method method, CpuType cpu>
433 class DistributedContainer<step13Local, algorithmFPType, method, cpu> : public
434  TrainingContainerIface<distributed>
435 {
436 public:
442  DistributedContainer(daal::services::Environment::env *daalEnv);
444  ~DistributedContainer();
445 
450  services::Status compute() DAAL_C11_OVERRIDE;
455  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
456 };
457 
475 template<ComputeStep step, typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = defaultDense>
476 class DAAL_EXPORT Distributed {};
477 
491 template<typename algorithmFPType, Method method>
492 class DAAL_EXPORT Distributed<step1Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
493 {
494 public:
495  typedef algorithms::dbscan::DistributedInput<step1Local> InputType;
496  typedef algorithms::dbscan::Parameter ParameterType;
497  typedef algorithms::dbscan::DistributedPartialResultStep1 PartialResultType;
498 
504  Distributed(size_t blockIndex, size_t nBlocks);
505 
512  Distributed(const Distributed<step1Local, algorithmFPType, method> &other);
513 
514  ~Distributed()
515  {
516  delete _par;
517  }
518 
523  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
524 
529  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
530 
535  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
536 
541  DistributedPartialResultStep1Ptr getPartialResult()
542  {
543  return _partialResult;
544  }
545 
549  services::Status setPartialResult(const DistributedPartialResultStep1Ptr& partialRes)
550  {
551  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
552  _partialResult = partialRes;
553  _pres = _partialResult.get();
554  return services::Status();
555  }
556 
562  services::SharedPtr<Distributed<step1Local, algorithmFPType, method> > clone() const
563  {
564  return services::SharedPtr<Distributed<step1Local, algorithmFPType, method> >(cloneImpl());
565  }
566 
567 protected:
568  virtual Distributed<step1Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
569  {
570  return new Distributed<step1Local, algorithmFPType, method>(*this);
571  }
572 
573  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
574  {
575  return services::Status();
576  }
577 
578  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
579  {
580  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
581  _pres = _partialResult.get();
582  return s;
583  }
584 
585  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
586  {
587  return services::Status();
588  }
589 
590  void initialize()
591  {
592  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step1Local, algorithmFPType, method)(&_env);
593  _in = &input;
594  _partialResult.reset(new PartialResultType());
595  }
596 
597 public:
598  InputType input;
600 private:
601  DistributedPartialResultStep1Ptr _partialResult;
602 };
603 
617 template<typename algorithmFPType, Method method>
618 class DAAL_EXPORT Distributed<step2Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
619 {
620 public:
621  typedef algorithms::dbscan::DistributedInput<step2Local> InputType;
622  typedef algorithms::dbscan::Parameter ParameterType;
623  typedef algorithms::dbscan::DistributedPartialResultStep2 PartialResultType;
624 
630  Distributed(size_t blockIndex, size_t nBlocks);
631 
638  Distributed(const Distributed<step2Local, algorithmFPType, method> &other);
639 
640  ~Distributed()
641  {
642  delete _par;
643  }
644 
649  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
650 
655  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
656 
661  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
662 
667  DistributedPartialResultStep2Ptr getPartialResult()
668  {
669  return _partialResult;
670  }
671 
675  services::Status setPartialResult(const DistributedPartialResultStep2Ptr& partialRes)
676  {
677  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
678  _partialResult = partialRes;
679  _pres = _partialResult.get();
680  return services::Status();
681  }
682 
688  services::SharedPtr<Distributed<step2Local, algorithmFPType, method> > clone() const
689  {
690  return services::SharedPtr<Distributed<step2Local, algorithmFPType, method> >(cloneImpl());
691  }
692 
693 protected:
694  virtual Distributed<step2Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
695  {
696  return new Distributed<step2Local, algorithmFPType, method>(*this);
697  }
698 
699  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
700  {
701  return services::Status();
702  }
703 
704  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
705  {
706  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
707  _pres = _partialResult.get();
708  return s;
709  }
710 
711  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
712  {
713  return services::Status();
714  }
715 
716  void initialize()
717  {
718  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step2Local, algorithmFPType, method)(&_env);
719  _in = &input;
720  _partialResult.reset(new PartialResultType());
721  }
722 
723 public:
724  InputType input;
726 private:
727  DistributedPartialResultStep2Ptr _partialResult;
728 };
729 
743 template<typename algorithmFPType, Method method>
744 class DAAL_EXPORT Distributed<step3Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
745 {
746 public:
747  typedef algorithms::dbscan::DistributedInput<step3Local> InputType;
748  typedef algorithms::dbscan::Parameter ParameterType;
749  typedef algorithms::dbscan::DistributedPartialResultStep3 PartialResultType;
750 
758  Distributed(size_t leftBlocks, size_t rightBlocks);
759 
766  Distributed(const Distributed<step3Local, algorithmFPType, method> &other);
767 
768  ~Distributed()
769  {
770  delete _par;
771  }
772 
777  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
778 
783  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
784 
789  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
790 
795  DistributedPartialResultStep3Ptr getPartialResult()
796  {
797  return _partialResult;
798  }
799 
803  services::Status setPartialResult(const DistributedPartialResultStep3Ptr& partialRes)
804  {
805  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
806  _partialResult = partialRes;
807  _pres = _partialResult.get();
808  return services::Status();
809  }
810 
816  services::SharedPtr<Distributed<step3Local, algorithmFPType, method> > clone() const
817  {
818  return services::SharedPtr<Distributed<step3Local, algorithmFPType, method> >(cloneImpl());
819  }
820 
821 protected:
822  virtual Distributed<step3Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
823  {
824  return new Distributed<step3Local, 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  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
835  _pres = _partialResult.get();
836  return s;
837  }
838 
839  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
840  {
841  return services::Status();
842  }
843 
844  void initialize()
845  {
846  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step3Local, algorithmFPType, method)(&_env);
847  _in = &input;
848  _partialResult.reset(new PartialResultType());
849  }
850 
851 public:
852  InputType input;
854 private:
855  DistributedPartialResultStep3Ptr _partialResult;
856 };
857 
871 template<typename algorithmFPType, Method method>
872 class DAAL_EXPORT Distributed<step4Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
873 {
874 public:
875  typedef algorithms::dbscan::DistributedInput<step4Local> InputType;
876  typedef algorithms::dbscan::Parameter ParameterType;
877  typedef algorithms::dbscan::DistributedPartialResultStep4 PartialResultType;
878 
886  Distributed(size_t leftBlocks, size_t rightBlocks);
887 
894  Distributed(const Distributed<step4Local, algorithmFPType, method> &other);
895 
896  ~Distributed()
897  {
898  delete _par;
899  }
900 
905  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
906 
911  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
912 
917  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
918 
923  DistributedPartialResultStep4Ptr getPartialResult()
924  {
925  return _partialResult;
926  }
927 
931  services::Status setPartialResult(const DistributedPartialResultStep4Ptr& partialRes)
932  {
933  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
934  _partialResult = partialRes;
935  _pres = _partialResult.get();
936  return services::Status();
937  }
938 
944  services::SharedPtr<Distributed<step4Local, algorithmFPType, method> > clone() const
945  {
946  return services::SharedPtr<Distributed<step4Local, algorithmFPType, method> >(cloneImpl());
947  }
948 
949 protected:
950  virtual Distributed<step4Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
951  {
952  return new Distributed<step4Local, algorithmFPType, method>(*this);
953  }
954 
955  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
956  {
957  return services::Status();
958  }
959 
960  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
961  {
962  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
963  _pres = _partialResult.get();
964  return s;
965  }
966 
967  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
968  {
969  return services::Status();
970  }
971 
972  void initialize()
973  {
974  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step4Local, algorithmFPType, method)(&_env);
975  _in = &input;
976  _partialResult.reset(new PartialResultType());
977  }
978 
979 public:
980  InputType input;
982 private:
983  DistributedPartialResultStep4Ptr _partialResult;
984 };
985 
999 template<typename algorithmFPType, Method method>
1000 class DAAL_EXPORT Distributed<step5Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1001 {
1002 public:
1003  typedef algorithms::dbscan::DistributedInput<step5Local> InputType;
1004  typedef algorithms::dbscan::Parameter ParameterType;
1005  typedef algorithms::dbscan::DistributedPartialResultStep5 PartialResultType;
1006 
1013  Distributed(size_t blockIndex, size_t nBlocks, algorithmFPType epsilon);
1014 
1021  Distributed(const Distributed<step5Local, algorithmFPType, method> &other);
1022 
1023  ~Distributed()
1024  {
1025  delete _par;
1026  }
1027 
1032  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1033 
1038  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1039 
1044  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1045 
1050  DistributedPartialResultStep5Ptr getPartialResult()
1051  {
1052  return _partialResult;
1053  }
1054 
1058  services::Status setPartialResult(const DistributedPartialResultStep5Ptr& partialRes)
1059  {
1060  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1061  _partialResult = partialRes;
1062  _pres = _partialResult.get();
1063  return services::Status();
1064  }
1065 
1071  services::SharedPtr<Distributed<step5Local, algorithmFPType, method> > clone() const
1072  {
1073  return services::SharedPtr<Distributed<step5Local, algorithmFPType, method> >(cloneImpl());
1074  }
1075 
1076 protected:
1077  virtual Distributed<step5Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1078  {
1079  return new Distributed<step5Local, algorithmFPType, method>(*this);
1080  }
1081 
1082  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1083  {
1084  return services::Status();
1085  }
1086 
1087  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1088  {
1089  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1090  _pres = _partialResult.get();
1091  return s;
1092  }
1093 
1094  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1095  {
1096  return services::Status();
1097  }
1098 
1099  void initialize()
1100  {
1101  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step5Local, algorithmFPType, method)(&_env);
1102  _in = &input;
1103  _partialResult.reset(new PartialResultType());
1104  }
1105 
1106 public:
1107  InputType input;
1109 private:
1110  DistributedPartialResultStep5Ptr _partialResult;
1111 };
1112 
1126 template<typename algorithmFPType, Method method>
1127 class DAAL_EXPORT Distributed<step6Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1128 {
1129 public:
1130  typedef algorithms::dbscan::DistributedInput<step6Local> InputType;
1131  typedef algorithms::dbscan::Parameter ParameterType;
1132  typedef algorithms::dbscan::DistributedPartialResultStep6 PartialResultType;
1133 
1141  Distributed(size_t blockIndex, size_t nBlocks, algorithmFPType epsilon, size_t minObservations);
1142 
1149  Distributed(const Distributed<step6Local, algorithmFPType, method> &other);
1150 
1151  ~Distributed()
1152  {
1153  delete _par;
1154  }
1155 
1160  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1161 
1166  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1167 
1172  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1173 
1178  DistributedPartialResultStep6Ptr getPartialResult()
1179  {
1180  return _partialResult;
1181  }
1182 
1186  services::Status setPartialResult(const DistributedPartialResultStep6Ptr& partialRes)
1187  {
1188  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1189  _partialResult = partialRes;
1190  _pres = _partialResult.get();
1191  return services::Status();
1192  }
1193 
1199  services::SharedPtr<Distributed<step6Local, algorithmFPType, method> > clone() const
1200  {
1201  return services::SharedPtr<Distributed<step6Local, algorithmFPType, method> >(cloneImpl());
1202  }
1203 
1204 protected:
1205  virtual Distributed<step6Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1206  {
1207  return new Distributed<step6Local, algorithmFPType, method>(*this);
1208  }
1209 
1210  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1211  {
1212  return services::Status();
1213  }
1214 
1215  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1216  {
1217  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1218  _pres = _partialResult.get();
1219  return s;
1220  }
1221 
1222  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1223  {
1224  return services::Status();
1225  }
1226 
1227  void initialize()
1228  {
1229  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step6Local, algorithmFPType, method)(&_env);
1230  _in = &input;
1231  _partialResult.reset(new PartialResultType());
1232  }
1233 
1234 public:
1235  InputType input;
1237 private:
1238  DistributedPartialResultStep6Ptr _partialResult;
1239 };
1240 
1254 template<typename algorithmFPType, Method method>
1255 class DAAL_EXPORT Distributed<step7Master, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1256 {
1257 public:
1258  typedef algorithms::dbscan::DistributedInput<step7Master> InputType;
1259  typedef algorithms::dbscan::DistributedPartialResultStep7 PartialResultType;
1260 
1264  Distributed();
1265 
1272  Distributed(const Distributed<step7Master, algorithmFPType, method> &other);
1273 
1274  ~Distributed() {}
1275 
1280  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1281 
1286  DistributedPartialResultStep7Ptr getPartialResult()
1287  {
1288  return _partialResult;
1289  }
1290 
1294  services::Status setPartialResult(const DistributedPartialResultStep7Ptr& partialResult)
1295  {
1296  DAAL_CHECK(partialResult, services::ErrorNullPartialResult)
1297  _partialResult = partialResult;
1298  _pres = _partialResult.get();
1299  return services::Status();
1300  }
1301 
1307  services::SharedPtr<Distributed<step7Master, algorithmFPType, method> > clone() const
1308  {
1309  return services::SharedPtr<Distributed<step7Master, algorithmFPType, method> >(cloneImpl());
1310  }
1311 
1315  virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
1316  {
1317  return services::Status();
1318  }
1319 
1320 protected:
1321  virtual Distributed<step7Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1322  {
1323  return new Distributed<step7Master, algorithmFPType, method>(*this);
1324  }
1325 
1326  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1327  {
1328  return services::Status();
1329  }
1330 
1331  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1332  {
1333  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1334  _pres = _partialResult.get();
1335  return services::Status();
1336  }
1337 
1338  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1339  {
1340  return services::Status();
1341  }
1342 
1343  void initialize()
1344  {
1345  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step7Master, algorithmFPType, method)(&_env);
1346  _in = &input;
1347  _partialResult.reset(new PartialResultType());
1348  }
1349 
1350 public:
1351  InputType input;
1353 private:
1354  DistributedPartialResultStep7Ptr _partialResult;
1355 };
1356 
1370 template<typename algorithmFPType, Method method>
1371 class DAAL_EXPORT Distributed<step8Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1372 {
1373 public:
1374  typedef algorithms::dbscan::DistributedInput<step8Local> InputType;
1375  typedef algorithms::dbscan::Parameter ParameterType;
1376  typedef algorithms::dbscan::DistributedPartialResultStep8 PartialResultType;
1377 
1383  Distributed(size_t blockIndex, size_t nBlocks);
1384 
1391  Distributed(const Distributed<step8Local, algorithmFPType, method> &other);
1392 
1393  ~Distributed()
1394  {
1395  delete _par;
1396  }
1397 
1402  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1403 
1408  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1409 
1414  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1415 
1420  DistributedPartialResultStep8Ptr getPartialResult()
1421  {
1422  return _partialResult;
1423  }
1424 
1428  services::Status setPartialResult(const DistributedPartialResultStep8Ptr& partialRes)
1429  {
1430  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1431  _partialResult = partialRes;
1432  _pres = _partialResult.get();
1433  return services::Status();
1434  }
1435 
1441  services::SharedPtr<Distributed<step8Local, algorithmFPType, method> > clone() const
1442  {
1443  return services::SharedPtr<Distributed<step8Local, algorithmFPType, method> >(cloneImpl());
1444  }
1445 
1446 protected:
1447  virtual Distributed<step8Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1448  {
1449  return new Distributed<step8Local, algorithmFPType, method>(*this);
1450  }
1451 
1452  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1453  {
1454  return services::Status();
1455  }
1456 
1457  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1458  {
1459  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1460  _pres = _partialResult.get();
1461  return s;
1462  }
1463 
1464  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1465  {
1466  return services::Status();
1467  }
1468 
1469  void initialize()
1470  {
1471  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step8Local, algorithmFPType, method)(&_env);
1472  _in = &input;
1473  _partialResult.reset(new PartialResultType());
1474  }
1475 
1476 public:
1477  InputType input;
1479 private:
1480  DistributedPartialResultStep8Ptr _partialResult;
1481 };
1482 
1496 template<typename algorithmFPType, Method method>
1497 class DAAL_EXPORT Distributed<step9Master, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1498 {
1499 public:
1500  typedef algorithms::dbscan::DistributedInput<step9Master> InputType;
1501  typedef algorithms::dbscan::DistributedResultStep9 ResultType;
1502  typedef algorithms::dbscan::DistributedPartialResultStep9 PartialResultType;
1503 
1507  Distributed();
1508 
1515  Distributed(const Distributed<step9Master, algorithmFPType, method> &other);
1516 
1517  ~Distributed() {}
1518 
1523  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1524 
1529  DistributedResultStep9Ptr getResult()
1530  {
1531  return _result;
1532  }
1533 
1537  services::Status setResult(const DistributedResultStep9Ptr& result)
1538  {
1539  DAAL_CHECK(result, services::ErrorNullResult)
1540  _result = result;
1541  _res = _result.get();
1542  return services::Status();
1543  }
1544 
1549  DistributedPartialResultStep9Ptr getPartialResult()
1550  {
1551  return _partialResult;
1552  }
1553 
1557  services::Status setPartialResult(const DistributedPartialResultStep9Ptr& partialRes)
1558  {
1559  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1560  _partialResult = partialRes;
1561  _pres = _partialResult.get();
1562  return services::Status();
1563  }
1564 
1570  services::SharedPtr<Distributed<step9Master, algorithmFPType, method> > clone() const
1571  {
1572  return services::SharedPtr<Distributed<step9Master, algorithmFPType, method> >(cloneImpl());
1573  }
1574 
1575 protected:
1576  virtual Distributed<step9Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1577  {
1578  return new Distributed<step9Master, algorithmFPType, method>(*this);
1579  }
1580 
1581  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1582  {
1583  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int) method);
1584  _res = _result.get();
1585  return services::Status();
1586  }
1587 
1588  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1589  {
1590  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1591  _pres = _partialResult.get();
1592  return s;
1593  }
1594 
1595  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1596  {
1597  return services::Status();
1598  }
1599 
1600  void initialize()
1601  {
1602  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step9Master, algorithmFPType, method)(&_env);
1603  _in = &input;
1604  _result.reset(new ResultType());
1605  _partialResult.reset(new PartialResultType());
1606  }
1607 
1608 public:
1609  InputType input;
1611 private:
1612  DistributedResultStep9Ptr _result;
1613  DistributedPartialResultStep9Ptr _partialResult;
1614 };
1615 
1629 template<typename algorithmFPType, Method method>
1630 class DAAL_EXPORT Distributed<step10Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1631 {
1632 public:
1633  typedef algorithms::dbscan::DistributedInput<step10Local> InputType;
1634  typedef algorithms::dbscan::Parameter ParameterType;
1635  typedef algorithms::dbscan::DistributedPartialResultStep10 PartialResultType;
1636 
1642  Distributed(size_t blockIndex, size_t nBlocks);
1643 
1650  Distributed(const Distributed<step10Local, algorithmFPType, method> &other);
1651 
1652  ~Distributed()
1653  {
1654  delete _par;
1655  }
1656 
1661  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1662 
1667  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1668 
1673  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1674 
1679  DistributedPartialResultStep10Ptr getPartialResult()
1680  {
1681  return _partialResult;
1682  }
1683 
1687  services::Status setPartialResult(const DistributedPartialResultStep10Ptr& partialRes)
1688  {
1689  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1690  _partialResult = partialRes;
1691  _pres = _partialResult.get();
1692  return services::Status();
1693  }
1694 
1700  services::SharedPtr<Distributed<step10Local, algorithmFPType, method> > clone() const
1701  {
1702  return services::SharedPtr<Distributed<step10Local, algorithmFPType, method> >(cloneImpl());
1703  }
1704 
1705 protected:
1706  virtual Distributed<step10Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1707  {
1708  return new Distributed<step10Local, algorithmFPType, method>(*this);
1709  }
1710 
1711  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1712  {
1713  return services::Status();
1714  }
1715 
1716  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1717  {
1718  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1719  _pres = _partialResult.get();
1720  return s;
1721  }
1722 
1723  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1724  {
1725  return services::Status();
1726  }
1727 
1728  void initialize()
1729  {
1730  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step10Local, algorithmFPType, method)(&_env);
1731  _in = &input;
1732  _partialResult.reset(new PartialResultType());
1733  }
1734 
1735 public:
1736  InputType input;
1738 private:
1739  DistributedPartialResultStep10Ptr _partialResult;
1740 };
1741 
1755 template<typename algorithmFPType, Method method>
1756 class DAAL_EXPORT Distributed<step11Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1757 {
1758 public:
1759  typedef algorithms::dbscan::DistributedInput<step11Local> InputType;
1760  typedef algorithms::dbscan::Parameter ParameterType;
1761  typedef algorithms::dbscan::DistributedPartialResultStep11 PartialResultType;
1762 
1768  Distributed(size_t blockIndex, size_t nBlocks);
1769 
1776  Distributed(const Distributed<step11Local, algorithmFPType, method> &other);
1777 
1778  ~Distributed()
1779  {
1780  delete _par;
1781  }
1782 
1787  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1788 
1793  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1794 
1799  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1800 
1805  DistributedPartialResultStep11Ptr getPartialResult()
1806  {
1807  return _partialResult;
1808  }
1809 
1813  services::Status setPartialResult(const DistributedPartialResultStep11Ptr& partialRes)
1814  {
1815  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1816  _partialResult = partialRes;
1817  _pres = _partialResult.get();
1818  return services::Status();
1819  }
1820 
1826  services::SharedPtr<Distributed<step11Local, algorithmFPType, method> > clone() const
1827  {
1828  return services::SharedPtr<Distributed<step11Local, algorithmFPType, method> >(cloneImpl());
1829  }
1830 
1831 protected:
1832  virtual Distributed<step11Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1833  {
1834  return new Distributed<step11Local, algorithmFPType, method>(*this);
1835  }
1836 
1837  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1838  {
1839  return services::Status();
1840  }
1841 
1842  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1843  {
1844  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1845  _pres = _partialResult.get();
1846  return s;
1847  }
1848 
1849  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1850  {
1851  return services::Status();
1852  }
1853 
1854  void initialize()
1855  {
1856  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step11Local, algorithmFPType, method)(&_env);
1857  _in = &input;
1858  _partialResult.reset(new PartialResultType());
1859  }
1860 
1861 public:
1862  InputType input;
1864 private:
1865  DistributedPartialResultStep11Ptr _partialResult;
1866 };
1867 
1881 template<typename algorithmFPType, Method method>
1882 class DAAL_EXPORT Distributed<step12Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1883 {
1884 public:
1885  typedef algorithms::dbscan::DistributedInput<step12Local> InputType;
1886  typedef algorithms::dbscan::Parameter ParameterType;
1887  typedef algorithms::dbscan::DistributedPartialResultStep12 PartialResultType;
1888 
1894  Distributed(size_t blockIndex, size_t nBlocks);
1895 
1902  Distributed(const Distributed<step12Local, algorithmFPType, method> &other);
1903 
1904  ~Distributed()
1905  {
1906  delete _par;
1907  }
1908 
1913  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1914 
1919  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1920 
1925  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1926 
1931  DistributedPartialResultStep12Ptr getPartialResult()
1932  {
1933  return _partialResult;
1934  }
1935 
1939  services::Status setPartialResult(const DistributedPartialResultStep12Ptr& partialRes)
1940  {
1941  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1942  _partialResult = partialRes;
1943  _pres = _partialResult.get();
1944  return services::Status();
1945  }
1946 
1952  services::SharedPtr<Distributed<step12Local, algorithmFPType, method> > clone() const
1953  {
1954  return services::SharedPtr<Distributed<step12Local, algorithmFPType, method> >(cloneImpl());
1955  }
1956 
1957 protected:
1958  virtual Distributed<step12Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1959  {
1960  return new Distributed<step12Local, algorithmFPType, method>(*this);
1961  }
1962 
1963  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1964  {
1965  return services::Status();
1966  }
1967 
1968  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1969  {
1970  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1971  _pres = _partialResult.get();
1972  return s;
1973  }
1974 
1975  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1976  {
1977  return services::Status();
1978  }
1979 
1980  void initialize()
1981  {
1982  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step12Local, algorithmFPType, method)(&_env);
1983  _in = &input;
1984  _partialResult.reset(new PartialResultType());
1985  }
1986 
1987 public:
1988  InputType input;
1990 private:
1991  DistributedPartialResultStep12Ptr _partialResult;
1992 };
1993 
2007 template<typename algorithmFPType, Method method>
2008 class DAAL_EXPORT Distributed<step13Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
2009 {
2010 public:
2011  typedef algorithms::dbscan::DistributedInput<step13Local> InputType;
2012  typedef algorithms::dbscan::DistributedResultStep13 ResultType;
2013  typedef algorithms::dbscan::DistributedPartialResultStep13 PartialResultType;
2014 
2018  Distributed();
2019 
2026  Distributed(const Distributed<step13Local, algorithmFPType, method> &other);
2027 
2028  ~Distributed() {}
2029 
2034  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
2035 
2040  DistributedResultStep13Ptr getResult()
2041  {
2042  return _result;
2043  }
2044 
2048  services::Status setResult(const DistributedResultStep13Ptr& result)
2049  {
2050  DAAL_CHECK(result, services::ErrorNullResult)
2051  _result = result;
2052  _res = _result.get();
2053  return services::Status();
2054  }
2055 
2060  DistributedPartialResultStep13Ptr getPartialResult()
2061  {
2062  return _partialResult;
2063  }
2064 
2068  services::Status setPartialResult(const DistributedPartialResultStep13Ptr& partialResult)
2069  {
2070  DAAL_CHECK(partialResult, services::ErrorNullPartialResult)
2071  _partialResult = partialResult;
2072  _pres = _partialResult.get();
2073  return services::Status();
2074  }
2075 
2081  services::SharedPtr<Distributed<step13Local, algorithmFPType, method> > clone() const
2082  {
2083  return services::SharedPtr<Distributed<step13Local, algorithmFPType, method> >(cloneImpl());
2084  }
2085 
2089  virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
2090  {
2091  return services::Status();
2092  }
2093 
2094 protected:
2095  virtual Distributed<step13Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
2096  {
2097  return new Distributed<step13Local, algorithmFPType, method>(*this);
2098  }
2099 
2100  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
2101  {
2102  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int) method);
2103  _res = _result.get();
2104  return services::Status();
2105  }
2106 
2107  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
2108  {
2109  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
2110  _pres = _partialResult.get();
2111  return services::Status();
2112  }
2113 
2114  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
2115  {
2116  return services::Status();
2117  }
2118 
2119  void initialize()
2120  {
2121  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step13Local, algorithmFPType, method)(&_env);
2122  _in = &input;
2123  _result.reset(new ResultType());
2124  _partialResult.reset(new PartialResultType());
2125  }
2126 
2127 public:
2128  InputType input;
2130 private:
2131  DistributedResultStep13Ptr _result;
2132  DistributedPartialResultStep13Ptr _partialResult;
2133 };
2134 
2136 } // namespace interface1
2137 using interface1::DistributedContainer;
2138 using interface1::Distributed;
2139 
2140 } // namespace daal::algorithms::dbscan
2141 } // namespace daal::algorithms
2142 } // namespace daal
2143 #endif
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::setResult
services::Status setResult(const DistributedResultStep13Ptr &result)
Definition: dbscan_distributed.h:2048
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1799
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep9Ptr &partialRes)
Definition: dbscan_distributed.h:1557
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1667
daal::step1Local
Definition: daal_defines.h:123
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step12Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1952
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep7Ptr getPartialResult()
Definition: dbscan_distributed.h:1286
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:789
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep13Ptr &partialResult)
Definition: dbscan_distributed.h:2068
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the second step of the distributed processing mode...
Definition: dbscan_distributed.h:618
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep6Ptr &partialRes)
Definition: dbscan_distributed.h:1186
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep4Ptr &partialRes)
Definition: dbscan_distributed.h:931
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1919
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:852
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1787
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1925
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:529
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1793
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:980
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:783
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1988
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep12Ptr getPartialResult()
Definition: dbscan_distributed.h:1931
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep10Ptr &partialRes)
Definition: dbscan_distributed.h:1687
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:598
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:649
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1673
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep8Ptr &partialRes)
Definition: dbscan_distributed.h:1428
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1351
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1736
daal::step12Local
Definition: daal_defines.h:139
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step8Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1441
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:2128
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep2Ptr &partialRes)
Definition: dbscan_distributed.h:675
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step1Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:562
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:911
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1862
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep6Ptr getPartialResult()
Definition: dbscan_distributed.h:1178
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the fifth step of the distributed processing mode...
Definition: dbscan_distributed.h:1000
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1280
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:523
daal::step11Local
Definition: daal_defines.h:138
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step6Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1199
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step7Master, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1307
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:661
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step11Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1826
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step13Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:2081
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep9Ptr getPartialResult()
Definition: dbscan_distributed.h:1549
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep11Ptr &partialRes)
Definition: dbscan_distributed.h:1813
daal::algorithms::dbscan::interface1::Distributed
Computes the results of the DBSCAN algorithm in the distributed processing mode.
Definition: dbscan_distributed.h:476
daal::step13Local
Definition: daal_defines.h:140
daal::step3Local
Definition: daal_defines.h:125
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1414
daal::services::ErrorNullResult
Definition: error_indexes.h:98
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the eighth step of the distributed processing mode...
Definition: dbscan_distributed.h:1882
daal::step8Local
Definition: daal_defines.h:135
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the seventh step of the distributed processing mode...
Definition: dbscan_distributed.h:1497
daal::step7Master
Definition: daal_defines.h:134
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1402
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1172
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep5Ptr getPartialResult()
Definition: dbscan_distributed.h:1050
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::step9Master
Definition: daal_defines.h:136
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getResult
DistributedResultStep9Ptr getResult()
Definition: dbscan_distributed.h:1529
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1523
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step3Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:816
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:535
daal_defines.h
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1160
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1044
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1166
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the tenth step of the distributed processing mode...
Definition: dbscan_distributed.h:1630
daal::step4Local
Definition: daal_defines.h:126
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the seventh step of the distributed processing mode...
Definition: dbscan_distributed.h:1255
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step4Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:944
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::checkPartialResult
virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1315
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1408
daal::algorithms::dbscan::interface1::DistributedContainer
Class containing methods to compute the result of DBSCAN algorithm in the distributed processing mode...
Definition: dbscan_distributed.h:54
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep7Ptr &partialResult)
Definition: dbscan_distributed.h:1294
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the first step of the distributed processing mode...
Definition: dbscan_distributed.h:492
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1477
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep3Ptr getPartialResult()
Definition: dbscan_distributed.h:795
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep5Ptr &partialRes)
Definition: dbscan_distributed.h:1058
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep12Ptr &partialRes)
Definition: dbscan_distributed.h:1939
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the third step of the distributed processing mode...
Definition: dbscan_distributed.h:744
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1235
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1609
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep10Ptr getPartialResult()
Definition: dbscan_distributed.h:1679
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep4Ptr getPartialResult()
Definition: dbscan_distributed.h:923
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep2Ptr getPartialResult()
Definition: dbscan_distributed.h:667
daal::step5Local
Definition: daal_defines.h:132
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1032
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::setResult
services::Status setResult(const DistributedResultStep9Ptr &result)
Definition: dbscan_distributed.h:1537
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the seventh step of the distributed processing mode...
Definition: dbscan_distributed.h:2008
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep8Ptr getPartialResult()
Definition: dbscan_distributed.h:1420
daal::step10Local
Definition: daal_defines.h:137
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step2Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:688
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:655
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the eleventh step of the distributed processing mode...
Definition: dbscan_distributed.h:1756
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1038
daal::algorithms::Analysis
Provides methods for execution of operations over data, such as computation of Summary Statistics est...
Definition: analysis.h:70
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getResult
DistributedResultStep13Ptr getResult()
Definition: dbscan_distributed.h:2040
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the eighth step of the distributed processing mode...
Definition: dbscan_distributed.h:1371
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:777
daal::step6Local
Definition: daal_defines.h:133
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:917
daal::services::ErrorNullPartialResult
Definition: error_indexes.h:107
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the fourth step of the distributed processing mode...
Definition: dbscan_distributed.h:872
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1107
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1913
daal::distributed
Definition: daal_defines.h:113
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep13Ptr getPartialResult()
Definition: dbscan_distributed.h:2060
daal::algorithms::TrainingContainerIface
Abstract interface class that provides virtual methods to access and run implementations of the model...
Definition: training.h:52
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep1Ptr getPartialResult()
Definition: dbscan_distributed.h:541
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:905
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep11Ptr getPartialResult()
Definition: dbscan_distributed.h:1805
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::checkPartialResult
virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:2089
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1661
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:2034
daal::step2Local
Definition: daal_defines.h:128
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep1Ptr &partialRes)
Definition: dbscan_distributed.h:549
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >
Computes the results of the DBSCAN algorithm in the sixth step of the distributed processing mode...
Definition: dbscan_distributed.h:1127
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step5Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1071
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:724
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step9Master, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1570
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step10Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1700
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep3Ptr &partialRes)
Definition: dbscan_distributed.h:803

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