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

dbscan_types.h
1 /* file: dbscan_types.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of the DBSCAN algorithm interface.
21 //--
22 */
23 
24 #ifndef __DBSCAN_TYPES_H__
25 #define __DBSCAN_TYPES_H__
26 
27 #include "algorithms/algorithm.h"
28 #include "data_management/data/numeric_table.h"
29 #include "data_management/data/homogen_numeric_table.h"
30 #include "services/daal_defines.h"
31 
32 namespace daal
33 {
34 namespace algorithms
35 {
43 namespace dbscan
44 {
45 
46 const int noise = -1;
47 const int undefined = -2;
48 
53 enum Method
54 {
55  defaultDense = 0,
56 };
57 
62 enum DistanceType
63 {
64  euclidean,
65  lastDistanceType = euclidean
66 };
67 
72 enum InputId
73 {
74  data,
75  weights,
76  lastInputId = weights
77 };
78 
83 enum ResultToComputeId
84 {
85  computeCoreIndices = 0x00000001ULL,
86  computeCoreObservations = 0x00000002ULL
87 };
88 
93 enum ResultId
94 {
95  assignments,
96  nClusters,
97  coreIndices,
98  coreObservations,
99  lastResultId = coreObservations
100 };
101 
106 enum LocalCollectionInputId
107 {
108  partialData,
109  partialWeights,
110  lastLocalCollectionInputId = partialWeights
111 };
112 
118 enum Step1LocalNumericTableInputId
119 {
120  step1Data,
121  lastStep1LocalNumericTableInputId = data
122 };
123 
129 enum DistributedPartialResultStep1Id
130 {
131  partialOrder,
133  lastDistributedPartialResultStep1Id = partialOrder
134 };
135 
141 enum DistributedPartialResultStep2Id
142 {
143  boundingBox,
146  lastDistributedPartialResultStep2Id = boundingBox
147 };
148 
154 enum Step3LocalCollectionInputId
155 {
156  step3PartialBoundingBoxes = lastLocalCollectionInputId + 1,
157  lastStep3LocalCollectionInputId = step3PartialBoundingBoxes
158 };
159 
165 enum DistributedPartialResultStep3Id
166 {
167  split,
169  lastDistributedPartialResultStep3Id = split
170 };
171 
177 enum Step4LocalCollectionInputId
178 {
179  step4PartialSplits = lastLocalCollectionInputId + 1,
181  step4PartialOrders,
183  lastStep4LocalCollectionInputId = step4PartialOrders
184 };
185 
191 enum DistributedPartialResultStep4Id
192 {
193  partitionedData,
194  partitionedWeights,
195  partitionedPartialOrders,
197  lastDistributedPartialResultStep4Id = partitionedPartialOrders
198 };
199 
205 enum Step5LocalCollectionInputId
206 {
207  step5PartialBoundingBoxes = lastLocalCollectionInputId + 1,
208  lastStep5LocalCollectionInputId = step5PartialBoundingBoxes
209 };
210 
216 enum DistributedPartialResultStep5Id
217 {
218  partitionedHaloData,
219  partitionedHaloDataIndices,
220  partitionedHaloWeights,
221  lastDistributedPartialResultStep5Id = partitionedHaloWeights
222 };
223 
229 enum Step6LocalCollectionInputId
230 {
231  haloData = lastLocalCollectionInputId + 1,
232  haloDataIndices,
233  haloWeights,
234  haloBlocks,
235  lastStep6LocalCollectionInputId = haloBlocks
236 };
237 
243 enum DistributedPartialResultStep6NumericTableId
244 {
245  step6ClusterStructure,
246  step6FinishedFlag,
247  step6NClusters,
248  lastDistributedPartialResultStep6NumericTableId = step6NClusters
249 };
250 
256 enum DistributedPartialResultStep6CollectionId
257 {
258  step6Queries = lastDistributedPartialResultStep6NumericTableId + 1,
259  lastDistributedPartialResultStep6CollectionId = step6Queries
260 };
261 
267 enum Step7MasterCollectionInputId
268 {
269  partialFinishedFlags,
271  lastStep7MasterCollectionInputId = partialFinishedFlags
272 };
273 
279 enum DistributedPartialResultStep7Id
280 {
281  finishedFlag,
282  lastDistributedPartialResultStep7Id = finishedFlag
283 };
284 
290 enum Step8LocalNumericTableInputId
291 {
292  step8InputClusterStructure,
293  step8InputNClusters,
294  lastStep8LocalNumericTableInputId = step8InputNClusters
295 };
296 
302 enum Step8LocalCollectionInputId
303 {
304  step8PartialQueries = lastStep8LocalNumericTableInputId + 1,
305  lastStep8LocalCollectionInputId = step8PartialQueries
306 };
307 
313 enum DistributedPartialResultStep8NumericTableId
314 {
315  step8ClusterStructure,
316  step8FinishedFlag,
317  step8NClusters,
318  lastDistributedPartialResultStep8NumericTableId = step8NClusters
319 };
320 
326 enum DistributedPartialResultStep8CollectionId
327 {
328  step8Queries = lastDistributedPartialResultStep8NumericTableId + 1,
329  lastDistributedPartialResultStep8CollectionId = step8Queries
330 };
331 
337 enum Step9MasterCollectionInputId
338 {
339  partialNClusters,
340  lastStep9MasterCollectionInputId = partialNClusters
341 };
342 
348 enum DistributedResultStep9Id
349 {
350  step9NClusters,
351  lastDistributedResultStep9Id = step9NClusters
352 };
353 
359 enum DistributedPartialResultStep9Id
360 {
361  clusterOffsets,
362  lastDistributedPartialResultStep9Id = clusterOffsets
363 };
364 
370 enum Step10LocalNumericTableInputId
371 {
372  step10InputClusterStructure,
373  step10ClusterOffset,
374  lastStep10LocalNumericTableInputId = step10ClusterOffset
375 };
376 
382 enum DistributedPartialResultStep10NumericTableId
383 {
384  step10ClusterStructure,
385  step10FinishedFlag,
386  lastDistributedPartialResultStep10NumericTableId = step10FinishedFlag
387 };
388 
394 enum DistributedPartialResultStep10CollectionId
395 {
396  step10Queries = lastDistributedPartialResultStep10NumericTableId + 1,
397  lastDistributedPartialResultStep10CollectionId = step10Queries
398 };
399 
405 enum Step11LocalNumericTableInputId
406 {
407  step11InputClusterStructure,
408  lastStep11LocalNumericTableInputId = step11InputClusterStructure
409 };
410 
416 enum Step11LocalCollectionInputId
417 {
418  step11PartialQueries = lastStep11LocalNumericTableInputId + 1,
419  lastStep11LocalCollectionInputId = step11PartialQueries
420 };
421 
427 enum DistributedPartialResultStep11NumericTableId
428 {
429  step11ClusterStructure,
430  step11FinishedFlag,
431  lastDistributedPartialResultStep11NumericTableId = step11FinishedFlag
432 };
433 
439 enum DistributedPartialResultStep11CollectionId
440 {
441  step11Queries = lastDistributedPartialResultStep11NumericTableId + 1,
442  lastDistributedPartialResultStep11CollectionId = step11Queries
443 };
444 
450 enum Step12LocalNumericTableInputId
451 {
452  step12InputClusterStructure,
453  lastStep12LocalNumericTableInputId = step12InputClusterStructure
454 };
455 
461 enum Step12LocalCollectionInputId
462 {
463  step12PartialOrders = lastStep12LocalNumericTableInputId + 1,
465  lastStep12LocalCollectionInputId = step12PartialOrders
466 };
467 
473 enum DistributedPartialResultStep12Id
474 {
475  assignmentQueries,
476  lastDistributedPartialResultStep12Id = assignmentQueries
477 };
478 
484 enum Step13LocalCollectionInputId
485 {
486  partialAssignmentQueries,
487  lastStep13LocalCollectionInputId = partialAssignmentQueries
488 };
489 
495 enum DistributedResultStep13Id
496 {
497  step13Assignments,
498  lastDistributedResultStep13Id = step13Assignments
499 };
500 
506 enum DistributedPartialResultStep13Id
507 {
508  step13AssignmentQueries,
509  lastDistributedPartialResultStep13Id = step13AssignmentQueries
510 };
511 
515 namespace interface1
516 {
525 /* [Parameter source code] */
526 struct DAAL_EXPORT Parameter : public daal::algorithms::Parameter
527 {
531  Parameter();
532 
538  Parameter(double _epsilon, size_t _minObservations);
539 
544  Parameter(const Parameter &other);
545 
546  double epsilon;
547  size_t minObservations;
548  bool memorySavingMode;
549  DAAL_UINT64 resultsToCompute;
551  size_t blockIndex;
552  size_t nBlocks;
554  size_t leftBlocks;
556  size_t rightBlocks;
559  services::Status check() const DAAL_C11_OVERRIDE;
560 };
561 /* [Parameter source code] */
562 
567 class DAAL_EXPORT Input : public daal::algorithms::Input
568 {
569 public:
570  Input();
571  Input(const Input& other) : daal::algorithms::Input(other){}
572 
573  virtual ~Input() {}
574 
580  data_management::NumericTablePtr get(InputId id) const;
581 
587  void set(InputId id, const data_management::NumericTablePtr &ptr);
588 
594  services::Status check(const daal::algorithms::Parameter *par, int method) const DAAL_C11_OVERRIDE;
595 };
596 
601 class DAAL_EXPORT Result : public daal::algorithms::Result
602 {
603 public:
604  DECLARE_SERIALIZABLE_CAST(Result);
605  Result();
606 
607  virtual ~Result() {};
608 
615  template <typename algorithmFPType>
616  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
617 
623  data_management::NumericTablePtr get(ResultId id) const;
624 
630  void set(ResultId id, const data_management::NumericTablePtr &ptr);
631 
638  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *par, int method) const DAAL_C11_OVERRIDE;
639 
640 protected:
642  template<typename Archive, bool onDeserialize>
643  services::Status serialImpl(Archive *arch)
644  {
645  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
646  }
647 };
648 typedef services::SharedPtr<Result> ResultPtr;
649 
654 template<ComputeStep step>
655 class DistributedInput
656 {};
657 
663 template<>
664 class DAAL_EXPORT DistributedInput<step1Local> : public daal::algorithms::Input
665 {
666 public:
668  DistributedInput();
669 
671  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
672 
673  virtual ~DistributedInput() {}
674 
680  data_management::NumericTablePtr get(Step1LocalNumericTableInputId id) const;
681 
687  void set(Step1LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
688 
695  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
696 };
697 
703 class DAAL_EXPORT DistributedPartialResultStep1 : public daal::algorithms::PartialResult
704 {
705 public:
706  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep1);
708  DistributedPartialResultStep1();
709 
710  virtual ~DistributedPartialResultStep1() {}
711 
717  data_management::NumericTablePtr get(DistributedPartialResultStep1Id id) const;
718 
724  void set(DistributedPartialResultStep1Id id, const data_management::NumericTablePtr &ptr);
725 
732  template <typename algorithmFPType>
733  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
734 
741  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
742  int method) const DAAL_C11_OVERRIDE;
743 
744 protected:
746  template<typename Archive, bool onDeserialize>
747  services::Status serialImpl(Archive *arch)
748  {
749  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
750  }
751 };
752 typedef services::SharedPtr<DistributedPartialResultStep1> DistributedPartialResultStep1Ptr;
753 
759 template<>
760 class DAAL_EXPORT DistributedInput<step2Local> : public daal::algorithms::Input
761 {
762 public:
764  DistributedInput();
765 
767  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
768 
769  virtual ~DistributedInput() {}
770 
776  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
777 
783  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
784 
790  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
791 
798  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
799 };
800 
806 class DAAL_EXPORT DistributedPartialResultStep2 : public daal::algorithms::PartialResult
807 {
808 public:
809  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep2);
811  DistributedPartialResultStep2();
812 
813  virtual ~DistributedPartialResultStep2() {}
814 
820  data_management::NumericTablePtr get(DistributedPartialResultStep2Id id) const;
821 
827  void set(DistributedPartialResultStep2Id id, const data_management::NumericTablePtr &ptr);
828 
835  template <typename algorithmFPType>
836  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
837 
844  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
845  int method) const DAAL_C11_OVERRIDE;
846 
847 protected:
849  template<typename Archive, bool onDeserialize>
850  services::Status serialImpl(Archive *arch)
851  {
852  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
853  }
854 };
855 typedef services::SharedPtr<DistributedPartialResultStep2> DistributedPartialResultStep2Ptr;
856 
862 template<>
863 class DAAL_EXPORT DistributedInput<step3Local> : public daal::algorithms::Input
864 {
865 public:
867  DistributedInput();
868 
870  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
871 
872  virtual ~DistributedInput() {}
873 
879  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
880 
886  data_management::DataCollectionPtr get(Step3LocalCollectionInputId id) const;
887 
893  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
894 
900  void set(Step3LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
901 
907  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
908 
914  void add(Step3LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
915 
922  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
923 };
924 
930 class DAAL_EXPORT DistributedPartialResultStep3 : public daal::algorithms::PartialResult
931 {
932 public:
933  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep3);
935  DistributedPartialResultStep3();
936 
937  virtual ~DistributedPartialResultStep3() {}
938 
944  data_management::NumericTablePtr get(DistributedPartialResultStep3Id id) const;
945 
951  void set(DistributedPartialResultStep3Id id, const data_management::NumericTablePtr &ptr);
952 
959  template <typename algorithmFPType>
960  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
961 
968  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
969  int method) const DAAL_C11_OVERRIDE;
970 
971 protected:
973  template<typename Archive, bool onDeserialize>
974  services::Status serialImpl(Archive *arch)
975  {
976  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
977  }
978 };
979 typedef services::SharedPtr<DistributedPartialResultStep3> DistributedPartialResultStep3Ptr;
980 
986 template<>
987 class DAAL_EXPORT DistributedInput<step4Local> : public daal::algorithms::Input
988 {
989 public:
991  DistributedInput();
992 
994  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
995 
996  virtual ~DistributedInput() {}
997 
1003  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1004 
1010  data_management::DataCollectionPtr get(Step4LocalCollectionInputId id) const;
1011 
1017  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1018 
1024  void set(Step4LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1025 
1031  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1032 
1038  void add(Step4LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1039 
1046  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1047 };
1048 
1054 class DAAL_EXPORT DistributedPartialResultStep4 : public daal::algorithms::PartialResult
1055 {
1056 public:
1057  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep4);
1059  DistributedPartialResultStep4();
1060 
1061  virtual ~DistributedPartialResultStep4() {}
1062 
1068  data_management::DataCollectionPtr get(DistributedPartialResultStep4Id id) const;
1069 
1075  void set(DistributedPartialResultStep4Id id, const data_management::DataCollectionPtr &ptr);
1076 
1083  template <typename algorithmFPType>
1084  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1085 
1092  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1093  int method) const DAAL_C11_OVERRIDE;
1094 
1095 protected:
1097  template<typename Archive, bool onDeserialize>
1098  services::Status serialImpl(Archive *arch)
1099  {
1100  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1101  }
1102 };
1103 typedef services::SharedPtr<DistributedPartialResultStep4> DistributedPartialResultStep4Ptr;
1104 
1110 template<>
1111 class DAAL_EXPORT DistributedInput<step5Local> : public daal::algorithms::Input
1112 {
1113 public:
1115  DistributedInput();
1116 
1118  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1119 
1120  virtual ~DistributedInput() {}
1121 
1127  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1128 
1134  data_management::DataCollectionPtr get(Step5LocalCollectionInputId id) const;
1135 
1141  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1142 
1148  void set(Step5LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1149 
1155  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1156 
1162  void add(Step5LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1163 
1170  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1171 };
1172 
1178 class DAAL_EXPORT DistributedPartialResultStep5 : public daal::algorithms::PartialResult
1179 {
1180 public:
1181  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep5);
1183  DistributedPartialResultStep5();
1184 
1185  virtual ~DistributedPartialResultStep5() {}
1186 
1192  data_management::DataCollectionPtr get(DistributedPartialResultStep5Id id) const;
1193 
1199  void set(DistributedPartialResultStep5Id id, const data_management::DataCollectionPtr &ptr);
1200 
1207  template <typename algorithmFPType>
1208  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1209 
1216  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1217  int method) const DAAL_C11_OVERRIDE;
1218 
1219 protected:
1221  template<typename Archive, bool onDeserialize>
1222  services::Status serialImpl(Archive *arch)
1223  {
1224  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1225  }
1226 };
1227 typedef services::SharedPtr<DistributedPartialResultStep5> DistributedPartialResultStep5Ptr;
1228 
1234 template<>
1235 class DAAL_EXPORT DistributedInput<step6Local> : public daal::algorithms::Input
1236 {
1237 public:
1239  DistributedInput();
1240 
1242  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1243 
1244  virtual ~DistributedInput() {}
1245 
1251  data_management::DataCollectionPtr get(LocalCollectionInputId id) const;
1252 
1258  data_management::DataCollectionPtr get(Step6LocalCollectionInputId id) const;
1259 
1265  void set(LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1266 
1272  void set(Step6LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1273 
1279  void add(LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1280 
1286  void add(Step6LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1287 
1294  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1295 };
1296 
1302 class DAAL_EXPORT DistributedPartialResultStep6 : public daal::algorithms::PartialResult
1303 {
1304 public:
1305  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep6);
1307  DistributedPartialResultStep6();
1308 
1309  virtual ~DistributedPartialResultStep6() {}
1310 
1316  data_management::NumericTablePtr get(DistributedPartialResultStep6NumericTableId id) const;
1317 
1323  data_management::DataCollectionPtr get(DistributedPartialResultStep6CollectionId id) const;
1324 
1330  void set(DistributedPartialResultStep6NumericTableId id, const data_management::NumericTablePtr &ptr);
1331 
1337  void set(DistributedPartialResultStep6CollectionId id, const data_management::DataCollectionPtr &ptr);
1338 
1345  template <typename algorithmFPType>
1346  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1347 
1354  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1355  int method) const DAAL_C11_OVERRIDE;
1356 
1357 protected:
1359  template<typename Archive, bool onDeserialize>
1360  services::Status serialImpl(Archive *arch)
1361  {
1362  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1363  }
1364 };
1365 typedef services::SharedPtr<DistributedPartialResultStep6> DistributedPartialResultStep6Ptr;
1366 
1372 template<>
1373 class DAAL_EXPORT DistributedInput<step7Master> : public daal::algorithms::Input
1374 {
1375 public:
1377  DistributedInput();
1378 
1380  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1381 
1382  virtual ~DistributedInput() {}
1383 
1389  data_management::DataCollectionPtr get(Step7MasterCollectionInputId id) const;
1390 
1396  void set(Step7MasterCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1397 
1403  void add(Step7MasterCollectionInputId id, const data_management::NumericTablePtr &ptr);
1404 
1411  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1412 };
1413 
1419 class DAAL_EXPORT DistributedPartialResultStep7 : public daal::algorithms::PartialResult
1420 {
1421 public:
1422  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep7);
1424  DistributedPartialResultStep7();
1425 
1426  virtual ~DistributedPartialResultStep7() {}
1427 
1433  data_management::NumericTablePtr get(DistributedPartialResultStep7Id id) const;
1434 
1440  void set(DistributedPartialResultStep7Id id, const data_management::NumericTablePtr &ptr);
1441 
1448  template <typename algorithmFPType>
1449  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1450 
1457  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1458  int method) const DAAL_C11_OVERRIDE;
1459 
1460 protected:
1462  template<typename Archive, bool onDeserialize>
1463  services::Status serialImpl(Archive *arch)
1464  {
1465  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1466  }
1467 };
1468 typedef services::SharedPtr<DistributedPartialResultStep7> DistributedPartialResultStep7Ptr;
1469 
1475 template<>
1476 class DAAL_EXPORT DistributedInput<step8Local> : public daal::algorithms::Input
1477 {
1478 public:
1480  DistributedInput();
1481 
1483  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1484 
1485  virtual ~DistributedInput() {}
1486 
1492  data_management::NumericTablePtr get(Step8LocalNumericTableInputId id) const;
1493 
1499  data_management::DataCollectionPtr get(Step8LocalCollectionInputId id) const;
1500 
1506  void set(Step8LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1507 
1513  void set(Step8LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1514 
1520  void add(Step8LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1521 
1528  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1529 };
1530 
1536 class DAAL_EXPORT DistributedPartialResultStep8 : public daal::algorithms::PartialResult
1537 {
1538 public:
1539  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep8);
1541  DistributedPartialResultStep8();
1542 
1543  virtual ~DistributedPartialResultStep8() {}
1544 
1550  data_management::NumericTablePtr get(DistributedPartialResultStep8NumericTableId id) const;
1551 
1557  data_management::DataCollectionPtr get(DistributedPartialResultStep8CollectionId id) const;
1558 
1564  void set(DistributedPartialResultStep8NumericTableId id, const data_management::NumericTablePtr &ptr);
1565 
1571  void set(DistributedPartialResultStep8CollectionId id, const data_management::DataCollectionPtr &ptr);
1572 
1579  template <typename algorithmFPType>
1580  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1581 
1588  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1589  int method) const DAAL_C11_OVERRIDE;
1590 
1591 protected:
1593  template<typename Archive, bool onDeserialize>
1594  services::Status serialImpl(Archive *arch)
1595  {
1596  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1597  }
1598 };
1599 typedef services::SharedPtr<DistributedPartialResultStep8> DistributedPartialResultStep8Ptr;
1600 
1606 template<>
1607 class DAAL_EXPORT DistributedInput<step9Master> : public daal::algorithms::Input
1608 {
1609 public:
1611  DistributedInput();
1612 
1614  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1615 
1616  virtual ~DistributedInput() {}
1617 
1623  data_management::DataCollectionPtr get(Step9MasterCollectionInputId id) const;
1624 
1630  void set(Step9MasterCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1631 
1637  void add(Step9MasterCollectionInputId id, const data_management::NumericTablePtr &ptr);
1638 
1645  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1646 };
1647 
1653 class DAAL_EXPORT DistributedResultStep9 : public daal::algorithms::Result
1654 {
1655 public:
1656  DECLARE_SERIALIZABLE_CAST(DistributedResultStep9);
1658  DistributedResultStep9();
1659 
1660  virtual ~DistributedResultStep9() {}
1661 
1667  data_management::NumericTablePtr get(DistributedResultStep9Id id) const;
1668 
1674  void set(DistributedResultStep9Id id, const data_management::NumericTablePtr &ptr);
1675 
1682  template <typename algorithmFPType>
1683  DAAL_EXPORT services::Status allocate(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, const int method);
1684 
1691  services::Status check(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1692 
1693 protected:
1695  template<typename Archive, bool onDeserialize>
1696  services::Status serialImpl(Archive *arch)
1697  {
1698  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
1699  }
1700 };
1701 typedef services::SharedPtr<DistributedResultStep9> DistributedResultStep9Ptr;
1702 
1708 class DAAL_EXPORT DistributedPartialResultStep9 : public daal::algorithms::PartialResult
1709 {
1710 public:
1711  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep9);
1713  DistributedPartialResultStep9();
1714 
1715  virtual ~DistributedPartialResultStep9() {}
1716 
1722  data_management::DataCollectionPtr get(DistributedPartialResultStep9Id id) const;
1723 
1729  void set(DistributedPartialResultStep9Id id, const data_management::DataCollectionPtr &ptr);
1730 
1737  template <typename algorithmFPType>
1738  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1739 
1746  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1747  int method) const DAAL_C11_OVERRIDE;
1748 
1749 protected:
1751  template<typename Archive, bool onDeserialize>
1752  services::Status serialImpl(Archive *arch)
1753  {
1754  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1755  }
1756 };
1757 typedef services::SharedPtr<DistributedPartialResultStep9> DistributedPartialResultStep9Ptr;
1758 
1764 template<>
1765 class DAAL_EXPORT DistributedInput<step10Local> : public daal::algorithms::Input
1766 {
1767 public:
1769  DistributedInput();
1770 
1772  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1773 
1774  virtual ~DistributedInput() {}
1775 
1781  data_management::NumericTablePtr get(Step10LocalNumericTableInputId id) const;
1782 
1788  void set(Step10LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1789 
1796  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1797 };
1798 
1804 class DAAL_EXPORT DistributedPartialResultStep10 : public daal::algorithms::PartialResult
1805 {
1806 public:
1807  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep10);
1809  DistributedPartialResultStep10();
1810 
1811  virtual ~DistributedPartialResultStep10() {}
1812 
1818  data_management::NumericTablePtr get(DistributedPartialResultStep10NumericTableId id) const;
1819 
1825  data_management::DataCollectionPtr get(DistributedPartialResultStep10CollectionId id) const;
1826 
1832  void set(DistributedPartialResultStep10NumericTableId id, const data_management::NumericTablePtr &ptr);
1833 
1839  void set(DistributedPartialResultStep10CollectionId id, const data_management::DataCollectionPtr &ptr);
1840 
1847  template <typename algorithmFPType>
1848  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1849 
1856  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1857  int method) const DAAL_C11_OVERRIDE;
1858 
1859 protected:
1861  template<typename Archive, bool onDeserialize>
1862  services::Status serialImpl(Archive *arch)
1863  {
1864  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1865  }
1866 };
1867 typedef services::SharedPtr<DistributedPartialResultStep10> DistributedPartialResultStep10Ptr;
1868 
1874 template<>
1875 class DAAL_EXPORT DistributedInput<step11Local> : public daal::algorithms::Input
1876 {
1877 public:
1879  DistributedInput();
1880 
1882  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
1883 
1884  virtual ~DistributedInput() {}
1885 
1891  data_management::NumericTablePtr get(Step11LocalNumericTableInputId id) const;
1892 
1898  data_management::DataCollectionPtr get(Step11LocalCollectionInputId id) const;
1899 
1905  void set(Step11LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
1906 
1912  void set(Step11LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
1913 
1919  void add(Step11LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
1920 
1927  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
1928 };
1929 
1935 class DAAL_EXPORT DistributedPartialResultStep11 : public daal::algorithms::PartialResult
1936 {
1937 public:
1938  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep11);
1940  DistributedPartialResultStep11();
1941 
1942  virtual ~DistributedPartialResultStep11() {}
1943 
1949  data_management::NumericTablePtr get(DistributedPartialResultStep11NumericTableId id) const;
1950 
1956  data_management::DataCollectionPtr get(DistributedPartialResultStep11CollectionId id) const;
1957 
1963  void set(DistributedPartialResultStep11NumericTableId id, const data_management::NumericTablePtr &ptr);
1964 
1970  void set(DistributedPartialResultStep11CollectionId id, const data_management::DataCollectionPtr &ptr);
1971 
1978  template <typename algorithmFPType>
1979  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
1980 
1987  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
1988  int method) const DAAL_C11_OVERRIDE;
1989 
1990 protected:
1992  template<typename Archive, bool onDeserialize>
1993  services::Status serialImpl(Archive *arch)
1994  {
1995  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
1996  }
1997 };
1998 typedef services::SharedPtr<DistributedPartialResultStep11> DistributedPartialResultStep11Ptr;
1999 
2005 template<>
2006 class DAAL_EXPORT DistributedInput<step12Local> : public daal::algorithms::Input
2007 {
2008 public:
2010  DistributedInput();
2011 
2013  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
2014 
2015  virtual ~DistributedInput() {}
2016 
2022  data_management::NumericTablePtr get(Step12LocalNumericTableInputId id) const;
2023 
2029  data_management::DataCollectionPtr get(Step12LocalCollectionInputId id) const;
2030 
2036  void set(Step12LocalNumericTableInputId id, const data_management::NumericTablePtr &ptr);
2037 
2043  void set(Step12LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
2044 
2050  void add(Step12LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
2051 
2058  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2059 };
2060 
2066 class DAAL_EXPORT DistributedPartialResultStep12 : public daal::algorithms::PartialResult
2067 {
2068 public:
2069  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep12);
2071  DistributedPartialResultStep12();
2072 
2073  virtual ~DistributedPartialResultStep12() {}
2074 
2080  data_management::DataCollectionPtr get(DistributedPartialResultStep12Id id) const;
2081 
2087  void set(DistributedPartialResultStep12Id id, const data_management::DataCollectionPtr &ptr);
2088 
2095  template <typename algorithmFPType>
2096  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
2097 
2104  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
2105  int method) const DAAL_C11_OVERRIDE;
2106 
2107 protected:
2109  template<typename Archive, bool onDeserialize>
2110  services::Status serialImpl(Archive *arch)
2111  {
2112  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
2113  }
2114 };
2115 typedef services::SharedPtr<DistributedPartialResultStep12> DistributedPartialResultStep12Ptr;
2116 
2122 template<>
2123 class DAAL_EXPORT DistributedInput<step13Local> : public daal::algorithms::Input
2124 {
2125 public:
2127  DistributedInput();
2128 
2130  DistributedInput(const DistributedInput& other) : daal::algorithms::Input(other){}
2131 
2132  virtual ~DistributedInput() {}
2133 
2139  data_management::DataCollectionPtr get(Step13LocalCollectionInputId id) const;
2140 
2146  void set(Step13LocalCollectionInputId id, const data_management::DataCollectionPtr &ptr);
2147 
2153  void add(Step13LocalCollectionInputId id, const data_management::NumericTablePtr &ptr);
2154 
2161  services::Status check(const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2162 };
2163 
2169 class DAAL_EXPORT DistributedResultStep13 : public daal::algorithms::Result
2170 {
2171 public:
2172  DECLARE_SERIALIZABLE_CAST(DistributedResultStep13);
2174  DistributedResultStep13();
2175 
2176  virtual ~DistributedResultStep13() {}
2177 
2183  data_management::NumericTablePtr get(DistributedResultStep13Id id) const;
2184 
2190  void set(DistributedResultStep13Id id, const data_management::NumericTablePtr &ptr);
2191 
2198  template <typename algorithmFPType>
2199  DAAL_EXPORT services::Status allocate(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, const int method);
2200 
2207  services::Status check(const daal::algorithms::PartialResult *pres, const daal::algorithms::Parameter *parameter, int method) const DAAL_C11_OVERRIDE;
2208 
2209 protected:
2211  template<typename Archive, bool onDeserialize>
2212  services::Status serialImpl(Archive *arch)
2213  {
2214  return daal::algorithms::Result::serialImpl<Archive, onDeserialize>(arch);
2215  }
2216 };
2217 typedef services::SharedPtr<DistributedResultStep13> DistributedResultStep13Ptr;
2218 
2224 class DAAL_EXPORT DistributedPartialResultStep13 : public daal::algorithms::PartialResult
2225 {
2226 public:
2227  DECLARE_SERIALIZABLE_CAST(DistributedPartialResultStep13);
2229  DistributedPartialResultStep13();
2230 
2231  virtual ~DistributedPartialResultStep13() {}
2232 
2238  data_management::NumericTablePtr get(DistributedPartialResultStep13Id id) const;
2239 
2245  void set(DistributedPartialResultStep13Id id, const data_management::NumericTablePtr &ptr);
2246 
2253  template <typename algorithmFPType>
2254  DAAL_EXPORT services::Status allocate(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter, const int method);
2255 
2262  services::Status check(const daal::algorithms::Input *input, const daal::algorithms::Parameter *parameter,
2263  int method) const DAAL_C11_OVERRIDE;
2264 
2265 protected:
2267  template<typename Archive, bool onDeserialize>
2268  services::Status serialImpl(Archive *arch)
2269  {
2270  return daal::algorithms::PartialResult::serialImpl<Archive, onDeserialize>(arch);
2271  }
2272 };
2273 typedef services::SharedPtr<DistributedPartialResultStep13> DistributedPartialResultStep13Ptr;
2274 
2275 } // namespace interface1
2276 
2277 using interface1::Parameter;
2278 using interface1::Input;
2279 using interface1::Result;
2280 using interface1::ResultPtr;
2281 
2282 using interface1::DistributedInput;
2283 using interface1::DistributedPartialResultStep1;
2284 using interface1::DistributedPartialResultStep1Ptr;
2285 using interface1::DistributedPartialResultStep2;
2286 using interface1::DistributedPartialResultStep2Ptr;
2287 using interface1::DistributedPartialResultStep3;
2288 using interface1::DistributedPartialResultStep3Ptr;
2289 using interface1::DistributedPartialResultStep4;
2290 using interface1::DistributedPartialResultStep4Ptr;
2291 using interface1::DistributedPartialResultStep5;
2292 using interface1::DistributedPartialResultStep5Ptr;
2293 using interface1::DistributedPartialResultStep6;
2294 using interface1::DistributedPartialResultStep6Ptr;
2295 using interface1::DistributedPartialResultStep7;
2296 using interface1::DistributedPartialResultStep7Ptr;
2297 using interface1::DistributedPartialResultStep8;
2298 using interface1::DistributedPartialResultStep8Ptr;
2299 using interface1::DistributedResultStep9;
2300 using interface1::DistributedResultStep9Ptr;
2301 using interface1::DistributedPartialResultStep9;
2302 using interface1::DistributedPartialResultStep9Ptr;
2303 using interface1::DistributedPartialResultStep10;
2304 using interface1::DistributedPartialResultStep10Ptr;
2305 using interface1::DistributedPartialResultStep11;
2306 using interface1::DistributedPartialResultStep11Ptr;
2307 using interface1::DistributedPartialResultStep12;
2308 using interface1::DistributedPartialResultStep12Ptr;
2309 using interface1::DistributedResultStep13;
2310 using interface1::DistributedResultStep13Ptr;
2311 using interface1::DistributedPartialResultStep13;
2312 using interface1::DistributedPartialResultStep13Ptr;
2313 
2314 } // namespace daal::algorithms::dbscan
2316 } // namespace daal::algorithms
2317 } // namespace daal
2318 #endif
daal::algorithms::dbscan::step10InputClusterStructure
Definition: dbscan_types.h:372
daal::algorithms::dbscan::partitionedHaloDataIndices
Definition: dbscan_types.h:219
daal::algorithms::dbscan::Step8LocalNumericTableInputId
Step8LocalNumericTableInputId
Definition: dbscan_types.h:290
daal::step1Local
Definition: daal_defines.h:123
daal::algorithms::dbscan::clusterOffsets
Definition: dbscan_types.h:361
daal::algorithms::dbscan::interface1::Parameter
Parameters for the DBSCAN algorithm.
Definition: dbscan_types.h:526
daal::algorithms::dbscan::DistributedResultStep13Id
DistributedResultStep13Id
Definition: dbscan_types.h:495
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:2066
daal::algorithms::dbscan::step8PartialQueries
Definition: dbscan_types.h:304
daal::algorithms::dbscan::haloWeights
Definition: dbscan_types.h:233
daal::algorithms::dbscan::coreIndices
Definition: dbscan_types.h:97
daal::algorithms::dbscan::computeCoreObservations
Definition: dbscan_types.h:86
daal::algorithms::dbscan::DistributedPartialResultStep8CollectionId
DistributedPartialResultStep8CollectionId
Definition: dbscan_types.h:326
daal::algorithms::dbscan::step6FinishedFlag
Definition: dbscan_types.h:246
daal::algorithms::dbscan::step13Assignments
Definition: dbscan_types.h:497
daal::algorithms::dbscan::DistributedPartialResultStep4Id
DistributedPartialResultStep4Id
Definition: dbscan_types.h:191
daal::algorithms::dbscan::ResultToComputeId
ResultToComputeId
Definition: dbscan_types.h:83
daal::algorithms::dbscan::DistributedPartialResultStep7Id
DistributedPartialResultStep7Id
Definition: dbscan_types.h:279
daal::algorithms::dbscan::step8Queries
Definition: dbscan_types.h:328
daal::algorithms::dbscan::interface1::Parameter::nBlocks
size_t nBlocks
Definition: dbscan_types.h:552
daal::step12Local
Definition: daal_defines.h:139
daal::algorithms::dbscan::DistributedPartialResultStep6NumericTableId
DistributedPartialResultStep6NumericTableId
Definition: dbscan_types.h:243
daal::algorithms::dbscan::step6Queries
Definition: dbscan_types.h:258
daal::algorithms::dbscan::step3PartialBoundingBoxes
Definition: dbscan_types.h:156
daal::algorithms::dbscan::partialFinishedFlags
Definition: dbscan_types.h:269
daal::algorithms::dbscan::interface1::Parameter::memorySavingMode
bool memorySavingMode
Definition: dbscan_types.h:548
daal::algorithms::dbscan::interface1::Parameter::epsilon
double epsilon
Definition: dbscan_types.h:546
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:1653
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:1708
daal::algorithms::dbscan::data
Definition: dbscan_types.h:74
daal::algorithms::dbscan::interface1::DistributedInput< step8Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1483
daal::algorithms::dbscan::DistributedPartialResultStep9Id
DistributedPartialResultStep9Id
Definition: dbscan_types.h:359
daal::algorithms::dbscan::Step12LocalNumericTableInputId
Step12LocalNumericTableInputId
Definition: dbscan_types.h:450
daal::algorithms::dbscan::partialWeights
Definition: dbscan_types.h:109
daal::algorithms::dbscan::DistributedPartialResultStep10NumericTableId
DistributedPartialResultStep10NumericTableId
Definition: dbscan_types.h:382
daal::algorithms::dbscan::DistributedPartialResultStep8NumericTableId
DistributedPartialResultStep8NumericTableId
Definition: dbscan_types.h:313
daal::step11Local
Definition: daal_defines.h:138
daal::algorithms::dbscan::interface1::DistributedInput< step2Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:767
daal::algorithms::dbscan::computeCoreIndices
Definition: dbscan_types.h:85
daal::algorithms::dbscan::interface1::DistributedInput< step10Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1772
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:1419
daal::algorithms::dbscan::step13AssignmentQueries
Definition: dbscan_types.h:508
daal::algorithms::dbscan::partialOrder
Definition: dbscan_types.h:131
daal::algorithms::dbscan::DistributedPartialResultStep3Id
DistributedPartialResultStep3Id
Definition: dbscan_types.h:165
daal::algorithms::dbscan::partialAssignmentQueries
Definition: dbscan_types.h:486
daal::algorithms::dbscan::step11PartialQueries
Definition: dbscan_types.h:418
daal::algorithms::dbscan::haloData
Definition: dbscan_types.h:231
daal::step13Local
Definition: daal_defines.h:140
daal::algorithms::dbscan::step12InputClusterStructure
Definition: dbscan_types.h:452
daal::algorithms::dbscan::interface1::DistributedInput< step12Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:2013
daal::algorithms::dbscan::partitionedPartialOrders
Definition: dbscan_types.h:195
daal::step3Local
Definition: daal_defines.h:125
daal::algorithms::dbscan::interface1::DistributedInput< step9Master >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1614
daal::algorithms::dbscan::step8ClusterStructure
Definition: dbscan_types.h:315
daal::algorithms::dbscan::partitionedWeights
Definition: dbscan_types.h:194
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:1804
daal::algorithms::dbscan::Step3LocalCollectionInputId
Step3LocalCollectionInputId
Definition: dbscan_types.h:154
daal::step8Local
Definition: daal_defines.h:135
daal::algorithms::dbscan::finishedFlag
Definition: dbscan_types.h:281
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:1178
daal::step7Master
Definition: daal_defines.h:134
daal::algorithms::dbscan::DistanceType
DistanceType
Definition: dbscan_types.h:62
daal::algorithms::dbscan::Step10LocalNumericTableInputId
Step10LocalNumericTableInputId
Definition: dbscan_types.h:370
daal::algorithms::dbscan::interface1::DistributedInput< step11Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1882
daal::algorithms::dbscan::step11InputClusterStructure
Definition: dbscan_types.h:407
daal::algorithms::dbscan::DistributedPartialResultStep12Id
DistributedPartialResultStep12Id
Definition: dbscan_types.h:473
daal::algorithms::dbscan::step9NClusters
Definition: dbscan_types.h:350
daal::step9Master
Definition: daal_defines.h:136
daal::algorithms::dbscan::DistributedPartialResultStep6CollectionId
DistributedPartialResultStep6CollectionId
Definition: dbscan_types.h:256
daal::algorithms::dbscan::Step1LocalNumericTableInputId
Step1LocalNumericTableInputId
Definition: dbscan_types.h:118
daal::algorithms::dbscan::step10ClusterOffset
Definition: dbscan_types.h:373
daal_defines.h
daal::algorithms::dbscan::assignmentQueries
Definition: dbscan_types.h:475
daal::algorithms::dbscan::interface1::DistributedInput< step13Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:2130
daal::algorithms::dbscan::step8InputClusterStructure
Definition: dbscan_types.h:292
daal::step4Local
Definition: daal_defines.h:126
daal::algorithms::dbscan::interface1::Input
Input objects for the DBSCAN algorithm
Definition: dbscan_types.h:567
daal::algorithms::dbscan::DistributedResultStep9Id
DistributedResultStep9Id
Definition: dbscan_types.h:348
daal::algorithms::dbscan::Step13LocalCollectionInputId
Step13LocalCollectionInputId
Definition: dbscan_types.h:484
daal::algorithms::dbscan::step4PartialOrders
Definition: dbscan_types.h:181
daal::algorithms::dbscan::assignments
Definition: dbscan_types.h:95
daal::algorithms::dbscan::DistributedPartialResultStep5Id
DistributedPartialResultStep5Id
Definition: dbscan_types.h:216
daal::algorithms::dbscan::partialData
Definition: dbscan_types.h:108
daal::algorithms::dbscan::split
Definition: dbscan_types.h:167
daal::algorithms::dbscan::defaultDense
Definition: dbscan_types.h:55
daal::algorithms::dbscan::step1Data
Definition: dbscan_types.h:120
daal::algorithms::dbscan::DistributedPartialResultStep11NumericTableId
DistributedPartialResultStep11NumericTableId
Definition: dbscan_types.h:427
daal::algorithms::dbscan::Step12LocalCollectionInputId
Step12LocalCollectionInputId
Definition: dbscan_types.h:461
daal::algorithms::dbscan::interface1::DistributedInput< step3Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:870
daal::algorithms::dbscan::interface1::Parameter::leftBlocks
size_t leftBlocks
Definition: dbscan_types.h:554
daal::algorithms::dbscan::DistributedPartialResultStep1Id
DistributedPartialResultStep1Id
Definition: dbscan_types.h:129
daal::algorithms::dbscan::Step9MasterCollectionInputId
Step9MasterCollectionInputId
Definition: dbscan_types.h:337
daal::algorithms::dbscan::partitionedHaloData
Definition: dbscan_types.h:218
daal::algorithms::dbscan::boundingBox
Definition: dbscan_types.h:143
daal::algorithms::dbscan::Step11LocalCollectionInputId
Step11LocalCollectionInputId
Definition: dbscan_types.h:416
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:2224
daal::algorithms::dbscan::interface1::DistributedInput< step6Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1242
daal::algorithms::dbscan::partialNClusters
Definition: dbscan_types.h:339
daal::algorithms::dbscan::Step7MasterCollectionInputId
Step7MasterCollectionInputId
Definition: dbscan_types.h:267
daal::algorithms::dbscan::interface1::Parameter::minObservations
size_t minObservations
Definition: dbscan_types.h:547
daal::algorithms::dbscan::DistributedPartialResultStep13Id
DistributedPartialResultStep13Id
Definition: dbscan_types.h:506
daal::algorithms::dbscan::weights
Definition: dbscan_types.h:75
daal::algorithms::dbscan::interface1::DistributedInput< step4Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:994
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:2169
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:1536
daal::algorithms::dbscan::interface1::Parameter::resultsToCompute
DAAL_UINT64 resultsToCompute
Definition: dbscan_types.h:549
daal::algorithms::dbscan::euclidean
Definition: dbscan_types.h:64
daal::algorithms::dbscan::DistributedPartialResultStep10CollectionId
DistributedPartialResultStep10CollectionId
Definition: dbscan_types.h:394
daal::algorithms::dbscan::step5PartialBoundingBoxes
Definition: dbscan_types.h:207
daal::algorithms::dbscan::ResultId
ResultId
Available identifiers of results of the DBSCAN algorithm.
Definition: dbscan_types.h:93
daal::algorithms::dbscan::interface1::DistributedInput< step5Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1118
daal::algorithms::dbscan::interface1::Result
Results obtained with the compute() method of the DBSCAN algorithm in the batch processing mode...
Definition: dbscan_types.h:601
daal::algorithms::dbscan::DistributedPartialResultStep2Id
DistributedPartialResultStep2Id
Definition: dbscan_types.h:141
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:1054
daal::step5Local
Definition: daal_defines.h:132
daal::algorithms::dbscan::step12PartialOrders
Definition: dbscan_types.h:463
daal::algorithms::dbscan::DistributedPartialResultStep11CollectionId
DistributedPartialResultStep11CollectionId
Definition: dbscan_types.h:439
daal::algorithms::dbscan::Step6LocalCollectionInputId
Step6LocalCollectionInputId
Definition: dbscan_types.h:229
daal::algorithms::dbscan::interface1::DistributedInput< step7Master >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:1380
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:1302
daal::algorithms::dbscan::step8NClusters
Definition: dbscan_types.h:317
daal::algorithms::dbscan::haloDataIndices
Definition: dbscan_types.h:232
daal::algorithms::dbscan::partitionedHaloWeights
Definition: dbscan_types.h:220
daal::algorithms::dbscan::step11FinishedFlag
Definition: dbscan_types.h:430
daal::algorithms::dbscan::interface1::Parameter::rightBlocks
size_t rightBlocks
Definition: dbscan_types.h:556
daal::algorithms::dbscan::interface1::DistributedInput
Input objects for the DBSCAN algorithm in the distributed processing mode
Definition: dbscan_types.h:655
daal::algorithms::dbscan::Method
Method
Definition: dbscan_types.h:53
daal::algorithms::dbscan::nClusters
Definition: dbscan_types.h:96
daal::algorithms::dbscan::step6NClusters
Definition: dbscan_types.h:247
daal::step10Local
Definition: daal_defines.h:137
daal::algorithms::dbscan::Step4LocalCollectionInputId
Step4LocalCollectionInputId
Definition: dbscan_types.h:177
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:930
daal::algorithms::dbscan::step10Queries
Definition: dbscan_types.h:396
daal::algorithms::dbscan::Step8LocalCollectionInputId
Step8LocalCollectionInputId
Definition: dbscan_types.h:302
daal::algorithms::dbscan::interface1::Parameter::blockIndex
size_t blockIndex
Definition: dbscan_types.h:551
daal::algorithms::dbscan::coreObservations
Definition: dbscan_types.h:98
daal::step6Local
Definition: daal_defines.h:133
daal::algorithms::dbscan::InputId
InputId
Available identifiers of input objects for the DBSCAN algorithm.
Definition: dbscan_types.h:72
daal::algorithms::dbscan::step4PartialSplits
Definition: dbscan_types.h:179
daal::algorithms::dbscan::step8FinishedFlag
Definition: dbscan_types.h:316
daal::algorithms::dbscan::step8InputNClusters
Definition: dbscan_types.h:293
daal::algorithms::dbscan::Step11LocalNumericTableInputId
Step11LocalNumericTableInputId
Definition: dbscan_types.h:405
daal::algorithms::dbscan::step10ClusterStructure
Definition: dbscan_types.h:384
daal::algorithms::dbscan::step11ClusterStructure
Definition: dbscan_types.h:429
daal::algorithms::dbscan::LocalCollectionInputId
LocalCollectionInputId
Definition: dbscan_types.h:106
daal::algorithms::dbscan::interface1::DistributedInput< step1Local >::DistributedInput
DistributedInput(const DistributedInput &other)
Definition: dbscan_types.h:671
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:1935
daal::algorithms::dbscan::step10FinishedFlag
Definition: dbscan_types.h:385
daal::algorithms::dbscan::partitionedData
Definition: dbscan_types.h:193
daal::algorithms::dbscan::step11Queries
Definition: dbscan_types.h:441
daal::step2Local
Definition: daal_defines.h:128
daal::algorithms::dbscan::step6ClusterStructure
Definition: dbscan_types.h:245
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:806
daal::algorithms::dbscan::haloBlocks
Definition: dbscan_types.h:234
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:703
daal::algorithms::dbscan::Step5LocalCollectionInputId
Step5LocalCollectionInputId
Definition: dbscan_types.h:205

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