C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

dbscan_distributed.h
1 /* file: dbscan_distributed.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Implementation of the interface for the DBSCAN algorithm in the distributed
19 // processing mode
20 //--
21 */
22 
23 #ifndef __DBSCAN_DISTRIBUTED_H__
24 #define __DBSCAN_DISTRIBUTED_H__
25 
26 #include "algorithms/algorithm.h"
27 #include "data_management/data/numeric_table.h"
28 #include "services/daal_defines.h"
29 #include "algorithms/dbscan/dbscan_types.h"
30 
31 namespace daal
32 {
33 namespace algorithms
34 {
35 namespace dbscan
36 {
37 
38 namespace interface1
39 {
51 template<ComputeStep step, typename algorithmFPType, Method method, CpuType cpu>
52 class DAAL_EXPORT DistributedContainer
53 {};
54 
59 template<typename algorithmFPType, Method method, CpuType cpu>
60 class DAAL_EXPORT DistributedContainer<step1Local, algorithmFPType, method, cpu> : public
61  TrainingContainerIface<distributed>
62 {
63 public:
69  DistributedContainer(daal::services::Environment::env *daalEnv);
71  ~DistributedContainer();
72 
77  services::Status compute() DAAL_C11_OVERRIDE;
82  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
83 };
84 
89 template<typename algorithmFPType, Method method, CpuType cpu>
90 class DAAL_EXPORT DistributedContainer<step2Local, algorithmFPType, method, cpu> : public
91  TrainingContainerIface<distributed>
92 {
93 public:
99  DistributedContainer(daal::services::Environment::env *daalEnv);
101  ~DistributedContainer();
102 
107  services::Status compute() DAAL_C11_OVERRIDE;
112  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
113 };
114 
115 
120 template<typename algorithmFPType, Method method, CpuType cpu>
121 class DAAL_EXPORT DistributedContainer<step3Local, algorithmFPType, method, cpu> : public
122  TrainingContainerIface<distributed>
123 {
124 public:
130  DistributedContainer(daal::services::Environment::env *daalEnv);
132  ~DistributedContainer();
133 
138  services::Status compute() DAAL_C11_OVERRIDE;
143  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
144 };
145 
146 
151 template<typename algorithmFPType, Method method, CpuType cpu>
152 class DAAL_EXPORT DistributedContainer<step4Local, algorithmFPType, method, cpu> : public
153  TrainingContainerIface<distributed>
154 {
155 public:
161  DistributedContainer(daal::services::Environment::env *daalEnv);
163  ~DistributedContainer();
164 
169  services::Status compute() DAAL_C11_OVERRIDE;
174  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
175 };
176 
177 
182 template<typename algorithmFPType, Method method, CpuType cpu>
183 class DAAL_EXPORT DistributedContainer<step5Local, algorithmFPType, method, cpu> : public
184  TrainingContainerIface<distributed>
185 {
186 public:
192  DistributedContainer(daal::services::Environment::env *daalEnv);
194  ~DistributedContainer();
195 
200  services::Status compute() DAAL_C11_OVERRIDE;
205  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
206 };
207 
208 
213 template<typename algorithmFPType, Method method, CpuType cpu>
214 class DAAL_EXPORT DistributedContainer<step6Local, algorithmFPType, method, cpu> : public
215  TrainingContainerIface<distributed>
216 {
217 public:
223  DistributedContainer(daal::services::Environment::env *daalEnv);
225  ~DistributedContainer();
226 
231  services::Status compute() DAAL_C11_OVERRIDE;
236  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
237 };
238 
239 
244 template<typename algorithmFPType, Method method, CpuType cpu>
245 class DAAL_EXPORT DistributedContainer<step7Master, algorithmFPType, method, cpu> : public
246  TrainingContainerIface<distributed>
247 {
248 public:
254  DistributedContainer(daal::services::Environment::env *daalEnv);
256  ~DistributedContainer();
257 
262  services::Status compute() DAAL_C11_OVERRIDE;
267  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
268 };
269 
270 
275 template<typename algorithmFPType, Method method, CpuType cpu>
276 class DAAL_EXPORT DistributedContainer<step8Local, algorithmFPType, method, cpu> : public
277  TrainingContainerIface<distributed>
278 {
279 public:
285  DistributedContainer(daal::services::Environment::env *daalEnv);
287  ~DistributedContainer();
288 
293  services::Status compute() DAAL_C11_OVERRIDE;
298  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
299 };
300 
301 
306 template<typename algorithmFPType, Method method, CpuType cpu>
307 class DAAL_EXPORT DistributedContainer<step9Master, algorithmFPType, method, cpu> : public
308  TrainingContainerIface<distributed>
309 {
310 public:
316  DistributedContainer(daal::services::Environment::env *daalEnv);
318  ~DistributedContainer();
319 
324  services::Status compute() DAAL_C11_OVERRIDE;
329  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
330 };
331 
332 
337 template<typename algorithmFPType, Method method, CpuType cpu>
338 class DAAL_EXPORT DistributedContainer<step10Local, algorithmFPType, method, cpu> : public
339  TrainingContainerIface<distributed>
340 {
341 public:
347  DistributedContainer(daal::services::Environment::env *daalEnv);
349  ~DistributedContainer();
350 
355  services::Status compute() DAAL_C11_OVERRIDE;
360  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
361 };
362 
363 
368 template<typename algorithmFPType, Method method, CpuType cpu>
369 class DAAL_EXPORT DistributedContainer<step11Local, algorithmFPType, method, cpu> : public
370  TrainingContainerIface<distributed>
371 {
372 public:
378  DistributedContainer(daal::services::Environment::env *daalEnv);
380  ~DistributedContainer();
381 
386  services::Status compute() DAAL_C11_OVERRIDE;
391  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
392 };
393 
394 
399 template<typename algorithmFPType, Method method, CpuType cpu>
400 class DAAL_EXPORT DistributedContainer<step12Local, algorithmFPType, method, cpu> : public
401  TrainingContainerIface<distributed>
402 {
403 public:
409  DistributedContainer(daal::services::Environment::env *daalEnv);
411  ~DistributedContainer();
412 
417  services::Status compute() DAAL_C11_OVERRIDE;
422  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
423 };
424 
425 
430 template<typename algorithmFPType, Method method, CpuType cpu>
431 class DAAL_EXPORT DistributedContainer<step13Local, algorithmFPType, method, cpu> : public
432  TrainingContainerIface<distributed>
433 {
434 public:
440  DistributedContainer(daal::services::Environment::env *daalEnv);
442  ~DistributedContainer();
443 
448  services::Status compute() DAAL_C11_OVERRIDE;
453  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
454 };
455 
473 template<ComputeStep step, typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = defaultDense>
474 class DAAL_EXPORT Distributed {};
475 
489 template<typename algorithmFPType, Method method>
490 class DAAL_EXPORT Distributed<step1Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
491 {
492 public:
493  typedef algorithms::dbscan::DistributedInput<step1Local> InputType;
494  typedef algorithms::dbscan::Parameter ParameterType;
495  typedef algorithms::dbscan::DistributedPartialResultStep1 PartialResultType;
496 
502  Distributed(size_t blockIndex, size_t nBlocks);
503 
510  Distributed(const Distributed<step1Local, algorithmFPType, method> &other);
511 
512  ~Distributed()
513  {
514  delete _par;
515  }
516 
521  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
522 
527  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
528 
533  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
534 
539  DistributedPartialResultStep1Ptr getPartialResult()
540  {
541  return _partialResult;
542  }
543 
547  services::Status setPartialResult(const DistributedPartialResultStep1Ptr& partialRes)
548  {
549  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
550  _partialResult = partialRes;
551  _pres = _partialResult.get();
552  return services::Status();
553  }
554 
560  services::SharedPtr<Distributed<step1Local, algorithmFPType, method> > clone() const
561  {
562  return services::SharedPtr<Distributed<step1Local, algorithmFPType, method> >(cloneImpl());
563  }
564 
565 protected:
566  virtual Distributed<step1Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
567  {
568  return new Distributed<step1Local, algorithmFPType, method>(*this);
569  }
570 
571  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
572  {
573  return services::Status();
574  }
575 
576  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
577  {
578  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
579  _pres = _partialResult.get();
580  return s;
581  }
582 
583  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
584  {
585  return services::Status();
586  }
587 
588  void initialize()
589  {
590  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step1Local, algorithmFPType, method)(&_env);
591  _in = &input;
592  _partialResult.reset(new PartialResultType());
593  }
594 
595 public:
596  InputType input;
598 private:
599  DistributedPartialResultStep1Ptr _partialResult;
600 };
601 
615 template<typename algorithmFPType, Method method>
616 class DAAL_EXPORT Distributed<step2Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
617 {
618 public:
619  typedef algorithms::dbscan::DistributedInput<step2Local> InputType;
620  typedef algorithms::dbscan::Parameter ParameterType;
621  typedef algorithms::dbscan::DistributedPartialResultStep2 PartialResultType;
622 
628  Distributed(size_t blockIndex, size_t nBlocks);
629 
636  Distributed(const Distributed<step2Local, algorithmFPType, method> &other);
637 
638  ~Distributed()
639  {
640  delete _par;
641  }
642 
647  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
648 
653  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
654 
659  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
660 
665  DistributedPartialResultStep2Ptr getPartialResult()
666  {
667  return _partialResult;
668  }
669 
673  services::Status setPartialResult(const DistributedPartialResultStep2Ptr& partialRes)
674  {
675  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
676  _partialResult = partialRes;
677  _pres = _partialResult.get();
678  return services::Status();
679  }
680 
686  services::SharedPtr<Distributed<step2Local, algorithmFPType, method> > clone() const
687  {
688  return services::SharedPtr<Distributed<step2Local, algorithmFPType, method> >(cloneImpl());
689  }
690 
691 protected:
692  virtual Distributed<step2Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
693  {
694  return new Distributed<step2Local, algorithmFPType, method>(*this);
695  }
696 
697  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
698  {
699  return services::Status();
700  }
701 
702  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
703  {
704  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
705  _pres = _partialResult.get();
706  return s;
707  }
708 
709  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
710  {
711  return services::Status();
712  }
713 
714  void initialize()
715  {
716  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step2Local, algorithmFPType, method)(&_env);
717  _in = &input;
718  _partialResult.reset(new PartialResultType());
719  }
720 
721 public:
722  InputType input;
724 private:
725  DistributedPartialResultStep2Ptr _partialResult;
726 };
727 
741 template<typename algorithmFPType, Method method>
742 class DAAL_EXPORT Distributed<step3Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
743 {
744 public:
745  typedef algorithms::dbscan::DistributedInput<step3Local> InputType;
746  typedef algorithms::dbscan::Parameter ParameterType;
747  typedef algorithms::dbscan::DistributedPartialResultStep3 PartialResultType;
748 
756  Distributed(size_t leftBlocks, size_t rightBlocks);
757 
764  Distributed(const Distributed<step3Local, algorithmFPType, method> &other);
765 
766  ~Distributed()
767  {
768  delete _par;
769  }
770 
775  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
776 
781  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
782 
787  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
788 
793  DistributedPartialResultStep3Ptr getPartialResult()
794  {
795  return _partialResult;
796  }
797 
801  services::Status setPartialResult(const DistributedPartialResultStep3Ptr& partialRes)
802  {
803  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
804  _partialResult = partialRes;
805  _pres = _partialResult.get();
806  return services::Status();
807  }
808 
814  services::SharedPtr<Distributed<step3Local, algorithmFPType, method> > clone() const
815  {
816  return services::SharedPtr<Distributed<step3Local, algorithmFPType, method> >(cloneImpl());
817  }
818 
819 protected:
820  virtual Distributed<step3Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
821  {
822  return new Distributed<step3Local, algorithmFPType, method>(*this);
823  }
824 
825  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
826  {
827  return services::Status();
828  }
829 
830  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
831  {
832  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
833  _pres = _partialResult.get();
834  return s;
835  }
836 
837  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
838  {
839  return services::Status();
840  }
841 
842  void initialize()
843  {
844  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step3Local, algorithmFPType, method)(&_env);
845  _in = &input;
846  _partialResult.reset(new PartialResultType());
847  }
848 
849 public:
850  InputType input;
852 private:
853  DistributedPartialResultStep3Ptr _partialResult;
854 };
855 
869 template<typename algorithmFPType, Method method>
870 class DAAL_EXPORT Distributed<step4Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
871 {
872 public:
873  typedef algorithms::dbscan::DistributedInput<step4Local> InputType;
874  typedef algorithms::dbscan::Parameter ParameterType;
875  typedef algorithms::dbscan::DistributedPartialResultStep4 PartialResultType;
876 
884  Distributed(size_t leftBlocks, size_t rightBlocks);
885 
892  Distributed(const Distributed<step4Local, algorithmFPType, method> &other);
893 
894  ~Distributed()
895  {
896  delete _par;
897  }
898 
903  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
904 
909  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
910 
915  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
916 
921  DistributedPartialResultStep4Ptr getPartialResult()
922  {
923  return _partialResult;
924  }
925 
929  services::Status setPartialResult(const DistributedPartialResultStep4Ptr& partialRes)
930  {
931  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
932  _partialResult = partialRes;
933  _pres = _partialResult.get();
934  return services::Status();
935  }
936 
942  services::SharedPtr<Distributed<step4Local, algorithmFPType, method> > clone() const
943  {
944  return services::SharedPtr<Distributed<step4Local, algorithmFPType, method> >(cloneImpl());
945  }
946 
947 protected:
948  virtual Distributed<step4Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
949  {
950  return new Distributed<step4Local, algorithmFPType, method>(*this);
951  }
952 
953  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
954  {
955  return services::Status();
956  }
957 
958  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
959  {
960  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
961  _pres = _partialResult.get();
962  return s;
963  }
964 
965  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
966  {
967  return services::Status();
968  }
969 
970  void initialize()
971  {
972  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step4Local, algorithmFPType, method)(&_env);
973  _in = &input;
974  _partialResult.reset(new PartialResultType());
975  }
976 
977 public:
978  InputType input;
980 private:
981  DistributedPartialResultStep4Ptr _partialResult;
982 };
983 
997 template<typename algorithmFPType, Method method>
998 class DAAL_EXPORT Distributed<step5Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
999 {
1000 public:
1001  typedef algorithms::dbscan::DistributedInput<step5Local> InputType;
1002  typedef algorithms::dbscan::Parameter ParameterType;
1003  typedef algorithms::dbscan::DistributedPartialResultStep5 PartialResultType;
1004 
1011  Distributed(size_t blockIndex, size_t nBlocks, algorithmFPType epsilon);
1012 
1019  Distributed(const Distributed<step5Local, algorithmFPType, method> &other);
1020 
1021  ~Distributed()
1022  {
1023  delete _par;
1024  }
1025 
1030  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1031 
1036  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1037 
1042  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1043 
1048  DistributedPartialResultStep5Ptr getPartialResult()
1049  {
1050  return _partialResult;
1051  }
1052 
1056  services::Status setPartialResult(const DistributedPartialResultStep5Ptr& partialRes)
1057  {
1058  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1059  _partialResult = partialRes;
1060  _pres = _partialResult.get();
1061  return services::Status();
1062  }
1063 
1069  services::SharedPtr<Distributed<step5Local, algorithmFPType, method> > clone() const
1070  {
1071  return services::SharedPtr<Distributed<step5Local, algorithmFPType, method> >(cloneImpl());
1072  }
1073 
1074 protected:
1075  virtual Distributed<step5Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1076  {
1077  return new Distributed<step5Local, algorithmFPType, method>(*this);
1078  }
1079 
1080  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1081  {
1082  return services::Status();
1083  }
1084 
1085  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1086  {
1087  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1088  _pres = _partialResult.get();
1089  return s;
1090  }
1091 
1092  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1093  {
1094  return services::Status();
1095  }
1096 
1097  void initialize()
1098  {
1099  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step5Local, algorithmFPType, method)(&_env);
1100  _in = &input;
1101  _partialResult.reset(new PartialResultType());
1102  }
1103 
1104 public:
1105  InputType input;
1107 private:
1108  DistributedPartialResultStep5Ptr _partialResult;
1109 };
1110 
1124 template<typename algorithmFPType, Method method>
1125 class DAAL_EXPORT Distributed<step6Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1126 {
1127 public:
1128  typedef algorithms::dbscan::DistributedInput<step6Local> InputType;
1129  typedef algorithms::dbscan::Parameter ParameterType;
1130  typedef algorithms::dbscan::DistributedPartialResultStep6 PartialResultType;
1131 
1139  Distributed(size_t blockIndex, size_t nBlocks, algorithmFPType epsilon, size_t minObservations);
1140 
1147  Distributed(const Distributed<step6Local, algorithmFPType, method> &other);
1148 
1149  ~Distributed()
1150  {
1151  delete _par;
1152  }
1153 
1158  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1159 
1164  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1165 
1170  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1171 
1176  DistributedPartialResultStep6Ptr getPartialResult()
1177  {
1178  return _partialResult;
1179  }
1180 
1184  services::Status setPartialResult(const DistributedPartialResultStep6Ptr& partialRes)
1185  {
1186  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1187  _partialResult = partialRes;
1188  _pres = _partialResult.get();
1189  return services::Status();
1190  }
1191 
1197  services::SharedPtr<Distributed<step6Local, algorithmFPType, method> > clone() const
1198  {
1199  return services::SharedPtr<Distributed<step6Local, algorithmFPType, method> >(cloneImpl());
1200  }
1201 
1202 protected:
1203  virtual Distributed<step6Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1204  {
1205  return new Distributed<step6Local, algorithmFPType, method>(*this);
1206  }
1207 
1208  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1209  {
1210  return services::Status();
1211  }
1212 
1213  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1214  {
1215  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1216  _pres = _partialResult.get();
1217  return s;
1218  }
1219 
1220  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1221  {
1222  return services::Status();
1223  }
1224 
1225  void initialize()
1226  {
1227  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step6Local, algorithmFPType, method)(&_env);
1228  _in = &input;
1229  _partialResult.reset(new PartialResultType());
1230  }
1231 
1232 public:
1233  InputType input;
1235 private:
1236  DistributedPartialResultStep6Ptr _partialResult;
1237 };
1238 
1252 template<typename algorithmFPType, Method method>
1253 class DAAL_EXPORT Distributed<step7Master, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1254 {
1255 public:
1256  typedef algorithms::dbscan::DistributedInput<step7Master> InputType;
1257  typedef algorithms::dbscan::DistributedPartialResultStep7 PartialResultType;
1258 
1262  Distributed();
1263 
1270  Distributed(const Distributed<step7Master, algorithmFPType, method> &other);
1271 
1272  ~Distributed() {}
1273 
1278  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1279 
1284  DistributedPartialResultStep7Ptr getPartialResult()
1285  {
1286  return _partialResult;
1287  }
1288 
1292  services::Status setPartialResult(const DistributedPartialResultStep7Ptr& partialResult)
1293  {
1294  DAAL_CHECK(partialResult, services::ErrorNullPartialResult)
1295  _partialResult = partialResult;
1296  _pres = _partialResult.get();
1297  return services::Status();
1298  }
1299 
1305  services::SharedPtr<Distributed<step7Master, algorithmFPType, method> > clone() const
1306  {
1307  return services::SharedPtr<Distributed<step7Master, algorithmFPType, method> >(cloneImpl());
1308  }
1309 
1313  virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
1314  {
1315  return services::Status();
1316  }
1317 
1318 protected:
1319  virtual Distributed<step7Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1320  {
1321  return new Distributed<step7Master, algorithmFPType, method>(*this);
1322  }
1323 
1324  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1325  {
1326  return services::Status();
1327  }
1328 
1329  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1330  {
1331  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1332  _pres = _partialResult.get();
1333  return services::Status();
1334  }
1335 
1336  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1337  {
1338  return services::Status();
1339  }
1340 
1341  void initialize()
1342  {
1343  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step7Master, algorithmFPType, method)(&_env);
1344  _in = &input;
1345  _partialResult.reset(new PartialResultType());
1346  }
1347 
1348 public:
1349  InputType input;
1351 private:
1352  DistributedPartialResultStep7Ptr _partialResult;
1353 };
1354 
1368 template<typename algorithmFPType, Method method>
1369 class DAAL_EXPORT Distributed<step8Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1370 {
1371 public:
1372  typedef algorithms::dbscan::DistributedInput<step8Local> InputType;
1373  typedef algorithms::dbscan::Parameter ParameterType;
1374  typedef algorithms::dbscan::DistributedPartialResultStep8 PartialResultType;
1375 
1381  Distributed(size_t blockIndex, size_t nBlocks);
1382 
1389  Distributed(const Distributed<step8Local, algorithmFPType, method> &other);
1390 
1391  ~Distributed()
1392  {
1393  delete _par;
1394  }
1395 
1400  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1401 
1406  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1407 
1412  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1413 
1418  DistributedPartialResultStep8Ptr getPartialResult()
1419  {
1420  return _partialResult;
1421  }
1422 
1426  services::Status setPartialResult(const DistributedPartialResultStep8Ptr& partialRes)
1427  {
1428  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1429  _partialResult = partialRes;
1430  _pres = _partialResult.get();
1431  return services::Status();
1432  }
1433 
1439  services::SharedPtr<Distributed<step8Local, algorithmFPType, method> > clone() const
1440  {
1441  return services::SharedPtr<Distributed<step8Local, algorithmFPType, method> >(cloneImpl());
1442  }
1443 
1444 protected:
1445  virtual Distributed<step8Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1446  {
1447  return new Distributed<step8Local, algorithmFPType, method>(*this);
1448  }
1449 
1450  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1451  {
1452  return services::Status();
1453  }
1454 
1455  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1456  {
1457  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1458  _pres = _partialResult.get();
1459  return s;
1460  }
1461 
1462  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1463  {
1464  return services::Status();
1465  }
1466 
1467  void initialize()
1468  {
1469  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step8Local, algorithmFPType, method)(&_env);
1470  _in = &input;
1471  _partialResult.reset(new PartialResultType());
1472  }
1473 
1474 public:
1475  InputType input;
1477 private:
1478  DistributedPartialResultStep8Ptr _partialResult;
1479 };
1480 
1494 template<typename algorithmFPType, Method method>
1495 class DAAL_EXPORT Distributed<step9Master, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1496 {
1497 public:
1498  typedef algorithms::dbscan::DistributedInput<step9Master> InputType;
1499  typedef algorithms::dbscan::DistributedResultStep9 ResultType;
1500  typedef algorithms::dbscan::DistributedPartialResultStep9 PartialResultType;
1501 
1505  Distributed();
1506 
1513  Distributed(const Distributed<step9Master, algorithmFPType, method> &other);
1514 
1515  ~Distributed() {}
1516 
1521  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1522 
1527  DistributedResultStep9Ptr getResult()
1528  {
1529  return _result;
1530  }
1531 
1535  services::Status setResult(const DistributedResultStep9Ptr& result)
1536  {
1537  DAAL_CHECK(result, services::ErrorNullResult)
1538  _result = result;
1539  _res = _result.get();
1540  return services::Status();
1541  }
1542 
1547  DistributedPartialResultStep9Ptr getPartialResult()
1548  {
1549  return _partialResult;
1550  }
1551 
1555  services::Status setPartialResult(const DistributedPartialResultStep9Ptr& partialRes)
1556  {
1557  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1558  _partialResult = partialRes;
1559  _pres = _partialResult.get();
1560  return services::Status();
1561  }
1562 
1568  services::SharedPtr<Distributed<step9Master, algorithmFPType, method> > clone() const
1569  {
1570  return services::SharedPtr<Distributed<step9Master, algorithmFPType, method> >(cloneImpl());
1571  }
1572 
1573 protected:
1574  virtual Distributed<step9Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1575  {
1576  return new Distributed<step9Master, algorithmFPType, method>(*this);
1577  }
1578 
1579  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1580  {
1581  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int) method);
1582  _res = _result.get();
1583  return services::Status();
1584  }
1585 
1586  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1587  {
1588  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1589  _pres = _partialResult.get();
1590  return s;
1591  }
1592 
1593  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1594  {
1595  return services::Status();
1596  }
1597 
1598  void initialize()
1599  {
1600  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step9Master, algorithmFPType, method)(&_env);
1601  _in = &input;
1602  _result.reset(new ResultType());
1603  _partialResult.reset(new PartialResultType());
1604  }
1605 
1606 public:
1607  InputType input;
1609 private:
1610  DistributedResultStep9Ptr _result;
1611  DistributedPartialResultStep9Ptr _partialResult;
1612 };
1613 
1627 template<typename algorithmFPType, Method method>
1628 class DAAL_EXPORT Distributed<step10Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1629 {
1630 public:
1631  typedef algorithms::dbscan::DistributedInput<step10Local> InputType;
1632  typedef algorithms::dbscan::Parameter ParameterType;
1633  typedef algorithms::dbscan::DistributedPartialResultStep10 PartialResultType;
1634 
1640  Distributed(size_t blockIndex, size_t nBlocks);
1641 
1648  Distributed(const Distributed<step10Local, algorithmFPType, method> &other);
1649 
1650  ~Distributed()
1651  {
1652  delete _par;
1653  }
1654 
1659  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1660 
1665  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1666 
1671  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1672 
1677  DistributedPartialResultStep10Ptr getPartialResult()
1678  {
1679  return _partialResult;
1680  }
1681 
1685  services::Status setPartialResult(const DistributedPartialResultStep10Ptr& partialRes)
1686  {
1687  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1688  _partialResult = partialRes;
1689  _pres = _partialResult.get();
1690  return services::Status();
1691  }
1692 
1698  services::SharedPtr<Distributed<step10Local, algorithmFPType, method> > clone() const
1699  {
1700  return services::SharedPtr<Distributed<step10Local, algorithmFPType, method> >(cloneImpl());
1701  }
1702 
1703 protected:
1704  virtual Distributed<step10Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1705  {
1706  return new Distributed<step10Local, algorithmFPType, method>(*this);
1707  }
1708 
1709  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1710  {
1711  return services::Status();
1712  }
1713 
1714  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1715  {
1716  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1717  _pres = _partialResult.get();
1718  return s;
1719  }
1720 
1721  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1722  {
1723  return services::Status();
1724  }
1725 
1726  void initialize()
1727  {
1728  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step10Local, algorithmFPType, method)(&_env);
1729  _in = &input;
1730  _partialResult.reset(new PartialResultType());
1731  }
1732 
1733 public:
1734  InputType input;
1736 private:
1737  DistributedPartialResultStep10Ptr _partialResult;
1738 };
1739 
1753 template<typename algorithmFPType, Method method>
1754 class DAAL_EXPORT Distributed<step11Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1755 {
1756 public:
1757  typedef algorithms::dbscan::DistributedInput<step11Local> InputType;
1758  typedef algorithms::dbscan::Parameter ParameterType;
1759  typedef algorithms::dbscan::DistributedPartialResultStep11 PartialResultType;
1760 
1766  Distributed(size_t blockIndex, size_t nBlocks);
1767 
1774  Distributed(const Distributed<step11Local, algorithmFPType, method> &other);
1775 
1776  ~Distributed()
1777  {
1778  delete _par;
1779  }
1780 
1785  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1786 
1791  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1792 
1797  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1798 
1803  DistributedPartialResultStep11Ptr getPartialResult()
1804  {
1805  return _partialResult;
1806  }
1807 
1811  services::Status setPartialResult(const DistributedPartialResultStep11Ptr& partialRes)
1812  {
1813  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1814  _partialResult = partialRes;
1815  _pres = _partialResult.get();
1816  return services::Status();
1817  }
1818 
1824  services::SharedPtr<Distributed<step11Local, algorithmFPType, method> > clone() const
1825  {
1826  return services::SharedPtr<Distributed<step11Local, algorithmFPType, method> >(cloneImpl());
1827  }
1828 
1829 protected:
1830  virtual Distributed<step11Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1831  {
1832  return new Distributed<step11Local, algorithmFPType, method>(*this);
1833  }
1834 
1835  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1836  {
1837  return services::Status();
1838  }
1839 
1840  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1841  {
1842  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1843  _pres = _partialResult.get();
1844  return s;
1845  }
1846 
1847  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1848  {
1849  return services::Status();
1850  }
1851 
1852  void initialize()
1853  {
1854  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step11Local, algorithmFPType, method)(&_env);
1855  _in = &input;
1856  _partialResult.reset(new PartialResultType());
1857  }
1858 
1859 public:
1860  InputType input;
1862 private:
1863  DistributedPartialResultStep11Ptr _partialResult;
1864 };
1865 
1879 template<typename algorithmFPType, Method method>
1880 class DAAL_EXPORT Distributed<step12Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
1881 {
1882 public:
1883  typedef algorithms::dbscan::DistributedInput<step12Local> InputType;
1884  typedef algorithms::dbscan::Parameter ParameterType;
1885  typedef algorithms::dbscan::DistributedPartialResultStep12 PartialResultType;
1886 
1892  Distributed(size_t blockIndex, size_t nBlocks);
1893 
1900  Distributed(const Distributed<step12Local, algorithmFPType, method> &other);
1901 
1902  ~Distributed()
1903  {
1904  delete _par;
1905  }
1906 
1911  ParameterType& parameter() { return *static_cast<ParameterType*>(_par); }
1912 
1917  const ParameterType& parameter() const { return *static_cast<const ParameterType*>(_par); }
1918 
1923  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
1924 
1929  DistributedPartialResultStep12Ptr getPartialResult()
1930  {
1931  return _partialResult;
1932  }
1933 
1937  services::Status setPartialResult(const DistributedPartialResultStep12Ptr& partialRes)
1938  {
1939  DAAL_CHECK(partialRes, services::ErrorNullPartialResult);
1940  _partialResult = partialRes;
1941  _pres = _partialResult.get();
1942  return services::Status();
1943  }
1944 
1950  services::SharedPtr<Distributed<step12Local, algorithmFPType, method> > clone() const
1951  {
1952  return services::SharedPtr<Distributed<step12Local, algorithmFPType, method> >(cloneImpl());
1953  }
1954 
1955 protected:
1956  virtual Distributed<step12Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
1957  {
1958  return new Distributed<step12Local, algorithmFPType, method>(*this);
1959  }
1960 
1961  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
1962  {
1963  return services::Status();
1964  }
1965 
1966  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
1967  {
1968  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
1969  _pres = _partialResult.get();
1970  return s;
1971  }
1972 
1973  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
1974  {
1975  return services::Status();
1976  }
1977 
1978  void initialize()
1979  {
1980  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step12Local, algorithmFPType, method)(&_env);
1981  _in = &input;
1982  _partialResult.reset(new PartialResultType());
1983  }
1984 
1985 public:
1986  InputType input;
1988 private:
1989  DistributedPartialResultStep12Ptr _partialResult;
1990 };
1991 
2005 template<typename algorithmFPType, Method method>
2006 class DAAL_EXPORT Distributed<step13Local, algorithmFPType, method> : public daal::algorithms::Analysis<distributed>
2007 {
2008 public:
2009  typedef algorithms::dbscan::DistributedInput<step13Local> InputType;
2010  typedef algorithms::dbscan::DistributedResultStep13 ResultType;
2011  typedef algorithms::dbscan::DistributedPartialResultStep13 PartialResultType;
2012 
2016  Distributed();
2017 
2024  Distributed(const Distributed<step13Local, algorithmFPType, method> &other);
2025 
2026  ~Distributed() {}
2027 
2032  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int) method; }
2033 
2038  DistributedResultStep13Ptr getResult()
2039  {
2040  return _result;
2041  }
2042 
2046  services::Status setResult(const DistributedResultStep13Ptr& result)
2047  {
2048  DAAL_CHECK(result, services::ErrorNullResult)
2049  _result = result;
2050  _res = _result.get();
2051  return services::Status();
2052  }
2053 
2058  DistributedPartialResultStep13Ptr getPartialResult()
2059  {
2060  return _partialResult;
2061  }
2062 
2066  services::Status setPartialResult(const DistributedPartialResultStep13Ptr& partialResult)
2067  {
2068  DAAL_CHECK(partialResult, services::ErrorNullPartialResult)
2069  _partialResult = partialResult;
2070  _pres = _partialResult.get();
2071  return services::Status();
2072  }
2073 
2079  services::SharedPtr<Distributed<step13Local, algorithmFPType, method> > clone() const
2080  {
2081  return services::SharedPtr<Distributed<step13Local, algorithmFPType, method> >(cloneImpl());
2082  }
2083 
2087  virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
2088  {
2089  return services::Status();
2090  }
2091 
2092 protected:
2093  virtual Distributed<step13Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
2094  {
2095  return new Distributed<step13Local, algorithmFPType, method>(*this);
2096  }
2097 
2098  virtual services::Status allocateResult() DAAL_C11_OVERRIDE
2099  {
2100  services::Status s = _result->allocate<algorithmFPType>(_pres, _par, (int) method);
2101  _res = _result.get();
2102  return services::Status();
2103  }
2104 
2105  virtual services::Status allocatePartialResult() DAAL_C11_OVERRIDE
2106  {
2107  services::Status s = _partialResult->allocate<algorithmFPType>(&input, _par, (int) method);
2108  _pres = _partialResult.get();
2109  return services::Status();
2110  }
2111 
2112  virtual services::Status initializePartialResult() DAAL_C11_OVERRIDE
2113  {
2114  return services::Status();
2115  }
2116 
2117  void initialize()
2118  {
2119  Analysis<distributed>::_ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step13Local, algorithmFPType, method)(&_env);
2120  _in = &input;
2121  _result.reset(new ResultType());
2122  _partialResult.reset(new PartialResultType());
2123  }
2124 
2125 public:
2126  InputType input;
2128 private:
2129  DistributedResultStep13Ptr _result;
2130  DistributedPartialResultStep13Ptr _partialResult;
2131 };
2132 
2134 } // namespace interface1
2135 using interface1::DistributedContainer;
2136 using interface1::Distributed;
2137 
2138 } // namespace daal::algorithms::dbscan
2139 } // namespace daal::algorithms
2140 } // namespace daal
2141 #endif
daal::step7Master
Definition: daal_defines.h:132
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step6Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1197
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step1Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:560
daal::step2Local
Definition: daal_defines.h:126
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::checkPartialResult
virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:2087
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step7Master, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1305
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step3Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:814
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1400
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep1Ptr getPartialResult()
Definition: dbscan_distributed.h:539
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1607
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:781
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep10Ptr getPartialResult()
Definition: dbscan_distributed.h:1677
daal
Definition: algorithm_base_common.h:31
daal::step5Local
Definition: daal_defines.h:130
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:616
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:2032
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:909
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getResult
DistributedResultStep13Ptr getResult()
Definition: dbscan_distributed.h:2038
daal::step10Local
Definition: daal_defines.h:135
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:2126
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::setResult
services::Status setResult(const DistributedResultStep13Ptr &result)
Definition: dbscan_distributed.h:2046
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:915
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep11Ptr getPartialResult()
Definition: dbscan_distributed.h:1803
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:775
daal::services::ErrorNullPartialResult
Definition: error_indexes.h:105
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1406
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getResult
DistributedResultStep9Ptr getResult()
Definition: dbscan_distributed.h:1527
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step12Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1950
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:533
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1911
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step2Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:686
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1917
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1797
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:659
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1030
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:998
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep5Ptr getPartialResult()
Definition: dbscan_distributed.h:1048
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:1628
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step8Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1439
daal_defines.h
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep7Ptr getPartialResult()
Definition: dbscan_distributed.h:1284
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::checkPartialResult
virtual services::Status checkPartialResult() DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1313
daal::step9Master
Definition: daal_defines.h:134
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1105
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step10Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1698
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1986
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:653
daal::algorithms::kmeans::init::interface2::Distributed
class DAAL_EXPORT Distributed
Computes initial clusters for the K-Means algorithm in the distributed processing mode...
Definition: kmeans_init_distributed.h:275
daal::distributed
Definition: daal_defines.h:111
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1412
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep3Ptr getPartialResult()
Definition: dbscan_distributed.h:793
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1734
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep8Ptr getPartialResult()
Definition: dbscan_distributed.h:1418
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step11Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1824
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:978
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1158
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:1754
daal::step13Local
Definition: daal_defines.h:138
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1665
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::setResult
services::Status setResult(const DistributedResultStep9Ptr &result)
Definition: dbscan_distributed.h:1535
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep6Ptr getPartialResult()
Definition: dbscan_distributed.h:1176
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1349
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep4Ptr getPartialResult()
Definition: dbscan_distributed.h:921
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1671
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1233
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:742
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:527
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep9Ptr getPartialResult()
Definition: dbscan_distributed.h:1547
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:521
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:1369
daal::step4Local
Definition: daal_defines.h:124
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep2Ptr getPartialResult()
Definition: dbscan_distributed.h:665
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1791
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep4Ptr &partialRes)
Definition: dbscan_distributed.h:929
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1521
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:1253
daal::algorithms::Analysis
Provides methods for execution of operations over data, such as computation of Summary Statistics est...
Definition: analysis.h:68
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step4Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:942
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep11Ptr &partialRes)
Definition: dbscan_distributed.h:1811
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep12Ptr getPartialResult()
Definition: dbscan_distributed.h:1929
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep3Ptr &partialRes)
Definition: dbscan_distributed.h:801
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step9Master, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1568
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:596
daal::algorithms::dbscan::interface1::Distributed< step1Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep1Ptr &partialRes)
Definition: dbscan_distributed.h:547
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:1880
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep2Ptr &partialRes)
Definition: dbscan_distributed.h:673
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1164
daal::algorithms::kmeans::interface1::DistributedContainer
class DAAL_EXPORT DistributedContainer
Provides methods to run implementations of the K-Means algorithm. This class is associated with the d...
Definition: kmeans_distributed.h:55
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep6Ptr &partialRes)
Definition: dbscan_distributed.h:1184
daal::step1Local
Definition: daal_defines.h:121
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1475
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep12Ptr &partialRes)
Definition: dbscan_distributed.h:1937
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep7Ptr &partialResult)
Definition: dbscan_distributed.h:1292
daal::algorithms::dbscan::interface1::Distributed< step4Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:903
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:787
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:870
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:1495
daal::step12Local
Definition: daal_defines.h:137
daal::step8Local
Definition: daal_defines.h:133
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1785
daal::step6Local
Definition: daal_defines.h:131
daal::algorithms::dbscan::interface1::Distributed
Computes the results of the DBSCAN algorithm in the distributed processing mode.
Definition: dbscan_distributed.h:474
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep10Ptr &partialRes)
Definition: dbscan_distributed.h:1685
daal::algorithms::dbscan::interface1::Distributed< step12Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1923
daal::step3Local
Definition: daal_defines.h:123
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1042
daal::algorithms::dbscan::interface1::Distributed< step9Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep9Ptr &partialRes)
Definition: dbscan_distributed.h:1555
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:647
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:490
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step13Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:2079
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep13Ptr getPartialResult()
Definition: dbscan_distributed.h:2058
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step5Local, algorithmFPType, method > > clone() const
Definition: dbscan_distributed.h:1069
daal::algorithms::dbscan::interface1::Distributed< step3Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:850
daal::services::ErrorNullResult
Definition: error_indexes.h:96
daal::algorithms::dbscan::interface1::DistributedContainer
Class containing methods to compute the result of DBSCAN algorithm in the distributed processing mode...
Definition: dbscan_distributed.h:52
daal::algorithms::dbscan::interface1::Distributed< step6Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1170
daal::step11Local
Definition: daal_defines.h:136
daal::algorithms::TrainingContainerIface
Abstract interface class that provides virtual methods to access and run implementations of the model...
Definition: training.h:50
daal::algorithms::dbscan::interface1::Distributed< step8Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep8Ptr &partialRes)
Definition: dbscan_distributed.h:1426
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:1125
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:2006
daal::algorithms::dbscan::interface1::Distributed< step2Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:722
daal::algorithms::dbscan::interface1::Distributed< step13Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep13Ptr &partialResult)
Definition: dbscan_distributed.h:2066
daal::algorithms::dbscan::interface1::Distributed< step7Master, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: dbscan_distributed.h:1278
daal::algorithms::dbscan::interface1::Distributed< step10Local, algorithmFPType, method >::parameter
ParameterType & parameter()
Definition: dbscan_distributed.h:1659
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep5Ptr &partialRes)
Definition: dbscan_distributed.h:1056
daal::algorithms::dbscan::interface1::Distributed< step11Local, algorithmFPType, method >::input
InputType input
Definition: dbscan_distributed.h:1860
daal::algorithms::dbscan::interface1::Distributed< step5Local, algorithmFPType, method >::parameter
const ParameterType & parameter() const
Definition: dbscan_distributed.h:1036

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