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

dbscan_types.h
1 /* file: dbscan_types.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 DBSCAN algorithm interface.
19 //--
20 */
21 
22 #ifndef __DBSCAN_TYPES_H__
23 #define __DBSCAN_TYPES_H__
24 
25 #include "algorithms/algorithm.h"
26 #include "data_management/data/numeric_table.h"
27 #include "data_management/data/homogen_numeric_table.h"
28 #include "services/daal_defines.h"
29 
30 namespace daal
31 {
32 namespace algorithms
33 {
41 namespace dbscan
42 {
43 
44 const int noise = -1;
45 const int undefined = -2;
46 
51 enum Method
52 {
53  defaultDense = 0,
54 };
55 
60 enum DistanceType
61 {
62  euclidean,
63  lastDistanceType = euclidean
64 };
65 
70 enum InputId
71 {
72  data,
73  weights,
74  lastInputId = weights
75 };
76 
81 enum ResultToComputeId
82 {
83  computeCoreIndices = 0x00000001ULL,
84  computeCoreObservations = 0x00000002ULL
85 };
86 
91 enum ResultId
92 {
93  assignments,
94  nClusters,
95  coreIndices,
96  coreObservations,
97  lastResultId = coreObservations
98 };
99 
104 enum LocalCollectionInputId
105 {
106  partialData,
107  partialWeights,
108  lastLocalCollectionInputId = partialWeights
109 };
110 
116 enum Step1LocalNumericTableInputId
117 {
118  step1Data,
119  lastStep1LocalNumericTableInputId = data
120 };
121 
127 enum DistributedPartialResultStep1Id
128 {
129  partialOrder,
131  lastDistributedPartialResultStep1Id = partialOrder
132 };
133 
139 enum DistributedPartialResultStep2Id
140 {
141  boundingBox,
144  lastDistributedPartialResultStep2Id = boundingBox
145 };
146 
152 enum Step3LocalCollectionInputId
153 {
154  step3PartialBoundingBoxes = lastLocalCollectionInputId + 1,
155  lastStep3LocalCollectionInputId = step3PartialBoundingBoxes
156 };
157 
163 enum DistributedPartialResultStep3Id
164 {
165  split,
167  lastDistributedPartialResultStep3Id = split
168 };
169 
175 enum Step4LocalCollectionInputId
176 {
177  step4PartialSplits = lastLocalCollectionInputId + 1,
179  step4PartialOrders,
181  lastStep4LocalCollectionInputId = step4PartialOrders
182 };
183 
189 enum DistributedPartialResultStep4Id
190 {
191  partitionedData,
192  partitionedWeights,
193  partitionedPartialOrders,
195  lastDistributedPartialResultStep4Id = partitionedPartialOrders
196 };
197 
203 enum Step5LocalCollectionInputId
204 {
205  step5PartialBoundingBoxes = lastLocalCollectionInputId + 1,
206  lastStep5LocalCollectionInputId = step5PartialBoundingBoxes
207 };
208 
214 enum DistributedPartialResultStep5Id
215 {
216  partitionedHaloData,
217  partitionedHaloDataIndices,
218  partitionedHaloWeights,
219  lastDistributedPartialResultStep5Id = partitionedHaloWeights
220 };
221 
227 enum Step6LocalCollectionInputId
228 {
229  haloData = lastLocalCollectionInputId + 1,
230  haloDataIndices,
231  haloWeights,
232  haloBlocks,
233  lastStep6LocalCollectionInputId = haloBlocks
234 };
235 
241 enum DistributedPartialResultStep6NumericTableId
242 {
243  step6ClusterStructure,
244  step6FinishedFlag,
245  step6NClusters,
246  lastDistributedPartialResultStep6NumericTableId = step6NClusters
247 };
248 
254 enum DistributedPartialResultStep6CollectionId
255 {
256  step6Queries = lastDistributedPartialResultStep6NumericTableId + 1,
257  lastDistributedPartialResultStep6CollectionId = step6Queries
258 };
259 
265 enum Step7MasterCollectionInputId
266 {
267  partialFinishedFlags,
269  lastStep7MasterCollectionInputId = partialFinishedFlags
270 };
271 
277 enum DistributedPartialResultStep7Id
278 {
279  finishedFlag,
280  lastDistributedPartialResultStep7Id = finishedFlag
281 };
282 
288 enum Step8LocalNumericTableInputId
289 {
290  step8InputClusterStructure,
291  step8InputNClusters,
292  lastStep8LocalNumericTableInputId = step8InputNClusters
293 };
294 
300 enum Step8LocalCollectionInputId
301 {
302  step8PartialQueries = lastStep8LocalNumericTableInputId + 1,
303  lastStep8LocalCollectionInputId = step8PartialQueries
304 };
305 
311 enum DistributedPartialResultStep8NumericTableId
312 {
313  step8ClusterStructure,
314  step8FinishedFlag,
315  step8NClusters,
316  lastDistributedPartialResultStep8NumericTableId = step8NClusters
317 };
318 
324 enum DistributedPartialResultStep8CollectionId
325 {
326  step8Queries = lastDistributedPartialResultStep8NumericTableId + 1,
327  lastDistributedPartialResultStep8CollectionId = step8Queries
328 };
329 
335 enum Step9MasterCollectionInputId
336 {
337  partialNClusters,
338  lastStep9MasterCollectionInputId = partialNClusters
339 };
340 
346 enum DistributedResultStep9Id
347 {
348  step9NClusters,
349  lastDistributedResultStep9Id = step9NClusters
350 };
351 
357 enum DistributedPartialResultStep9Id
358 {
359  clusterOffsets,
360  lastDistributedPartialResultStep9Id = clusterOffsets
361 };
362 
368 enum Step10LocalNumericTableInputId
369 {
370  step10InputClusterStructure,
371  step10ClusterOffset,
372  lastStep10LocalNumericTableInputId = step10ClusterOffset
373 };
374 
380 enum DistributedPartialResultStep10NumericTableId
381 {
382  step10ClusterStructure,
383  step10FinishedFlag,
384  lastDistributedPartialResultStep10NumericTableId = step10FinishedFlag
385 };
386 
392 enum DistributedPartialResultStep10CollectionId
393 {
394  step10Queries = lastDistributedPartialResultStep10NumericTableId + 1,
395  lastDistributedPartialResultStep10CollectionId = step10Queries
396 };
397 
403 enum Step11LocalNumericTableInputId
404 {
405  step11InputClusterStructure,
406  lastStep11LocalNumericTableInputId = step11InputClusterStructure
407 };
408 
414 enum Step11LocalCollectionInputId
415 {
416  step11PartialQueries = lastStep11LocalNumericTableInputId + 1,
417  lastStep11LocalCollectionInputId = step11PartialQueries
418 };
419 
425 enum DistributedPartialResultStep11NumericTableId
426 {
427  step11ClusterStructure,
428  step11FinishedFlag,
429  lastDistributedPartialResultStep11NumericTableId = step11FinishedFlag
430 };
431 
437 enum DistributedPartialResultStep11CollectionId
438 {
439  step11Queries = lastDistributedPartialResultStep11NumericTableId + 1,
440  lastDistributedPartialResultStep11CollectionId = step11Queries
441 };
442 
448 enum Step12LocalNumericTableInputId
449 {
450  step12InputClusterStructure,
451  lastStep12LocalNumericTableInputId = step12InputClusterStructure
452 };
453 
459 enum Step12LocalCollectionInputId
460 {
461  step12PartialOrders = lastStep12LocalNumericTableInputId + 1,
463  lastStep12LocalCollectionInputId = step12PartialOrders
464 };
465 
471 enum DistributedPartialResultStep12Id
472 {
473  assignmentQueries,
474  lastDistributedPartialResultStep12Id = assignmentQueries
475 };
476 
482 enum Step13LocalCollectionInputId
483 {
484  partialAssignmentQueries,
485  lastStep13LocalCollectionInputId = partialAssignmentQueries
486 };
487 
493 enum DistributedResultStep13Id
494 {
495  step13Assignments,
496  lastDistributedResultStep13Id = step13Assignments
497 };
498 
504 enum DistributedPartialResultStep13Id
505 {
506  step13AssignmentQueries,
507  lastDistributedPartialResultStep13Id = step13AssignmentQueries
508 };
509 
513 namespace interface1
514 {
523 /* [Parameter source code] */
524 struct DAAL_EXPORT Parameter : public daal::algorithms::Parameter
525 {
529  Parameter();
530 
536  Parameter(double _epsilon, size_t _minObservations);
537 
542  Parameter(const Parameter &other);
543 
544  double epsilon;
545  size_t minObservations;
546  bool memorySavingMode;
547  DAAL_UINT64 resultsToCompute;
549  size_t blockIndex;
550  size_t nBlocks;
552  size_t leftBlocks;
554  size_t rightBlocks;
557  services::Status check() const DAAL_C11_OVERRIDE;
558 };
559 /* [Parameter source code] */
560 
565 class DAAL_EXPORT Input : public daal::algorithms::Input
566 {
567 public:
568  Input();
569  Input(const Input& other) : daal::algorithms::Input(other){}
570 
571  virtual ~Input() {}
572 
578  data_management::NumericTablePtr get(InputId id) const;
579 
585  void set(InputId id, const data_management::NumericTablePtr &ptr);
586 
592  services::Status check(const daal::algorithms::Parameter *par, int method) const DAAL_C11_OVERRIDE;
593 };
594 
599 class DAAL_EXPORT Result : public daal::algorithms::Result
600 {
601 public:
602  DECLARE_SERIALIZABLE_CAST(Result);
603  Result();
604 
605  virtual ~Result() {};
606 
613  template <typename algorithmFPType>
614  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
615 
621  data_management::NumericTablePtr get(ResultId id) const;
622 
628  void set(ResultId id, const data_management::NumericTablePtr &ptr);
629 
636  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *par, int method) const DAAL_C11_OVERRIDE;
637 
638 protected:
640  template<typename Archive, bool onDeserialize>
641  services::Status serialImpl(Archive *arch)
642  {
643  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
644  }
645 };
646 typedef services::SharedPtr<Result> ResultPtr;
647 
652 template<ComputeStep step>
653 class DistributedInput
654 {};
655 
661 template<>
662 class DAAL_EXPORT DistributedInput<step1Local> : public daal::algorithms::Input
663 {
664 public:
666  DistributedInput();
667 
669  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
670 
671  virtual ~DistributedInput() {}
672 
678  data_management::NumericTablePtr get(Step1LocalNumericTableInputId id) const;
679 
685  void set(Step1LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
686 
693  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
694 };
695 
701 class DAAL_EXPORT DistributedPartialResultStep1 : public daal::algorithms::PartialResult
702 {
703 public:
704  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep1);
706  DistributedPartialResultStep1();
707 
708  virtual ~DistributedPartialResultStep1() {}
709 
715  data_management::NumericTablePtr get(DistributedPartialResultStep1Id id) const;
716 
722  void set(DistributedPartialResultStep1Id id, const data_management::NumericTablePtr &ptr);
723 
730  template <typename algorithmFPType>
731  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
732 
739  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
740  int method) const DAAL_C11_OVERRIDE;
741 
742 protected:
744  template<typename Archive, bool onDeserialize>
745  services::Status serialImpl(Archive *arch)
746  {
747  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
748  }
749 };
750 typedef services::SharedPtr<DistributedPartialResultStep1> DistributedPartialResultStep1Ptr;
751 
757 template<>
758 class DAAL_EXPORT DistributedInput<step2Local> : public daal::algorithms::Input
759 {
760 public:
762  DistributedInput();
763 
765  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
766 
767  virtual ~DistributedInput() {}
768 
774  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
775 
781  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
782 
788  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
789 
796  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
797 };
798 
804 class DAAL_EXPORT DistributedPartialResultStep2 : public daal::algorithms::PartialResult
805 {
806 public:
807  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep2);
809  DistributedPartialResultStep2();
810 
811  virtual ~DistributedPartialResultStep2() {}
812 
818  data_management::NumericTablePtr get(DistributedPartialResultStep2Id id) const;
819 
825  void set(DistributedPartialResultStep2Id id, const data_management::NumericTablePtr &ptr);
826 
833  template <typename algorithmFPType>
834  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
835 
842  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
843  int method) const DAAL_C11_OVERRIDE;
844 
845 protected:
847  template<typename Archive, bool onDeserialize>
848  services::Status serialImpl(Archive *arch)
849  {
850  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
851  }
852 };
853 typedef services::SharedPtr<DistributedPartialResultStep2> DistributedPartialResultStep2Ptr;
854 
860 template<>
861 class DAAL_EXPORT DistributedInput<step3Local> : public daal::algorithms::Input
862 {
863 public:
865  DistributedInput();
866 
868  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
869 
870  virtual ~DistributedInput() {}
871 
877  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
878 
884  data_management::DataCollectionPtr get(Step3LocalCollectionInputId id) const;
885 
891  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
892 
898  void set(Step3LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
899 
905  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
906 
912  void add(Step3LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
913 
920  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
921 };
922 
928 class DAAL_EXPORT DistributedPartialResultStep3 : public daal::algorithms::PartialResult
929 {
930 public:
931  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep3);
933  DistributedPartialResultStep3();
934 
935  virtual ~DistributedPartialResultStep3() {}
936 
942  data_management::NumericTablePtr get(DistributedPartialResultStep3Id id) const;
943 
949  void set(DistributedPartialResultStep3Id id, const data_management::NumericTablePtr &ptr);
950 
957  template <typename algorithmFPType>
958  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
959 
966  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
967  int method) const DAAL_C11_OVERRIDE;
968 
969 protected:
971  template<typename Archive, bool onDeserialize>
972  services::Status serialImpl(Archive *arch)
973  {
974  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
975  }
976 };
977 typedef services::SharedPtr<DistributedPartialResultStep3> DistributedPartialResultStep3Ptr;
978 
984 template<>
985 class DAAL_EXPORT DistributedInput<step4Local> : public daal::algorithms::Input
986 {
987 public:
989  DistributedInput();
990 
992  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
993 
994  virtual ~DistributedInput() {}
995 
1001  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1002 
1008  data_management::DataCollectionPtr get(Step4LocalCollectionInputId id) const;
1009 
1015  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1016 
1022  void set(Step4LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1023 
1029  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1030 
1036  void add(Step4LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1037 
1044  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1045 };
1046 
1052 class DAAL_EXPORT DistributedPartialResultStep4 : public daal::algorithms::PartialResult
1053 {
1054 public:
1055  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep4);
1057  DistributedPartialResultStep4();
1058 
1059  virtual ~DistributedPartialResultStep4() {}
1060 
1066  data_management::DataCollectionPtr get(DistributedPartialResultStep4Id id) const;
1067 
1073  void set(DistributedPartialResultStep4Id id, const data_management::DataCollectionPtr &ptr);
1074 
1081  template <typename algorithmFPType>
1082  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1083 
1090  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1091  int method) const DAAL_C11_OVERRIDE;
1092 
1093 protected:
1095  template<typename Archive, bool onDeserialize>
1096  services::Status serialImpl(Archive *arch)
1097  {
1098  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1099  }
1100 };
1101 typedef services::SharedPtr<DistributedPartialResultStep4> DistributedPartialResultStep4Ptr;
1102 
1108 template<>
1109 class DAAL_EXPORT DistributedInput<step5Local> : public daal::algorithms::Input
1110 {
1111 public:
1113  DistributedInput();
1114 
1116  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1117 
1118  virtual ~DistributedInput() {}
1119 
1125  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1126 
1132  data_management::DataCollectionPtr get(Step5LocalCollectionInputId id) const;
1133 
1139  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1140 
1146  void set(Step5LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1147 
1153  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1154 
1160  void add(Step5LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1161 
1168  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1169 };
1170 
1176 class DAAL_EXPORT DistributedPartialResultStep5 : public daal::algorithms::PartialResult
1177 {
1178 public:
1179  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep5);
1181  DistributedPartialResultStep5();
1182 
1183  virtual ~DistributedPartialResultStep5() {}
1184 
1190  data_management::DataCollectionPtr get(DistributedPartialResultStep5Id id) const;
1191 
1197  void set(DistributedPartialResultStep5Id id, const data_management::DataCollectionPtr &ptr);
1198 
1205  template <typename algorithmFPType>
1206  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1207 
1214  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1215  int method) const DAAL_C11_OVERRIDE;
1216 
1217 protected:
1219  template<typename Archive, bool onDeserialize>
1220  services::Status serialImpl(Archive *arch)
1221  {
1222  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1223  }
1224 };
1225 typedef services::SharedPtr<DistributedPartialResultStep5> DistributedPartialResultStep5Ptr;
1226 
1232 template<>
1233 class DAAL_EXPORT DistributedInput<step6Local> : public daal::algorithms::Input
1234 {
1235 public:
1237  DistributedInput();
1238 
1240  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1241 
1242  virtual ~DistributedInput() {}
1243 
1249  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1250 
1256  data_management::DataCollectionPtr get(Step6LocalCollectionInputId id) const;
1257 
1263  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1264 
1270  void set(Step6LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1271 
1277  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1278 
1284  void add(Step6LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1285 
1292  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1293 };
1294 
1300 class DAAL_EXPORT DistributedPartialResultStep6 : public daal::algorithms::PartialResult
1301 {
1302 public:
1303  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep6);
1305  DistributedPartialResultStep6();
1306 
1307  virtual ~DistributedPartialResultStep6() {}
1308 
1314  data_management::NumericTablePtr get(DistributedPartialResultStep6NumericTableId id) const;
1315 
1321  data_management::DataCollectionPtr get(DistributedPartialResultStep6CollectionId id) const;
1322 
1328  void set(DistributedPartialResultStep6NumericTableId id, const data_management::NumericTablePtr &ptr);
1329 
1335  void set(DistributedPartialResultStep6CollectionId id, const data_management::DataCollectionPtr &ptr);
1336 
1343  template <typename algorithmFPType>
1344  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1345 
1352  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1353  int method) const DAAL_C11_OVERRIDE;
1354 
1355 protected:
1357  template<typename Archive, bool onDeserialize>
1358  services::Status serialImpl(Archive *arch)
1359  {
1360  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1361  }
1362 };
1363 typedef services::SharedPtr<DistributedPartialResultStep6> DistributedPartialResultStep6Ptr;
1364 
1370 template<>
1371 class DAAL_EXPORT DistributedInput<step7Master> : public daal::algorithms::Input
1372 {
1373 public:
1375  DistributedInput();
1376 
1378  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1379 
1380  virtual ~DistributedInput() {}
1381 
1387  data_management::DataCollectionPtr get(Step7MasterCollectionInputId id) const;
1388 
1394  void set(Step7MasterCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1395 
1401  void add(Step7MasterCollectionInputId id, const data_management::NumericTablePtr &ptr);
1402 
1409  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1410 };
1411 
1417 class DAAL_EXPORT DistributedPartialResultStep7 : public daal::algorithms::PartialResult
1418 {
1419 public:
1420  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep7);
1422  DistributedPartialResultStep7();
1423 
1424  virtual ~DistributedPartialResultStep7() {}
1425 
1431  data_management::NumericTablePtr get(DistributedPartialResultStep7Id id) const;
1432 
1438  void set(DistributedPartialResultStep7Id id, const data_management::NumericTablePtr &ptr);
1439 
1446  template <typename algorithmFPType>
1447  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1448 
1455  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1456  int method) const DAAL_C11_OVERRIDE;
1457 
1458 protected:
1460  template<typename Archive, bool onDeserialize>
1461  services::Status serialImpl(Archive *arch)
1462  {
1463  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1464  }
1465 };
1466 typedef services::SharedPtr<DistributedPartialResultStep7> DistributedPartialResultStep7Ptr;
1467 
1473 template<>
1474 class DAAL_EXPORT DistributedInput<step8Local> : public daal::algorithms::Input
1475 {
1476 public:
1478  DistributedInput();
1479 
1481  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1482 
1483  virtual ~DistributedInput() {}
1484 
1490  data_management::NumericTablePtr get(Step8LocalNumericTableInputId id) const;
1491 
1497  data_management::DataCollectionPtr get(Step8LocalCollectionInputId id) const;
1498 
1504  void set(Step8LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1505 
1511  void set(Step8LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1512 
1518  void add(Step8LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1519 
1526  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1527 };
1528 
1534 class DAAL_EXPORT DistributedPartialResultStep8 : public daal::algorithms::PartialResult
1535 {
1536 public:
1537  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep8);
1539  DistributedPartialResultStep8();
1540 
1541  virtual ~DistributedPartialResultStep8() {}
1542 
1548  data_management::NumericTablePtr get(DistributedPartialResultStep8NumericTableId id) const;
1549 
1555  data_management::DataCollectionPtr get(DistributedPartialResultStep8CollectionId id) const;
1556 
1562  void set(DistributedPartialResultStep8NumericTableId id, const data_management::NumericTablePtr &ptr);
1563 
1569  void set(DistributedPartialResultStep8CollectionId id, const data_management::DataCollectionPtr &ptr);
1570 
1577  template <typename algorithmFPType>
1578  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1579 
1586  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1587  int method) const DAAL_C11_OVERRIDE;
1588 
1589 protected:
1591  template<typename Archive, bool onDeserialize>
1592  services::Status serialImpl(Archive *arch)
1593  {
1594  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1595  }
1596 };
1597 typedef services::SharedPtr<DistributedPartialResultStep8> DistributedPartialResultStep8Ptr;
1598 
1604 template<>
1605 class DAAL_EXPORT DistributedInput<step9Master> : public daal::algorithms::Input
1606 {
1607 public:
1609  DistributedInput();
1610 
1612  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1613 
1614  virtual ~DistributedInput() {}
1615 
1621  data_management::DataCollectionPtr get(Step9MasterCollectionInputId id) const;
1622 
1628  void set(Step9MasterCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1629 
1635  void add(Step9MasterCollectionInputId id, const data_management::NumericTablePtr &ptr);
1636 
1643  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1644 };
1645 
1651 class DAAL_EXPORT DistributedResultStep9 : public daal::algorithms::Result
1652 {
1653 public:
1654  DECLARE_SERIALIZABLE_CAST(DistributedResultStep9);
1656  DistributedResultStep9();
1657 
1658  virtual ~DistributedResultStep9() {}
1659 
1665  data_management::NumericTablePtr get(DistributedResultStep9Id id) const;
1666 
1672  void set(DistributedResultStep9Id id, const data_management::NumericTablePtr &ptr);
1673 
1680  template <typename algorithmFPType>
1681  DAAL_EXPORT services::Status allocate(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, const int method);
1682 
1689  services::Status check(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1690 
1691 protected:
1693  template<typename Archive, bool onDeserialize>
1694  services::Status serialImpl(Archive *arch)
1695  {
1696  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
1697  }
1698 };
1699 typedef services::SharedPtr<DistributedResultStep9> DistributedResultStep9Ptr;
1700 
1706 class DAAL_EXPORT DistributedPartialResultStep9 : public daal::algorithms::PartialResult
1707 {
1708 public:
1709  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep9);
1711  DistributedPartialResultStep9();
1712 
1713  virtual ~DistributedPartialResultStep9() {}
1714 
1720  data_management::DataCollectionPtr get(DistributedPartialResultStep9Id id) const;
1721 
1727  void set(DistributedPartialResultStep9Id id, const data_management::DataCollectionPtr &ptr);
1728 
1735  template <typename algorithmFPType>
1736  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1737 
1744  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1745  int method) const DAAL_C11_OVERRIDE;
1746 
1747 protected:
1749  template<typename Archive, bool onDeserialize>
1750  services::Status serialImpl(Archive *arch)
1751  {
1752  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1753  }
1754 };
1755 typedef services::SharedPtr<DistributedPartialResultStep9> DistributedPartialResultStep9Ptr;
1756 
1762 template<>
1763 class DAAL_EXPORT DistributedInput<step10Local> : public daal::algorithms::Input
1764 {
1765 public:
1767  DistributedInput();
1768 
1770  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1771 
1772  virtual ~DistributedInput() {}
1773 
1779  data_management::NumericTablePtr get(Step10LocalNumericTableInputId id) const;
1780 
1786  void set(Step10LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1787 
1794  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1795 };
1796 
1802 class DAAL_EXPORT DistributedPartialResultStep10 : public daal::algorithms::PartialResult
1803 {
1804 public:
1805  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep10);
1807  DistributedPartialResultStep10();
1808 
1809  virtual ~DistributedPartialResultStep10() {}
1810 
1816  data_management::NumericTablePtr get(DistributedPartialResultStep10NumericTableId id) const;
1817 
1823  data_management::DataCollectionPtr get(DistributedPartialResultStep10CollectionId id) const;
1824 
1830  void set(DistributedPartialResultStep10NumericTableId id, const data_management::NumericTablePtr &ptr);
1831 
1837  void set(DistributedPartialResultStep10CollectionId id, const data_management::DataCollectionPtr &ptr);
1838 
1845  template <typename algorithmFPType>
1846  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1847 
1854  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1855  int method) const DAAL_C11_OVERRIDE;
1856 
1857 protected:
1859  template<typename Archive, bool onDeserialize>
1860  services::Status serialImpl(Archive *arch)
1861  {
1862  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1863  }
1864 };
1865 typedef services::SharedPtr<DistributedPartialResultStep10> DistributedPartialResultStep10Ptr;
1866 
1872 template<>
1873 class DAAL_EXPORT DistributedInput<step11Local> : public daal::algorithms::Input
1874 {
1875 public:
1877  DistributedInput();
1878 
1880  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1881 
1882  virtual ~DistributedInput() {}
1883 
1889  data_management::NumericTablePtr get(Step11LocalNumericTableInputId id) const;
1890 
1896  data_management::DataCollectionPtr get(Step11LocalCollectionInputId id) const;
1897 
1903  void set(Step11LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1904 
1910  void set(Step11LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1911 
1917  void add(Step11LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1918 
1925  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1926 };
1927 
1933 class DAAL_EXPORT DistributedPartialResultStep11 : public daal::algorithms::PartialResult
1934 {
1935 public:
1936  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep11);
1938  DistributedPartialResultStep11();
1939 
1940  virtual ~DistributedPartialResultStep11() {}
1941 
1947  data_management::NumericTablePtr get(DistributedPartialResultStep11NumericTableId id) const;
1948 
1954  data_management::DataCollectionPtr get(DistributedPartialResultStep11CollectionId id) const;
1955 
1961  void set(DistributedPartialResultStep11NumericTableId id, const data_management::NumericTablePtr &ptr);
1962 
1968  void set(DistributedPartialResultStep11CollectionId id, const data_management::DataCollectionPtr &ptr);
1969 
1976  template <typename algorithmFPType>
1977  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1978 
1985  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1986  int method) const DAAL_C11_OVERRIDE;
1987 
1988 protected:
1990  template<typename Archive, bool onDeserialize>
1991  services::Status serialImpl(Archive *arch)
1992  {
1993  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1994  }
1995 };
1996 typedef services::SharedPtr<DistributedPartialResultStep11> DistributedPartialResultStep11Ptr;
1997 
2003 template<>
2004 class DAAL_EXPORT DistributedInput<step12Local> : public daal::algorithms::Input
2005 {
2006 public:
2008  DistributedInput();
2009 
2011  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
2012 
2013  virtual ~DistributedInput() {}
2014 
2020  data_management::NumericTablePtr get(Step12LocalNumericTableInputId id) const;
2021 
2027  data_management::DataCollectionPtr get(Step12LocalCollectionInputId id) const;
2028 
2034  void set(Step12LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
2035 
2041  void set(Step12LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
2042 
2048  void add(Step12LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
2049 
2056  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2057 };
2058 
2064 class DAAL_EXPORT DistributedPartialResultStep12 : public daal::algorithms::PartialResult
2065 {
2066 public:
2067  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep12);
2069  DistributedPartialResultStep12();
2070 
2071  virtual ~DistributedPartialResultStep12() {}
2072 
2078  data_management::DataCollectionPtr get(DistributedPartialResultStep12Id id) const;
2079 
2085  void set(DistributedPartialResultStep12Id id, const data_management::DataCollectionPtr &ptr);
2086 
2093  template <typename algorithmFPType>
2094  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
2095 
2102  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
2103  int method) const DAAL_C11_OVERRIDE;
2104 
2105 protected:
2107  template<typename Archive, bool onDeserialize>
2108  services::Status serialImpl(Archive *arch)
2109  {
2110  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
2111  }
2112 };
2113 typedef services::SharedPtr<DistributedPartialResultStep12> DistributedPartialResultStep12Ptr;
2114 
2120 template<>
2121 class DAAL_EXPORT DistributedInput<step13Local> : public daal::algorithms::Input
2122 {
2123 public:
2125  DistributedInput();
2126 
2128  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
2129 
2130  virtual ~DistributedInput() {}
2131 
2137  data_management::DataCollectionPtr get(Step13LocalCollectionInputId id) const;
2138 
2144  void set(Step13LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
2145 
2151  void add(Step13LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
2152 
2159  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2160 };
2161 
2167 class DAAL_EXPORT DistributedResultStep13 : public daal::algorithms::Result
2168 {
2169 public:
2170  DECLARE_SERIALIZABLE_CAST(DistributedResultStep13);
2172  DistributedResultStep13();
2173 
2174  virtual ~DistributedResultStep13() {}
2175 
2181  data_management::NumericTablePtr get(DistributedResultStep13Id id) const;
2182 
2188  void set(DistributedResultStep13Id id, const data_management::NumericTablePtr &ptr);
2189 
2196  template <typename algorithmFPType>
2197  DAAL_EXPORT services::Status allocate(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, const int method);
2198 
2205  services::Status check(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2206 
2207 protected:
2209  template<typename Archive, bool onDeserialize>
2210  services::Status serialImpl(Archive *arch)
2211  {
2212  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
2213  }
2214 };
2215 typedef services::SharedPtr<DistributedResultStep13> DistributedResultStep13Ptr;
2216 
2222 class DAAL_EXPORT DistributedPartialResultStep13 : public daal::algorithms::PartialResult
2223 {
2224 public:
2225  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep13);
2227  DistributedPartialResultStep13();
2228 
2229  virtual ~DistributedPartialResultStep13() {}
2230 
2236  data_management::NumericTablePtr get(DistributedPartialResultStep13Id id) const;
2237 
2243  void set(DistributedPartialResultStep13Id id, const data_management::NumericTablePtr &ptr);
2244 
2251  template <typename algorithmFPType>
2252  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
2253 
2260  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
2261  int method) const DAAL_C11_OVERRIDE;
2262 
2263 protected:
2265  template<typename Archive, bool onDeserialize>
2266  services::Status serialImpl(Archive *arch)
2267  {
2268  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
2269  }
2270 };
2271 typedef services::SharedPtr<DistributedPartialResultStep13> DistributedPartialResultStep13Ptr;
2272 
2273 } // namespace interface1
2274 
2275 using interface1::Parameter;
2276 using interface1::Input;
2277 using interface1::Result;
2278 using interface1::ResultPtr;
2279 
2280 using interface1::DistributedInput;
2281 using interface1::DistributedPartialResultStep1;
2282 using interface1::DistributedPartialResultStep1Ptr;
2283 using interface1::DistributedPartialResultStep2;
2284 using interface1::DistributedPartialResultStep2Ptr;
2285 using interface1::DistributedPartialResultStep3;
2286 using interface1::DistributedPartialResultStep3Ptr;
2287 using interface1::DistributedPartialResultStep4;
2288 using interface1::DistributedPartialResultStep4Ptr;
2289 using interface1::DistributedPartialResultStep5;
2290 using interface1::DistributedPartialResultStep5Ptr;
2291 using interface1::DistributedPartialResultStep6;
2292 using interface1::DistributedPartialResultStep6Ptr;
2293 using interface1::DistributedPartialResultStep7;
2294 using interface1::DistributedPartialResultStep7Ptr;
2295 using interface1::DistributedPartialResultStep8;
2296 using interface1::DistributedPartialResultStep8Ptr;
2297 using interface1::DistributedResultStep9;
2298 using interface1::DistributedResultStep9Ptr;
2299 using interface1::DistributedPartialResultStep9;
2300 using interface1::DistributedPartialResultStep9Ptr;
2301 using interface1::DistributedPartialResultStep10;
2302 using interface1::DistributedPartialResultStep10Ptr;
2303 using interface1::DistributedPartialResultStep11;
2304 using interface1::DistributedPartialResultStep11Ptr;
2305 using interface1::DistributedPartialResultStep12;
2306 using interface1::DistributedPartialResultStep12Ptr;
2307 using interface1::DistributedResultStep13;
2308 using interface1::DistributedResultStep13Ptr;
2309 using interface1::DistributedPartialResultStep13;
2310 using interface1::DistributedPartialResultStep13Ptr;
2311 
2312 } // namespace daal::algorithms::dbscan
2314 } // namespace daal::algorithms
2315 } // namespace daal
2316 #endif
daal::algorithms::dbscan::step11PartialQueries
Definition: dbscan_types.h:416
daal::algorithms::dbscan::Step1LocalNumericTableInputId
Step1LocalNumericTableInputId
Definition: dbscan_types.h:116
daal::algorithms::dbscan::interface1::DistributedInput< step11Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1880
daal::algorithms::dbscan::partitionedPartialOrders
Definition: dbscan_types.h:193
daal::step7Master
Definition: daal_defines.h:132
daal::algorithms::dbscan::step6FinishedFlag
Definition: dbscan_types.h:244
daal::algorithms::dbscan::Step8LocalNumericTableInputId
Step8LocalNumericTableInputId
Definition: dbscan_types.h:288
daal::algorithms::dbscan::haloWeights
Definition: dbscan_types.h:231
daal::step2Local
Definition: daal_defines.h:126
daal::algorithms::dbscan::DistributedPartialResultStep11NumericTableId
DistributedPartialResultStep11NumericTableId
Definition: dbscan_types.h:425
daal::algorithms::dbscan::step6Queries
Definition: dbscan_types.h:256
daal::algorithms::dbscan::partitionedHaloData
Definition: dbscan_types.h:216
daal::algorithms::dbscan::partialFinishedFlags
Definition: dbscan_types.h:267
daal::algorithms::dbscan::interface1::DistributedResultStep9
Provides methods to access results obtained with the compute() method of the DBSCAN in the ninth step...
Definition: dbscan_types.h:1651
daal::algorithms::dbscan::partitionedData
Definition: dbscan_types.h:191
daal::algorithms::dbscan::step8Queries
Definition: dbscan_types.h:326
daal
Definition: algorithm_base_common.h:31
daal::step5Local
Definition: daal_defines.h:130
daal::algorithms::dbscan::interface1::DistributedInput< step7Master >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1378
daal::algorithms::dbscan::split
Definition: dbscan_types.h:165
daal::algorithms::dbscan::interface1::Input
Input objects for the DBSCAN algorithm
Definition: dbscan_types.h:565
daal::algorithms::dbscan::interface1::Parameter::resultsToCompute
DAAL_UINT64 resultsToCompute
Definition: dbscan_types.h:547
daal::algorithms::dbscan::DistributedPartialResultStep9Id
DistributedPartialResultStep9Id
Definition: dbscan_types.h:357
daal::algorithms::dbscan::DistributedResultStep9Id
DistributedResultStep9Id
Definition: dbscan_types.h:346
daal::algorithms::dbscan::step9NClusters
Definition: dbscan_types.h:348
daal::step10Local
Definition: daal_defines.h:135
daal::algorithms::dbscan::interface1::DistributedInput
Input objects for the DBSCAN algorithm in the distributed processing mode
Definition: dbscan_types.h:653
daal::algorithms::dbscan::interface1::Parameter::rightBlocks
size_t rightBlocks
Definition: dbscan_types.h:554
daal::algorithms::dbscan::interface1::DistributedPartialResultStep11
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the el...
Definition: dbscan_types.h:1933
daal::algorithms::dbscan::Step9MasterCollectionInputId
Step9MasterCollectionInputId
Definition: dbscan_types.h:335
daal::algorithms::dbscan::interface1::Parameter::memorySavingMode
bool memorySavingMode
Definition: dbscan_types.h:546
daal::algorithms::dbscan::DistributedPartialResultStep13Id
DistributedPartialResultStep13Id
Definition: dbscan_types.h:504
daal::algorithms::dbscan::interface1::DistributedPartialResultStep1
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the fi...
Definition: dbscan_types.h:701
daal::algorithms::dbscan::step13Assignments
Definition: dbscan_types.h:495
daal::algorithms::dbscan::Method
Method
Definition: dbscan_types.h:51
daal::algorithms::dbscan::step8PartialQueries
Definition: dbscan_types.h:302
daal::algorithms::dbscan::interface1::DistributedInput< step2Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:765
daal::algorithms::dbscan::interface1::Parameter
Parameters for the DBSCAN algorithm.
Definition: dbscan_types.h:524
daal::algorithms::dbscan::DistributedPartialResultStep8CollectionId
DistributedPartialResultStep8CollectionId
Definition: dbscan_types.h:324
daal::algorithms::dbscan::DistributedPartialResultStep4Id
DistributedPartialResultStep4Id
Definition: dbscan_types.h:189
daal::algorithms::dbscan::DistributedPartialResultStep12Id
DistributedPartialResultStep12Id
Definition: dbscan_types.h:471
daal::algorithms::dbscan::step6NClusters
Definition: dbscan_types.h:245
daal::algorithms::dbscan::partitionedWeights
Definition: dbscan_types.h:192
daal::algorithms::dbscan::Step6LocalCollectionInputId
Step6LocalCollectionInputId
Definition: dbscan_types.h:227
daal::algorithms::dbscan::data
Definition: dbscan_types.h:72
daal::algorithms::dbscan::DistanceType
DistanceType
Definition: dbscan_types.h:60
daal::algorithms::dbscan::ResultId
ResultId
Available identifiers of results of the DBSCAN algorithm.
Definition: dbscan_types.h:91
daal::algorithms::dbscan::step4PartialSplits
Definition: dbscan_types.h:177
daal::algorithms::dbscan::DistributedPartialResultStep11CollectionId
DistributedPartialResultStep11CollectionId
Definition: dbscan_types.h:437
daal::algorithms::dbscan::interface1::DistributedPartialResultStep3
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the th...
Definition: dbscan_types.h:928
daal::algorithms::dbscan::step5PartialBoundingBoxes
Definition: dbscan_types.h:205
daal::algorithms::dbscan::InputId
InputId
Available identifiers of input objects for the DBSCAN algorithm.
Definition: dbscan_types.h:70
daal::algorithms::dbscan::interface1::DistributedResultStep13
Provides methods to access results obtained with the compute() method of the DBSCAN in the thirteenth...
Definition: dbscan_types.h:2167
daal_defines.h
daal::step9Master
Definition: daal_defines.h:134
daal::algorithms::dbscan::step10Queries
Definition: dbscan_types.h:394
daal::algorithms::dbscan::interface1::Parameter::epsilon
double epsilon
Definition: dbscan_types.h:544
daal::algorithms::dbscan::step11Queries
Definition: dbscan_types.h:439
daal::algorithms::dbscan::coreObservations
Definition: dbscan_types.h:96
daal::algorithms::dbscan::step8InputNClusters
Definition: dbscan_types.h:291
daal::algorithms::dbscan::Step12LocalCollectionInputId
Step12LocalCollectionInputId
Definition: dbscan_types.h:459
daal::algorithms::dbscan::step1Data
Definition: dbscan_types.h:118
daal::algorithms::dbscan::DistributedPartialResultStep10NumericTableId
DistributedPartialResultStep10NumericTableId
Definition: dbscan_types.h:380
daal::algorithms::dbscan::interface1::DistributedPartialResultStep5
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the fi...
Definition: dbscan_types.h:1176
daal::algorithms::dbscan::DistributedPartialResultStep1Id
DistributedPartialResultStep1Id
Definition: dbscan_types.h:127
daal::algorithms::dbscan::DistributedPartialResultStep6CollectionId
DistributedPartialResultStep6CollectionId
Definition: dbscan_types.h:254
daal::algorithms::dbscan::interface1::DistributedInput< step6Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1240
daal::algorithms::dbscan::step6ClusterStructure
Definition: dbscan_types.h:243
daal::algorithms::dbscan::interface1::Result
Results obtained with the compute() method of the DBSCAN algorithm in the batch processing mode...
Definition: dbscan_types.h:599
daal::algorithms::dbscan::step4PartialOrders
Definition: dbscan_types.h:179
daal::algorithms::dbscan::step12InputClusterStructure
Definition: dbscan_types.h:450
daal::algorithms::dbscan::partitionedHaloDataIndices
Definition: dbscan_types.h:217
daal::algorithms::dbscan::weights
Definition: dbscan_types.h:73
daal::algorithms::dbscan::DistributedPartialResultStep10CollectionId
DistributedPartialResultStep10CollectionId
Definition: dbscan_types.h:392
daal::algorithms::dbscan::step8ClusterStructure
Definition: dbscan_types.h:313
daal::algorithms::dbscan::haloDataIndices
Definition: dbscan_types.h:230
daal::algorithms::dbscan::partitionedHaloWeights
Definition: dbscan_types.h:218
daal::algorithms::dbscan::interface1::DistributedPartialResultStep7
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the se...
Definition: dbscan_types.h:1417
daal::algorithms::dbscan::DistributedPartialResultStep5Id
DistributedPartialResultStep5Id
Definition: dbscan_types.h:214
daal::step13Local
Definition: daal_defines.h:138
daal::algorithms::dbscan::Step4LocalCollectionInputId
Step4LocalCollectionInputId
Definition: dbscan_types.h:175
daal::algorithms::dbscan::haloBlocks
Definition: dbscan_types.h:232
daal::algorithms::dbscan::interface1::DistributedInput< step4Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:992
daal::algorithms::dbscan::interface1::DistributedInput< step12Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:2011
daal::algorithms::dbscan::step13AssignmentQueries
Definition: dbscan_types.h:506
daal::algorithms::dbscan::Step10LocalNumericTableInputId
Step10LocalNumericTableInputId
Definition: dbscan_types.h:368
daal::algorithms::dbscan::DistributedPartialResultStep6NumericTableId
DistributedPartialResultStep6NumericTableId
Definition: dbscan_types.h:241
daal::algorithms::dbscan::partialWeights
Definition: dbscan_types.h:107
daal::algorithms::dbscan::coreIndices
Definition: dbscan_types.h:95
daal::algorithms::dbscan::assignmentQueries
Definition: dbscan_types.h:473
daal::algorithms::dbscan::step8InputClusterStructure
Definition: dbscan_types.h:290
daal::algorithms::dbscan::ResultToComputeId
ResultToComputeId
Definition: dbscan_types.h:81
daal::algorithms::dbscan::assignments
Definition: dbscan_types.h:93
daal::algorithms::dbscan::DistributedResultStep13Id
DistributedResultStep13Id
Definition: dbscan_types.h:493
daal::algorithms::dbscan::interface1::DistributedInput< step9Master >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1612
daal::algorithms::dbscan::euclidean
Definition: dbscan_types.h:62
daal::algorithms::dbscan::interface1::DistributedInput< step3Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:868
daal::algorithms::dbscan::interface1::Parameter::nBlocks
size_t nBlocks
Definition: dbscan_types.h:550
daal::algorithms::dbscan::interface1::DistributedPartialResultStep10
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the te...
Definition: dbscan_types.h:1802
daal::algorithms::dbscan::interface1::DistributedPartialResultStep9
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the ni...
Definition: dbscan_types.h:1706
daal::algorithms::dbscan::Step3LocalCollectionInputId
Step3LocalCollectionInputId
Definition: dbscan_types.h:152
daal::algorithms::dbscan::step12PartialOrders
Definition: dbscan_types.h:461
daal::algorithms::dbscan::partialData
Definition: dbscan_types.h:106
daal::algorithms::dbscan::clusterOffsets
Definition: dbscan_types.h:359
daal::algorithms::dbscan::computeCoreObservations
Definition: dbscan_types.h:84
daal::algorithms::dbscan::Step11LocalCollectionInputId
Step11LocalCollectionInputId
Definition: dbscan_types.h:414
daal::algorithms::dbscan::interface1::DistributedInput< step10Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1770
daal::algorithms::dbscan::Step5LocalCollectionInputId
Step5LocalCollectionInputId
Definition: dbscan_types.h:203
daal::step4Local
Definition: daal_defines.h:124
daal::algorithms::dbscan::interface1::DistributedInput< step13Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:2128
daal::algorithms::dbscan::interface1::DistributedPartialResultStep2
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the se...
Definition: dbscan_types.h:804
daal::algorithms::dbscan::interface1::Parameter::blockIndex
size_t blockIndex
Definition: dbscan_types.h:549
daal::algorithms::dbscan::interface1::Parameter::leftBlocks
size_t leftBlocks
Definition: dbscan_types.h:552
daal::algorithms::dbscan::partialNClusters
Definition: dbscan_types.h:337
daal::algorithms::dbscan::Step12LocalNumericTableInputId
Step12LocalNumericTableInputId
Definition: dbscan_types.h:448
daal::algorithms::dbscan::step3PartialBoundingBoxes
Definition: dbscan_types.h:154
daal::algorithms::dbscan::Step8LocalCollectionInputId
Step8LocalCollectionInputId
Definition: dbscan_types.h:300
daal::algorithms::dbscan::interface1::DistributedInput< step1Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:669
daal::algorithms::dbscan::Step7MasterCollectionInputId
Step7MasterCollectionInputId
Definition: dbscan_types.h:265
daal::algorithms::dbscan::interface1::DistributedPartialResultStep12
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the tw...
Definition: dbscan_types.h:2064
daal::algorithms::dbscan::DistributedPartialResultStep2Id
DistributedPartialResultStep2Id
Definition: dbscan_types.h:139
daal::algorithms::dbscan::interface1::DistributedInput< step8Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1481
daal::algorithms::dbscan::interface1::Parameter::minObservations
size_t minObservations
Definition: dbscan_types.h:545
daal::algorithms::dbscan::defaultDense
Definition: dbscan_types.h:53
daal::algorithms::dbscan::haloData
Definition: dbscan_types.h:229
daal::algorithms::dbscan::Step11LocalNumericTableInputId
Step11LocalNumericTableInputId
Definition: dbscan_types.h:403
daal::algorithms::dbscan::step11FinishedFlag
Definition: dbscan_types.h:428
daal::algorithms::dbscan::interface1::DistributedPartialResultStep4
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the fo...
Definition: dbscan_types.h:1052
daal::step1Local
Definition: daal_defines.h:121
daal::algorithms::dbscan::step11ClusterStructure
Definition: dbscan_types.h:427
daal::algorithms::dbscan::Step13LocalCollectionInputId
Step13LocalCollectionInputId
Definition: dbscan_types.h:482
daal::algorithms::dbscan::partialOrder
Definition: dbscan_types.h:129
daal::algorithms::dbscan::computeCoreIndices
Definition: dbscan_types.h:83
daal::algorithms::dbscan::nClusters
Definition: dbscan_types.h:94
daal::algorithms::dbscan::DistributedPartialResultStep7Id
DistributedPartialResultStep7Id
Definition: dbscan_types.h:277
daal::step12Local
Definition: daal_defines.h:137
daal::algorithms::dbscan::step10FinishedFlag
Definition: dbscan_types.h:383
daal::step8Local
Definition: daal_defines.h:133
daal::step6Local
Definition: daal_defines.h:131
daal::algorithms::dbscan::DistributedPartialResultStep3Id
DistributedPartialResultStep3Id
Definition: dbscan_types.h:163
daal::algorithms::dbscan::DistributedPartialResultStep8NumericTableId
DistributedPartialResultStep8NumericTableId
Definition: dbscan_types.h:311
daal::algorithms::dbscan::step8NClusters
Definition: dbscan_types.h:315
daal::algorithms::dbscan::interface1::DistributedPartialResultStep13
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the th...
Definition: dbscan_types.h:2222
daal::algorithms::dbscan::interface1::DistributedPartialResultStep6
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the si...
Definition: dbscan_types.h:1300
daal::algorithms::dbscan::partialAssignmentQueries
Definition: dbscan_types.h:484
daal::step3Local
Definition: daal_defines.h:123
daal::algorithms::dbscan::interface1::DistributedInput< step5Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1116
daal::algorithms::dbscan::step11InputClusterStructure
Definition: dbscan_types.h:405
daal::algorithms::dbscan::step10InputClusterStructure
Definition: dbscan_types.h:370
daal::algorithms::dbscan::boundingBox
Definition: dbscan_types.h:141
daal::algorithms::dbscan::step10ClusterStructure
Definition: dbscan_types.h:382
daal::algorithms::dbscan::finishedFlag
Definition: dbscan_types.h:279
daal::algorithms::dbscan::LocalCollectionInputId
LocalCollectionInputId
Definition: dbscan_types.h:104
daal::step11Local
Definition: daal_defines.h:136
daal::algorithms::dbscan::step8FinishedFlag
Definition: dbscan_types.h:314
daal::algorithms::dbscan::step10ClusterOffset
Definition: dbscan_types.h:371
daal::algorithms::dbscan::interface1::DistributedPartialResultStep8
Provides methods to access partial results obtained with the compute() method of the DBSCAN in the ei...
Definition: dbscan_types.h:1534

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