[maintenance] make spelling corrections

MAINTAINERS.md

@@ -98,14 +98,14 @@ Responsibilities:
   * Follow and enforce the project [contributing guidelines](CONTRIBUTING.md)
   * Co-own with other component Maintainers on the technical direction of a specific component.
   * Co-own with other Maintainers on the project as a whole, including determining strategy and policy for the project.
-  * Suppport and guide Contributors and Code Owners.
+  * Support and guide Contributors and Code Owners.
 
 Requirements:
   * Experience as a Code Owner for at least 12 months.
   * Track record of major project contributions to a specific project component.
   * Demonstrated deep knowledge of a specific project component.
   * Demonstrated broad knowledge of the project across multiple areas.
-  * Commits to using priviledges responsibly for the good of the project.
+  * Commits to using privileges responsibly for the good of the project.
   * Is able to exercise judgment for the good of the project, independent of
     their employer, friends, or team.
 

README.md

@@ -120,7 +120,7 @@ You can contribute to this project and also contribute to the specification for
 
 ## Support
 
-Ask questions and engage in discussions with oneDAL developers, contributers, and other users through the following channels:
+Ask questions and engage in discussions with oneDAL developers, contributors, and other users through the following channels:
 
 - [GitHub Discussions](https://github.com/uxlfoundation/oneDAL/discussions)
 - [Community Forum](https://community.intel.com/t5/Intel-oneAPI-Data-Analytics/bd-p/oneapi-data-analytics-library)

cpp/daal/src/algorithms/assocrules/assoc_rules_apriori_kernel.h

@@ -76,7 +76,7 @@ class AssociationRulesKernel<apriori, algorithmFPType, cpu> : public Kernel
                               hash_tree<cpu> * C_tree, services::Status & s);
 
     /** Test that all {n-1}-item subsets of {n}-item set are "large" item sets */
-    bool pruneCandidate(size_t iset_size, const size_t * cadidate, size_t * subset, hash_tree<cpu> & C_tree);
+    bool pruneCandidate(size_t iset_size, const size_t * candidate, size_t * subset, hash_tree<cpu> & C_tree);
 
     size_t binarySearch(size_t nUniqueItems, assocRulesUniqueItem<cpu> * uniqueItems, size_t itemID);
 

cpp/daal/src/algorithms/cordistance/cordistance_batch_container.h

@@ -34,7 +34,7 @@ namespace algorithms
 namespace correlation_distance
 {
 /**
- *  \brief Initialize list of correlation distance, double precission
+ *  \brief Initialize list of correlation distance, double precision
  *  kernels with implementations for supported architectures
  */
 template <typename algorithmFPType, Method method, CpuType cpu>

cpp/daal/src/algorithms/cosdistance/cosdistance_batch_container.h

@@ -34,7 +34,7 @@ namespace algorithms
 namespace cosine_distance
 {
 /**
- *  \brief Initialize list of correlation distance, double precission
+ *  \brief Initialize list of correlation distance, double precision
  *  kernels with implementations for supported architectures
  */
 template <typename algorithmFPType, Method method, CpuType cpu>

cpp/daal/src/algorithms/dtrees/dtrees_train_data_helper.i

@@ -150,7 +150,7 @@ struct SResponse
 //////////////////////////////////////////////////////////////////////////////////////////
 // DataHelper. Base class for response-specific services classes.
 // Keeps indices of the bootstrap samples and provides optimal access to columns in case
-// of homogenious numeric table
+// of homogeneous numeric table
 //////////////////////////////////////////////////////////////////////////////////////////
 template <typename algorithmFPType, CpuType cpu>
 class DataHelperBase
@@ -194,7 +194,7 @@ protected:
 //////////////////////////////////////////////////////////////////////////////////////////
 // DataHelper. Base class for response-specific services classes.
 // Keeps indices of the bootstrap samples and provides optimal access to columns in case
-// of homogenious numeric table
+// of homogeneous numeric table
 //////////////////////////////////////////////////////////////////////////////////////////
 template <typename algorithmFPType, typename TResponse, CpuType cpu>
 class DataHelper : public DataHelperBase<algorithmFPType, cpu>

cpp/daal/src/algorithms/dtrees/forest/classification/df_classification_train_dense_default_impl.i

@@ -119,7 +119,7 @@ protected: //enables specific functions for UnorderedRespHelperBest
         imp.hist[iClass] -= moveWeights;
     }
 
-    // Calculate impurity for left and right childs
+    // Calculate impurity for left and right children
     static void updateImpurity(ImpurityData & left, ImpurityData & right, ClassIndexType iClass, intermSummFPType totalWeights,
                                intermSummFPType startWeights, intermSummFPType & moveWeights)
     {

cpp/daal/src/algorithms/dtrees/gbt/classification/gbt_classification_predict_dense_default_batch_impl.i

@@ -268,7 +268,7 @@ protected:
      * \param hasUnorderedFeatures Data has unordered features yes/no
      * \param hasAnyMissing Data has missing values yes/no
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param vectorBlockSize Vector instruction block size
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
@@ -287,7 +287,7 @@ protected:
      *
      * \param hasAnyMissing Data has missing values yes/no
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param vectorBlockSize Vector instruction block size
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
@@ -305,7 +305,7 @@ protected:
      * \brief Traverse a number of trees to get prediction results
      *
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param vectorBlockSize Vector instruction block size
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
@@ -323,7 +323,7 @@ protected:
      * \brief Traverse a number of trees to get prediction results
      *
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param vectorBlockSizeFactor Vector instruction block size - recursively decremented until it becomes equal to dim.vectorBlockSizeFactor or equal to DimType::minVectorBlockSizeFactor
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
@@ -341,7 +341,7 @@ protected:
      * \brief Traverse a number of trees to get prediction results
      *
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param vectorBlockSizeFactor Vector instruction block size - recursively decremented until it becomes equal to dim.vectorBlockSizeFactor or equal to DimType::minVectorBlockSizeFactor
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
@@ -361,7 +361,7 @@ protected:
      * \brief Traverse a number of trees to get prediction results
      *
      * \param isResValidPtr Result pointer is valid yes/no (write result to the pointer if yes, skip if no)
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
      * \param nRows Number of rows in observation data for which prediction is run
@@ -378,7 +378,7 @@ protected:
     /**
      * \brief Traverse a number of trees to get prediction results
      *
-     * \param reuseBuffer Re-use buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
+     * \param reuseBuffer Reuse buffer yes/no (will fill buffer with zero if yes, shift buff pointer if no)
      * \param nTrees Number of trees contributing to prediction
      * \param nClasses Number of data classes
      * \param nRows Number of rows in observation data for which prediction is run

cpp/daal/src/algorithms/dtrees/gbt/gbt_train_aux.i

@@ -549,7 +549,7 @@ public:
             }
         }
 
-        ~BuffersStorage() { destoy(); }
+        ~BuffersStorage() { destroy(); }
 
         T * getBlockFromStorage()
         {
@@ -595,7 +595,7 @@ public:
             return alloc[alloc.size() - 1];
         }
 
-        void destoy()
+        void destroy()
         {
             for (size_t i = 0; i < alloc.size(); ++i)
             {
@@ -626,7 +626,7 @@ class GHSumsStorage
 public:
     GHSumsStorage(size_t nGH, size_t nInitElems) : _nGH(nGH), _capacity(nInitElems), _curIdx(0) { allocate(_capacity); }
 
-    ~GHSumsStorage() { destoy(); }
+    ~GHSumsStorage() { destroy(); }
 
     T * getBlockFromStorage()
     {
@@ -663,7 +663,7 @@ protected:
         }
     }
 
-    void destoy()
+    void destroy()
     {
         for (size_t i = 0; i < alloc.size(); ++i)
         {

cpp/daal/src/algorithms/dtrees/gbt/gbt_train_tree_builder.i

@@ -220,7 +220,7 @@ protected:
 
         ImpurityType imp;
         getInitialImpurity(imp);
-        typename NodeType::Base * res = buildLeaf(0, nSamples, 0, imp); // use node creater
+        typename NodeType::Base * res = buildLeaf(0, nSamples, 0, imp); // use node creator
         if (res) return res;
 
         SplitJobType job(0, nSamples, 0, imp, res);

cpp/daal/src/algorithms/dtrees/gbt/gbt_train_updater.i

@@ -116,8 +116,8 @@ public:
 
         if (_iFeature >= 0) // best split has been found
         {
-            PartitionTaskType partion(_iFeature, idxFeatureValueBestSplit, _data, _node, _bestSplit);
-            partion.execute();
+            PartitionTaskType partition(_iFeature, idxFeatureValueBestSplit, _data, _node, _bestSplit);
+            partition.execute();
         }
 
         return nullptr;
@@ -276,13 +276,13 @@ public:
         LoopHelper<cpu>::run(true, 2, [&](size_t i) {
             if (_iFeature1 >= 0 && i == 0)
             {
-                PartitionTaskType partion(_iFeature1, idxFeatureValueBestSplit1, _data, _node1, _bestSplit1);
-                partion.execute();
+                PartitionTaskType partition(_iFeature1, idxFeatureValueBestSplit1, _data, _node1, _bestSplit1);
+                partition.execute();
             }
             if (_iFeature2 >= 0 && i == 1)
             {
-                PartitionTaskType partion(_iFeature2, idxFeatureValueBestSplit2, _data, _node2, _bestSplit2);
-                partion.execute();
+                PartitionTaskType partition(_iFeature2, idxFeatureValueBestSplit2, _data, _node2, _bestSplit2);
+                partition.execute();
             }
         });
 

cpp/daal/src/algorithms/dtrees/gbt/regression/gbt_regression_train_container.h

@@ -61,7 +61,7 @@ BatchContainer<algorithmFPType, method, cpu>::~BatchContainer()
  *  \brief Choose appropriate kernel to calculate gradient boosted trees model.
  *
  *  \param env[in]  Environment
- *  \param a[in]    Array of numeric tables contating input data
+ *  \param a[in]    Array of numeric tables containing input data
  *  \param r[out]   Resulting model
  *  \param par[in]  Decision forest algorithm parameters
  */

cpp/daal/src/algorithms/dtrees/gbt/treeshap.cpp

@@ -182,7 +182,7 @@ void unwindPath(PathElement * uniquePath, float * partialWeights, uint32_t uniqu
     }
 }
 
-// determine what the total permuation weight would be if
+// determine what the total permutation weight would be if
 // we unwound a previous extension in the decision path (for feature satisfying the threshold)
 float unwoundPathSum(const PathElement * uniquePath, const float * partialWeights, uint32_t uniqueDepth, uint32_t uniqueDepthPartialWeights,
                      uint32_t pathIndex)

cpp/daal/src/algorithms/em/em_gmm_dense_default_batch_task.h

@@ -146,15 +146,15 @@ class GmmModelFull : public GmmModel<algorithmFPType, cpu>
 
     void finalize(size_t k, algorithmFPType denominator)
     {
-        algorithmFPType multplier = 1.0 / denominator;
+        algorithmFPType multiplier = 1.0 / denominator;
         for (size_t i = 0; i < nFeatures; i++)
         {
             for (size_t j = 0; j < i; j++)
             {
-                sigma[k][i * nFeatures + j] *= multplier;
+                sigma[k][i * nFeatures + j] *= multiplier;
                 sigma[k][j * nFeatures + i] = sigma[k][i * nFeatures + j];
             }
-            sigma[k][i * nFeatures + i] *= multplier;
+            sigma[k][i * nFeatures + i] *= multiplier;
         }
     }
 
@@ -270,10 +270,10 @@ class GmmModelDiag : public GmmModel<algorithmFPType, cpu>
 
     void finalize(size_t k, algorithmFPType denominator)
     {
-        algorithmFPType multplier = 1.0 / denominator;
+        algorithmFPType multiplier = 1.0 / denominator;
         for (size_t i = 0; i < nFeatures; i++)
         {
-            sigma[k][i] *= multplier;
+            sigma[k][i] *= multiplier;
         }
     }
 

cpp/daal/src/algorithms/implicit_als/implicit_als_predict_ratings_dense_default_impl.i

@@ -17,7 +17,7 @@
 
 /*
 //++
-//  Implementation of impicit ALS prediction algorithm
+//  Implementation of implicit ALS prediction algorithm
 //--
 */
 

cpp/daal/src/algorithms/implicit_als/implicit_als_train_csr_default_distr_impl.i

@@ -17,7 +17,7 @@
 
 /*
 //++
-//  Implementation of impicit ALS training algorithm for distributed processing mode
+//  Implementation of implicit ALS training algorithm for distributed processing mode
 //--
 */
 

cpp/daal/src/algorithms/implicit_als/implicit_als_train_dense_default_batch_impl.i

@@ -17,7 +17,7 @@
 
 /*
 //++
-//  Implementation of impicit ALS training algorithm for batch processing mode
+//  Implementation of implicit ALS training algorithm for batch processing mode
 //--
 */
 

cpp/daal/src/algorithms/kmeans/kmeans_lloyd_batch_impl.i

@@ -80,17 +80,17 @@ Status KMeansBatchKernel<method, algorithmFPType, cpu>::compute(const NumericTab
         clusters = tClusters.get();
     }
 
-    NumericTable * assignmetsNT = nullptr;
+    NumericTable * assignmentsNT = nullptr;
     NumericTablePtr assignmentsPtr;
     if (r[1])
     {
-        assignmetsNT = const_cast<NumericTable *>(r[1]);
+        assignmentsNT = const_cast<NumericTable *>(r[1]);
     }
     else if (par->resultsToEvaluate & computeExactObjectiveFunction)
     {
         assignmentsPtr = HomogenNumericTableCPU<int, cpu>::create(1, n, &s);
         DAAL_CHECK_MALLOC(s);
-        assignmetsNT = assignmentsPtr.get();
+        assignmentsNT = assignmentsPtr.get();
     }
 
     DAAL_OVERFLOW_CHECK_BY_MULTIPLICATION(size_t, p, sizeof(double));
@@ -120,8 +120,9 @@ Status KMeansBatchKernel<method, algorithmFPType, cpu>::compute(const NumericTab
         DAAL_CHECK(task.get(), services::ErrorMemoryAllocationFailed);
         {
             DAAL_PROFILER_TASK(addNTToTaskThreaded);
-            /* For the last iteration we do not need to recount of assignmets */
-            s = task->template addNTToTaskThreaded<method>(ntData, nullptr, blockSize, assignmetsNT && (kIter == nIter - 1) ? assignmetsNT : nullptr);
+            /* For the last iteration we do not need to recount of assignments */
+            s = task->template addNTToTaskThreaded<method>(ntData, nullptr, blockSize,
+                                                           assignmentsNT && (kIter == nIter - 1) ? assignmentsNT : nullptr);
         }
 
         if (!s)
@@ -213,15 +214,15 @@ Status KMeansBatchKernel<method, algorithmFPType, cpu>::compute(const NumericTab
 
     if (par->resultsToEvaluate & computeAssignments || par->assignFlag || par->resultsToEvaluate & computeExactObjectiveFunction)
     {
-        PostProcessing<method, algorithmFPType, cpu>::computeAssignments(p, nClusters, clusters, ntData, nullptr, assignmetsNT, blockSize);
+        PostProcessing<method, algorithmFPType, cpu>::computeAssignments(p, nClusters, clusters, ntData, nullptr, assignmentsNT, blockSize);
     }
 
     if (par->resultsToEvaluate & computeExactObjectiveFunction)
     {
         WriteOnlyRows<algorithmFPType, cpu> mtTarget(*const_cast<NumericTable *>(r[2]), 0, 1);
         DAAL_CHECK_BLOCK_STATUS(mtTarget);
         algorithmFPType exactTargetFunc = algorithmFPType(0);
-        PostProcessing<method, algorithmFPType, cpu>::computeExactObjectiveFunction(p, nClusters, clusters, ntData, nullptr, assignmetsNT,
+        PostProcessing<method, algorithmFPType, cpu>::computeExactObjectiveFunction(p, nClusters, clusters, ntData, nullptr, assignmentsNT,
                                                                                     exactTargetFunc, blockSize);
 
         *mtTarget.get() = exactTargetFunc;

cpp/daal/src/algorithms/kmeans/kmeans_plusplus_init_impl.i

@@ -660,7 +660,7 @@ Status TaskPlusPlusBatchBase<algorithmFPType, cpu, DataHelper>::updateMinDist(co
 template <typename algorithmFPType, CpuType cpu, typename DataHelper>
 void TaskPlusPlusBatch<algorithmFPType, cpu, DataHelper>::calcCenter(size_t iCluster)
 {
-    // nTrials new candidats
+    // nTrials new candidates
     for (size_t iTrials = 0u; iTrials < this->_nTrials; iTrials++)
     {
         const algorithmFPType probability = this->_aProbability[iTrials * this->_nClusters + iCluster];

cpp/daal/src/algorithms/linear_model/linear_model_train_normeq_kernel.h

@@ -138,7 +138,7 @@ class ThreadingTask
 
     /**
      * Creates thread local storage of the requested size
-     * \param[in] nBetasIntercept   Number of colums in the partial result
+     * \param[in] nBetasIntercept   Number of columms in the partial result
      * \param[in] nResponses        Number of responses
      * \return Pointer on the thread local storage object if the object was created successfully, NULL otherwise
      */
@@ -165,7 +165,7 @@ class ThreadingTask
 protected:
     /**
      * Construct thread local storage of the requested size
-     * \param[in]  nBetasIntercept  Number of colums in the partial result
+     * \param[in]  nBetasIntercept  Number of columns in the partial result
      * \param[in]  nResponses       Number of responses
      * \param[out] st               Status of the object construction
      */
@@ -200,7 +200,7 @@ class UpdateKernel
      * \param[in]  initializeResult Flag. True if results initialization is required, false otherwise
      * \param[in]  interceptFlag    Flag.
      *                              - True if it is required to compute an intercept term and P' = P + 1
-     *                              - False otherwis, P' = P
+     *                              - False otherwise, P' = P
      * \return Status of the computations
      */
     static Status compute(const NumericTable & x, const NumericTable & y, NumericTable & xtx, NumericTable & xty, bool initializeResult,
@@ -223,7 +223,7 @@ class MergeKernel
 
     /**
      * Merges an array of partial results into one partial result
-     * \param[in] n          Number of partial resuts in the input array
+     * \param[in] n          Number of partial results in the input array
      * \param[in] partialxtx Array of n numeric tables of size P x P
      * \param[in] partialxty Array of n numeric tables of size Ny x P
      * \param[out] xtx       Numeric table of size P x P