| 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : KNNClassificationModel in class org.apache.ignite.ml.knn.classification.KNNClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, upstreamMap Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, upstreamMap Map<K,V>, parts int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public buildDataset(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : Dataset<EmptyContext,LabeledDataset<Double,LabeledVector>> in class org.apache.ignite.ml.knn.KNNUtils | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method private wrapFeatureExtractor(featureExtractor IgniteBiFunction<K,V,Vector>, featureMapping Map<Integer,Integer>) : IgniteBiFunction<K,V,Vector> in class org.apache.ignite.ml.composition.BaggingModelTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : double[] to row : Vector in method private calculateFrequencies(row Vector, valuesByFreq Map<Double,Integer>[]) : Map<Double,Integer>[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public DecisionTreeDataBuilder(featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) in class org.apache.ignite.ml.tree.data.DecisionTreeDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public LocalLabelPairCursor(upstreamMap Map<K,V>, filter IgniteBiPredicate<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, mdl Model<Vector,L>) in class org.apache.ignite.ml.selection.scoring.cursor.LocalLabelPairCursor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public evaluate(dataCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, mdl Model<Vector,L>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, metric Accuracy<L>) : double in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : double[] to row : Vector in method private calculateTheSums(row Vector, sums double[]) : double[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(upstreamMap Map<K,V>, partitions int, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(datasetBuilder DatasetBuilder<K,V>, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public NormalizationPreprocessor(p int, basePreprocessor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : LogRegressionMultiClassModel in class org.apache.ignite.ml.regressions.logistic.multiclass.LogRegressionMultiClassTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(upstreamMap Map<K,V>, partitions int, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	imputingValues : double[] to imputingValues : Vector in method public ImputerPreprocessor(imputingValues Vector, basePreprocessor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor IgniteBiFunction<K,V,Vector>) : ImputerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : DecisionTreeNode in class org.apache.ignite.ml.tree.DecisionTree | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public SimpleLabeledDatasetDataBuilder(featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleLabeledDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	xExtractor : IgniteBiFunction<K,V,double[]> to xExtractor : IgniteBiFunction<K,V,Vector> in method public LabeledDatasetPartitionDataBuilderOnHeap(xExtractor IgniteBiFunction<K,V,Vector>, yExtractor IgniteBiFunction<K,V,Double>) in class org.apache.ignite.ml.structures.partition.LabeledDatasetPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method private score(trainer DatasetTrainer<M,L>, datasetBuilderSupplier Function<IgniteBiPredicate<K,V>,DatasetBuilder<K,V>>, testDataIterSupplier BiFunction<IgniteBiPredicate<K,V>,M,LabelPairCursor<L>>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, scoreCalculator Metric<L>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : SVMLinearMultiClassClassificationModel in class org.apache.ignite.ml.svm.SVMLinearMultiClassClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method package FeatureExtractorWrapper(featureExtractor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.regressions.linear.FeatureExtractorWrapper | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : KMeansModel in class org.apache.ignite.ml.clustering.kmeans.KMeansTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public evaluate(dataCache IgniteCache<K,V>, mdl Model<Vector,L>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, metric Accuracy<L>) : double in class org.apache.ignite.ml.selection.scoring.evaluator.Evaluator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : MultilayerPerceptron in class org.apache.ignite.ml.nn.MLPTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method private learnModel(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : ModelOnFeaturesSubspace in class org.apache.ignite.ml.composition.BaggingModelTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(ignite Ignite, cache IgniteCache<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : KNNRegressionModel in class org.apache.ignite.ml.knn.regression.KNNRegressionTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(ignite Ignite, cache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public ImputerPreprocessor(imputingValues Vector, basePreprocessor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method protected abstract learnLabels(builder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lExtractor IgniteBiFunction<K,V,Double>) : void in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : SVMLinearBinaryClassificationModel in class org.apache.ignite.ml.svm.SVMLinearBinaryClassificationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(datasetBuilder DatasetBuilder<K,V>, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor IgniteBiFunction<K,V,Vector>) : MinMaxScalerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleDataset(upstreamMap Map<K,V>, partitions int, partCtxBuilder PartitionContextBuilder<K,V,C>, featureExtractor IgniteBiFunction<K,V,Vector>) : SimpleDataset<C> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(ignite Ignite, upstreamCache IgniteCache<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : Model<Vector,Double> in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public createSimpleLabeledDataset(upstreamMap Map<K,V>, partitions int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,double[]>) : SimpleLabeledDataset<EmptyContext> in class org.apache.ignite.ml.dataset.DatasetFactory | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method protected computeInitialValue(builder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : IgniteBiTuple<Double,Long> in class org.apache.ignite.ml.composition.boosting.GDBTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public CacheBasedLabelPairCursor(upstreamCache IgniteCache<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, mdl Model<Vector,L>) in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, ignite Ignite, upstreamCache IgniteCache<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor IgniteBiFunction<K,V,Vector>) : NormalizationPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.normalization.NormalizationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public MinMaxScalerPreprocessor(min double[], max double[], basePreprocessor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public SimpleDatasetDataBuilder(featureExtractor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method protected learnLabels(builder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lExtractor IgniteBiFunction<K,V,Double>) : void in class org.apache.ignite.ml.composition.boosting.GDBBinaryClassifierTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	vec : double[] to vec : Vector in method private foldMap(vec Vector, foldFun IgniteBiFunction<Double,Double,Double>, mapFun IgniteDoubleFunction<Double>, zero double) : double in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor IgniteBiFunction<K,V,Vector>) : BinarizationPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.binarization.BinarizationTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : LinearRegressionModel in class org.apache.ignite.ml.regressions.linear.LinearRegressionLSQRTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : ModelsComposition in class org.apache.ignite.ml.composition.BaggingModelTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(datasetBuilder DatasetBuilder<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,Double>) : LogisticRegressionModel in class org.apache.ignite.ml.regressions.logistic.binomial.LogisticRegressionSGDTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public score(trainer DatasetTrainer<M,L>, scoreCalculator Metric<L>, upstreamMap Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, mapper UniformMapper<K,V>, cv int) : double[] in class org.apache.ignite.ml.selection.cv.CrossValidation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(data Map<K,V>, parts int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public fit(data Map<K,V>, filter IgniteBiPredicate<K,V>, parts int, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>) : M in class org.apache.ignite.ml.trainers.DatasetTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	basePreprocessor : IgniteBiFunction<K,V,double[]> to basePreprocessor : IgniteBiFunction<K,V,Vector> in method public BinarizationPreprocessor(threshold double, basePreprocessor IgniteBiFunction<K,V,Vector>) in class org.apache.ignite.ml.preprocessing.binarization.BinarizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	featureExtractor : IgniteBiFunction<K,V,double[]> to featureExtractor : IgniteBiFunction<K,V,Vector> in method public CacheBasedLabelPairCursor(upstreamCache IgniteCache<K,V>, filter IgniteBiPredicate<K,V>, featureExtractor IgniteBiFunction<K,V,Vector>, lbExtractor IgniteBiFunction<K,V,L>, mdl Model<Vector,L>) in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	row : double[] to row : Vector in method private calculateTheCounts(row Vector, counts int[]) : int[] in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                            
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,double[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,double[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	standardizationTrainer : MinMaxScalerTrainer<Integer,double[]> to standardizationTrainer : MinMaxScalerTrainer<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cache : IgniteCache<Integer,double[]> to cache : IgniteCache<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : MinMaxScalerPreprocessor<Integer,double[]> to preprocessor : MinMaxScalerPreprocessor<Integer,Vector> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cache : IgniteCache<Integer,double[]> to cache : IgniteCache<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Go_to_LogReg | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cache : IgniteCache<Integer,double[]> to cache : IgniteCache<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,double[]> to preprocessor : IgniteBiFunction<Integer,Person,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.BinarizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,double[]> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : double[] to res : Vector in method public apply(k K, v V) : Vector in class org.apache.ignite.ml.preprocessing.imputing.ImputerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,double[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : NormalizationPreprocessor<Integer,double[]> to preprocessor : NormalizationPreprocessor<Integer,Vector> in method public testApply() : void in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessorTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	features : double[] to features : Vector in method public next() : LabelPair<L> in class org.apache.ignite.ml.selection.scoring.cursor.CacheBasedLabelPairCursor.TruthWithPredictionIterator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	row : double[] to row : Vector in method public build(upstreamData Iterator<UpstreamEntry<K,V>>, upstreamDataSize long, ctx C) : LabeledDataset<Double,LabeledVector> in class org.apache.ignite.ml.structures.partition.LabeledDatasetPartitionDataBuilderOnHeap | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : ImputerPreprocessor<Integer,double[]> to preprocessor : ImputerPreprocessor<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	featureRow : double[] to featureRow : Vector in method public build(upstreamData Iterator<UpstreamEntry<K,V>>, upstreamDataSize long, ctx C) : SimpleLabeledDatasetData in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleLabeledDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,double[]> to preprocessor : IgniteBiFunction<Integer,Person,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.NormalizationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,double[]> to preprocessor : IgniteBiFunction<Integer,Person,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.MinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationTrainer : MinMaxScalerTrainer<Integer,double[]> to normalizationTrainer : MinMaxScalerTrainer<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Go_to_LogReg | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,double[]> to preprocessor : IgniteBiFunction<Integer,Person,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.ImputingExampleWithMostFrequentValues | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputerTrainer : ImputerTrainer<Integer,double[]> to imputerTrainer : ImputerTrainer<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : MinMaxScalerPreprocessor<Integer,double[]> to preprocessor : MinMaxScalerPreprocessor<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observation : Cache.Entry<Integer,double[]> to observation : Cache.Entry<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	features : double[] to features : Vector in method public next() : LabelPair<L> in class org.apache.ignite.ml.selection.scoring.cursor.LocalLabelPairCursor.TruthWithPredictionIterator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : double[] to res : Vector in method public apply(k K, v V) : Vector in class org.apache.ignite.ml.preprocessing.normalization.NormalizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,double[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,double[]> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_3_Categorial | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_2_Imputing | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_7_Split_train_test | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,double[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_8_CV | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to minMaxScalerPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	val : double[] to val : Vector in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,double[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.svm.multiclass.SVMMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Go_to_LogReg | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationTrainer : MinMaxScalerTrainer<Integer,double[]> to normalizationTrainer : MinMaxScalerTrainer<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : double[] to res : Vector in method public apply(k K, v V) : Vector in class org.apache.ignite.ml.preprocessing.binarization.BinarizationPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingValues : double[] to imputingValues : Vector in method public fit(datasetBuilder DatasetBuilder<K,V>, basePreprocessor IgniteBiFunction<K,V,Vector>) : ImputerPreprocessor<K,V> in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	row : double[] to row : Vector in method public build(upstreamData Iterator<UpstreamEntry<K,V>>, upstreamDataSize long, ctx C) : SimpleDatasetData in class org.apache.ignite.ml.dataset.primitive.builder.data.SimpleDatasetDataBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	preprocessor : IgniteBiFunction<Integer,Person,double[]> to preprocessor : IgniteBiFunction<Integer,Person,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.preprocessing.ImputingExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	dataCache : IgniteCache<Integer,double[]> to dataCache : IgniteCache<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	res : double[] to res : Vector in method public apply(k K, v V) : Vector in class org.apache.ignite.ml.preprocessing.minmaxscaling.MinMaxScalerPreprocessor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	imputingPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to imputingPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_4_Add_age_fare | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_9_Go_to_LogReg | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	datasetBuilder : DatasetBuilder<Integer,double[]> to datasetBuilder : DatasetBuilder<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainerTest | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	observations : QueryCursor<Cache.Entry<Integer,double[]>> to observations : QueryCursor<Cache.Entry<Integer,Vector>> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.linear.LinearRegressionLSQRTrainerWithMinMaxScalerExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationTrainer : MinMaxScalerTrainer<Integer,double[]> to normalizationTrainer : MinMaxScalerTrainer<Integer,Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	normalizationPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to normalizationPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_6_KNN | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	cacheConfiguration : CacheConfiguration<Integer,double[]> to cacheConfiguration : CacheConfiguration<Integer,Vector> in method private getTestCache(ignite Ignite) : IgniteCache<Integer,Vector> in class org.apache.ignite.examples.ml.regression.logistic.multiclass.LogRegressionMultiClassClassificationExample | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],double[]> to strEncoderPreprocessor : IgniteBiFunction<Integer,Object[],Vector> in method public main(args String[]) : void in class org.apache.ignite.examples.ml.tutorial.Step_5_Scaling | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	data : Map<Integer,double[]> to data : Map<Integer,Vector> in method public testFit() : void in class org.apache.ignite.ml.preprocessing.imputing.ImputerTrainerTest | 
                                From | 
                                To |