@@ -21,7 +21,7 @@ export(SVMtrainInterface)

 export(SelectParams)

 export(TrainParams)

 export(TransformParams)

-export(actualOutcomes)

+export(actualOutcome)

 export(bartlettRanking)

 export(calcCVperformance)

 export(calcExternalPerformance)

@@ -106,7 +106,7 @@ exportMethods(SVMtrainInterface)

 exportMethods(SelectParams)

 exportMethods(TrainParams)

 exportMethods(TransformParams)

-exportMethods(actualOutcomes)

+exportMethods(actualOutcome)

 exportMethods(bartlettRanking)

 exportMethods(calcCVperformance)

 exportMethods(calcExternalPerformance)

@@ -98,7 +98,7 @@ setMethod("ROCplot", "list",

   mode <- match.arg(mode)

   ggplot2::theme_set(ggplot2::theme_classic() + ggplot2::theme(panel.border = ggplot2::element_rect(fill = NA)))

-  distinctClasses <- levels(actualOutcomes(results[[1]]))

+  distinctClasses <- levels(actualOutcome(results[[1]]))

   numberDistinctClasses <- length(distinctClasses)

   comparisonName <- comparison

   comparisonValues <- sapply(results, function(result) result@characteristics[match(comparisonName, result@characteristics[, "characteristic"]), "value"])

@@ -124,7 +124,7 @@ setMethod("ROCplot", "list",

     allPRlist <- lapply(predictionsList, function(predictions)

     {

-      actualClasses <- actualOutcomes(result)[match(predictions[, "sample"], sampleNames(result))]

+      actualClasses <- actualOutcome(result)[match(predictions[, "sample"], sampleNames(result))]

       do.call(rbind, lapply(levels(actualClasses), function(class)

       {

         totalPositives <- sum(actualClasses == class)

@@ -60,8 +60,8 @@

 #' \item{\code{"Sample C-index"}: Per-individual C-index.}

 #' }

 #' 

-#' @param actualOutcomes A factor vector or survival information specifying each sample's known outcome.

-#' @param predictedOutcomes A factor vector or survival information of the same length as \code{actualOutcomes} specifying each sample's predicted outcome.

+#' @param actualOutcome A factor vector or survival information specifying each sample's known outcome.

+#' @param predictedOutcome A factor vector or survival information of the same length as \code{actualOutcome} specifying each sample's predicted outcome.

 #' 

 #' @return If \code{calcCVperformance} was run, an updated

 #' \code{\linkS4class{ClassifyResult}} object, with new metric values in the

@@ -86,13 +86,13 @@

 #' @rdname calcPerformance

 #' @usage NULL

 #' @export

-setGeneric("calcExternalPerformance", function(actualOutcomes, predictedOutcomes, ...)

+setGeneric("calcExternalPerformance", function(actualOutcome, predictedOutcome, ...)

 standardGeneric("calcExternalPerformance"))

 #' @rdname calcPerformance

 #' @exportMethod calcExternalPerformance

 setMethod("calcExternalPerformance", c("factor", "factor"),

-          function(actualOutcomes, predictedOutcomes, # Both are classes.

+          function(actualOutcome, predictedOutcome, # Both are classes.

                    performanceType = c("Balanced Accuracy", "Balanced Error", "Error", "Accuracy",

                                        "Sample Error", "Sample Accuracy",

                                        "Micro Precision", "Micro Recall",

@@ -100,19 +100,19 @@ setMethod("calcExternalPerformance", c("factor", "factor"),

                                        "Macro Recall", "Macro F1", "Matthews Correlation Coefficient"))

 {

   performanceType <- match.arg(performanceType)

-  if(length(levels(actualOutcomes)) > 2 && performanceType == "Matthews Correlation Coefficient")

+  if(length(levels(actualOutcome)) > 2 && performanceType == "Matthews Correlation Coefficient")

     stop("Error: Matthews Correlation Coefficient specified but data set has more than 2 classes.")

-  if(is(predictedOutcomes, "factor")) levels(predictedOutcomes) <- levels(actualOutcomes)

-  .calcPerformance(list(actualOutcomes), list(predictedOutcomes), performanceType = performanceType)[["values"]]

+  if(is(predictedOutcome, "factor")) levels(predictedOutcome) <- levels(actualOutcome)

+  .calcPerformance(list(actualOutcome), list(predictedOutcome), performanceType = performanceType)[["values"]]

 })

 #' @rdname calcPerformance

 #' @exportMethod calcExternalPerformance

 setMethod("calcExternalPerformance", c("Surv", "numeric"),

-          function(actualOutcomes, predictedOutcomes, performanceType = "C-index")

+          function(actualOutcome, predictedOutcome, performanceType = "C-index")

           {

             performanceType <- match.arg(performanceType)

-            .calcPerformance(actualOutcomes, predictedOutcomes, performanceType = performanceType)[["values"]]

+            .calcPerformance(actualOutcome, predictedOutcome, performanceType = performanceType)[["values"]]

           })

 #' @rdname calcPerformance

@@ -132,7 +132,7 @@ setMethod("calcCVperformance", "ClassifyResult",

                                                "C-index", "Sample C-index"))

 {

   performanceType <- match.arg(performanceType)

-  actualOutcomes <- actualOutcomes(result) # Extract the known outcomes of all samples.

+  actualOutcome <- actualOutcome(result) # Extract the known outcome of each sample.

   ### Group by permutation

   if(!performanceType %in% c("Sample Error", "Sample Accuracy"))

@@ -146,8 +146,8 @@ setMethod("calcCVperformance", "ClassifyResult",

   ### Performance for survival data

   if(performanceType %in% c("C-index", "Sample C-index")) {

     samples <- factor(result@predictions[, "sample"], levels = sampleNames(result))

-    performance <- .calcPerformance(actualOutcomes = actualOutcomes[match(result@predictions[, "sample"], sampleNames(result))],

-                                    predictedOutcomes = result@predictions[, "risk"], 

+    performance <- .calcPerformance(actualOutcome = actualOutcome[match(result@predictions[, "sample"], sampleNames(result))],

+                                    predictedOutcome = result@predictions[, "risk"], 

                                     samples = samples,

                                     performanceType = performanceType, 

                                     grouping = grouping)

@@ -156,28 +156,28 @@ setMethod("calcCVperformance", "ClassifyResult",

   }

   if(performanceType == "AUC") {

-    performance <- .calcPerformance(actualOutcomes[match(result@predictions[, "sample"], sampleNames(result))],

-                                    result@predictions[, levels(actualOutcomes)],

+    performance <- .calcPerformance(actualOutcome[match(result@predictions[, "sample"], sampleNames(result))],

+                                    result@predictions[, levels(actualOutcome)],

                                     performanceType = performanceType, grouping = grouping)

     result@performance[[performance[["name"]]]] <- performance[["values"]]

     return(result)

   }

   ### Performance for data with classes

-  if(length(levels(actualOutcomes)) > 2 && performanceType == "Matthews Correlation Coefficient")

+  if(length(levels(actualOutcome)) > 2 && performanceType == "Matthews Correlation Coefficient")

     stop("Error: Matthews Correlation Coefficient specified but data set has more than 2 classes.")

-  classLevels <- levels(actualOutcomes)

+  classLevels <- levels(actualOutcome)

   samples <- factor(result@predictions[, "sample"], levels = sampleNames(result))

-  predictedOutcomes <- factor(result@predictions[, "class"], levels = classLevels)

-  actualOutcomes <- factor(actualOutcomes[match(result@predictions[, "sample"], sampleNames(result))], levels = classLevels, ordered = TRUE)

-  performance <- .calcPerformance(actualOutcomes, predictedOutcomes, samples, performanceType, grouping)

+  predictedOutcome <- factor(result@predictions[, "class"], levels = classLevels)

+  actualOutcome <- factor(actualOutcome[match(result@predictions[, "sample"], sampleNames(result))], levels = classLevels, ordered = TRUE)

+  performance <- .calcPerformance(actualOutcome, predictedOutcome, samples, performanceType, grouping)

   result@performance[[performance[["name"]]]] <- performance[["values"]]

   result

 })

 #' @importFrom survival concordance

-.calcPerformance <- function(actualOutcomes, predictedOutcomes, samples = NA, performanceType, grouping = NULL)

+.calcPerformance <- function(actualOutcome, predictedOutcome, samples = NA, performanceType, grouping = NULL)

 {

   if(performanceType %in% c("Sample Error", "Sample Accuracy"))

   {

@@ -186,9 +186,9 @@ setMethod("calcCVperformance", "ClassifyResult",

     {

       consider <- which(samples == sampleID)

       if(performanceType == "Sample Error")

-        sum(predictedOutcomes[consider] != as.character(actualOutcomes[consider]))

+        sum(predictedOutcome[consider] != as.character(actualOutcome[consider]))

       else

-        sum(predictedOutcomes[consider] == as.character(actualOutcomes[consider]))

+        sum(predictedOutcome[consider] == as.character(actualOutcome[consider]))

     })

     performanceValues <- as.numeric(sampleMetricValues / table(samples))

     names(performanceValues) <- levels(samples)

@@ -197,8 +197,8 @@ setMethod("calcCVperformance", "ClassifyResult",

   if(!is.null(grouping))

   {

-    actualOutcomes <- split(actualOutcomes, grouping)

-    predictedOutcomes <- split(predictedOutcomes, grouping)

+    actualOutcome <- split(actualOutcome, grouping)

+    predictedOutcome <- split(predictedOutcome, grouping)

     allSamples <- levels(samples)

     samples <- split(samples, grouping)

   }

@@ -231,7 +231,7 @@ setMethod("calcCVperformance", "ClassifyResult",

         }

         data.frame(sample = sampleID, concordant = concordants, discordant = discordants)

       }))

-    }, actualOutcomes, predictedOutcomes, samples, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, samples, SIMPLIFY = FALSE))

     sampleValues <- by(performanceValues[, c("concordant", "discordant")], performanceValues[, "sample"], colSums)

     Cindex <- round(sapply(sampleValues, '[', 1) / (sapply(sampleValues, '[', 1) + sapply(sampleValues, '[', 2)), 2)

@@ -240,8 +240,8 @@ setMethod("calcCVperformance", "ClassifyResult",

     return(list(name = performanceType, values = Cindex))

   }

-  if(!is(actualOutcomes, "list")) actualOutcomes <- list(actualOutcomes)

-  if(!is(predictedOutcomes, "list")) predictedOutcomes <- list(predictedOutcomes)

+  if(!is(actualOutcome, "list")) actualOutcome <- list(actualOutcome)

+  if(!is(predictedOutcome, "list")) predictedOutcome <- list(predictedOutcome)

   if(performanceType %in% c("Accuracy", "Error")) {

@@ -257,7 +257,7 @@ setMethod("calcCVperformance", "ClassifyResult",

         correctPredictions / totalPredictions

       else # It is "error".

         wrongPredictions / totalPredictions

-    }, actualOutcomes, predictedOutcomes, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, SIMPLIFY = FALSE))

   } else if(performanceType %in% c("Balanced Accuracy", "Balanced Error")) {

     performanceValues <- unlist(mapply(function(iterationClasses, iterationPredictions)

     {

@@ -269,7 +269,7 @@ setMethod("calcCVperformance", "ClassifyResult",

         mean(diag(confusionMatrix) / classSizes)

       else

         mean(classErrors / classSizes)

-    }, actualOutcomes, predictedOutcomes, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, SIMPLIFY = FALSE))

   } else if(performanceType %in% c("AUC")) {

     performanceValues <- unlist(mapply(function(iterationClasses, iterationPredictions)

     {

@@ -290,14 +290,14 @@ setMethod("calcCVperformance", "ClassifyResult",

         rates <- rbind(data.frame(FPR = 0, TPR = 0, class = class), rates)

         rates

       }))

-      classesAUC <- .calcArea(classesTable, levels(actualOutcomes[[1]]))

+      classesAUC <- .calcArea(classesTable, levels(actualOutcome[[1]]))

       mean(classesAUC[!duplicated(classesAUC[, c("class", "AUC")]), "AUC"]) # Average AUC in iteration.

-    }, actualOutcomes, predictedOutcomes, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, SIMPLIFY = FALSE))

   } else if(performanceType %in% c("C-index")) {

     performanceValues <- unlist(mapply(function(x, y){

       y <- -y

       survival::concordance(x ~ y)$concordance

-    }, actualOutcomes, predictedOutcomes, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, SIMPLIFY = FALSE))

     } else { # Metrics for which true positives, true negatives, false positives, false negatives must be calculated.

     performanceValues <- unlist(mapply(function(iterationClasses, iterationPredictions)

@@ -345,7 +345,7 @@ setMethod("calcCVperformance", "ClassifyResult",

         return(unname((truePositives[2] * trueNegatives[2] - falsePositives[2] * falseNegatives[2]) / sqrt((truePositives[2] + falsePositives[2]) * (truePositives[2] + falseNegatives[2]) * (trueNegatives[2] + falsePositives[2]) * (trueNegatives[2] + falseNegatives[2]))))

       }

-    }, actualOutcomes, predictedOutcomes, SIMPLIFY = FALSE))

+    }, actualOutcome, predictedOutcome, SIMPLIFY = FALSE))

   }

   list(name = performanceType, values = performanceValues)

@@ -1228,8 +1228,8 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' ClassifyResult,DataFrame,character,characterOrDataFrame-method

 #' show,ClassifyResult-method sampleNames sampleNames,ClassifyResult-method

 #' featuresInfo featuresInfo,ClassifyResult-method

-#' predictions predictions,ClassifyResult-method actualOutcomes

-#' actualOutcomes,ClassifyResult-method features features,ClassifyResult-method

+#' predictions predictions,ClassifyResult-method actualOutcome

+#' actualOutcome,ClassifyResult-method features features,ClassifyResult-method

 #' models models,ClassifyResult-method performance

 #' performance,ClassifyResult-method tunedParameters

 #' tunedParameters,ClassifyResult-method totalPredictions

@@ -1238,7 +1238,7 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' 

 #' @section Constructor:

 #' \preformatted{ClassifyResult(characteristics, originalNames, originalFeatures,

-#'               rankedFeatures, chosenFeatures, models, tunedParameters, predictions, actualOutcomes, importance = NULL, modellingParams = NULL, finalModel = NULL)}

+#'               rankedFeatures, chosenFeatures, models, tunedParameters, predictions, actualOutcome, importance = NULL, modellingParams = NULL, finalModel = NULL)}

 #' \describe{

 #' \item{\code{characteristics}}{A \code{\link{DataFrame}} describing the

 #' characteristics of classification done. First column must be named

@@ -1257,7 +1257,7 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' \item{\code{tunedParameters}}{Names of tuning parameters and the value chosen of each parameter.}

 #' \item{\code{predictions}}{A data frame containing sample IDs, predicted class or risk and information about the 

 #' cross-validation iteration in which the prediction was made.}

-#' \item{\code{actualOutcomes}}{The known class or survival data of each sample.}

+#' \item{\code{actualOutcome}}{The known class or survival data of each sample.}

 #' \item{\code{importance}}{The changes in model performance for each selected variable when it is excluded.}

 #' \item{\code{modellingParams}}{Stores the object used for defining the model building to enable future reuse.}

 #' \item{\code{finalModel}}{A model built using all of the sample for future use. For any tuning parameters, the

@@ -1278,7 +1278,7 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' \describe{

 #' \item{\code{featuresInfo(result)}}{Returns a table of features present in the data set. Shows original names and renamed names to ensure no unusual symbols in names.}}

 #' \describe{

-#' \item{\code{actualOutcomes(result)}}{Returns the known outcomes of each sample.}}

+#' \item{\code{actualOutcome(result)}}{Returns the known outcome of each sample.}}

 #' \describe{

 #' \item{\code{models(result)}}{A \code{list} of the models fitted for each training.}}

 #' \describe{

@@ -1328,7 +1328,7 @@ setClass("ClassifyResult", representation(

   featuresInfo = "DataFrame",

   rankedFeatures = "listOrNULL",

   chosenFeatures = "listOrNULL",

-  actualOutcomes = "factorOrSurv",

+  actualOutcome = "factorOrSurv",

   models = "list",

   tune = "listOrNULL",

   predictions = "DataFrame",

@@ -1342,13 +1342,13 @@ setClass("ClassifyResult", representation(

 #' @export

 setMethod("ClassifyResult", c("DataFrame", "character", "characterOrDataFrame"),

           function(characteristics, originalNames, featuresInfo,

-                   rankedFeatures, chosenFeatures, models, tunedParameters, predictions, actualOutcomes, importance = NULL, modellingParams = NULL, finalModel = NULL)

+                   rankedFeatures, chosenFeatures, models, tunedParameters, predictions, actualOutcome, importance = NULL, modellingParams = NULL, finalModel = NULL)

           {

             new("ClassifyResult", characteristics = characteristics,

                 originalNames = originalNames, featuresInfo = featuresInfo,

                 rankedFeatures = rankedFeatures, chosenFeatures = chosenFeatures,

                 models = models, tune = tunedParameters,

-                predictions = predictions, actualOutcomes = actualOutcomes, importance = importance, modellingParams = modellingParams, finalModel = finalModel)

+                predictions = predictions, actualOutcome = actualOutcome, importance = importance, modellingParams = modellingParams, finalModel = finalModel)

           })

 #' @usage NULL

@@ -1463,16 +1463,16 @@ setMethod("performance", c("ClassifyResult"),

 #' @export

 #' @usage NULL

-setGeneric("actualOutcomes", function(object, ...)

-standardGeneric("actualOutcomes"))

+setGeneric("actualOutcome", function(object, ...)

+standardGeneric("actualOutcome"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

-setMethod("actualOutcomes", c("ClassifyResult"),

+setMethod("actualOutcome", c("ClassifyResult"),

           function(object)

           {

-            object@actualOutcomes

+            object@actualOutcome

           })

 #' @export

@@ -7,16 +7,13 @@

 #' or a list of these objects containing the training data.  For a

 #' \code{matrix} and \code{data.frame}, the rows are samples and the columns are features. For a \code{data.frame} or \code{\link{MultiAssayExperiment}} assay

 #' the rows are features and the columns are samples, as is typical in Bioconductor.

-#' @param outcomes A vector of class labels of class \code{\link{factor}} of the

+#' @param outcome A vector of class labels of class \code{\link{factor}} of the

 #' same length as the number of samples in \code{measurements} or a character vector of length 1 containing the

 #' column name in \code{measurements} if it is a \code{\link{DataFrame}} or the

 #' column name in \code{colData(measurements)} if \code{measurements} is a \code{\link{MultiAssayExperiment}}. If a column name, that column will be

 #' removed before training. Or a \code{\link{Surv}} object or a character vector of length 2 or 3 specifying the time and event columns in

 #' \code{measurements} for survival outcome.

-#' @param ... Arguments other than measurements and outcomes in the generic.

-#' @param assayName An informative name describing the data (e.g. RNA-seq) table if the input is a data frame or matrix. Not used if input

-#' is \code{MultiAssayExperiment} or other list-like structure because it will already have assay names in the experiment list. This

-#' name will be stored in the characteristics table of the result as Assay Name characteristic.

+#' @param ... Arguments other than measurements and outcome in the generic.

 #' @param nFeatures The number of features to be used for classification. If this is a single number, the same number of features will be used for all comparisons

 #' or assays. If a numeric vector these will be optimised over using \code{selectionOptimisation}. If a named vector with the same names of multiple assays, 

 #' a different number of features will be used for each assay. If a named list of vectors, the respective number of features will be optimised over. 

@@ -81,15 +78,14 @@

 #' # performancePlot(c(result, resultMerge))

 #' 

 #' @importFrom survival Surv

-setGeneric("crossValidate", function(measurements, outcomes, ...)

+setGeneric("crossValidate", function(measurements, outcome, ...)

     standardGeneric("crossValidate"))

 #' @rdname crossValidate

 #' @export

 setMethod("crossValidate", "DataFrame", 

           function(measurements,

-                   outcomes,

-                   assayName = NULL,

+                   outcome,

                    nFeatures = 20,

                    selectionMethod = "t-test",

                    selectionOptimisation = "Resubstitution",

@@ -103,16 +99,16 @@ setMethod("crossValidate", "DataFrame",

           {

               # Check that data is in the right format

-              splitAssay <- .splitDataAndOutcomes(measurements, outcomes)

+              splitAssay <- .splitDataAndOutcome(measurements, outcome)

               measurements <- splitAssay[["measurements"]]

-              outcomes <- splitAssay[["outcomes"]]

+              outcome <- splitAssay[["outcome"]]

               # Which data-types or data-views are present?

               assayIDs <- unique(mcols(measurements)[, "assay"])

               if(is.null(assayIDs))

                 assayIDs <- 1

-              checkData(measurements, outcomes)

+              checkData(measurements, outcome)

               # Check that other variables are in the right format and fix

               nFeatures <- cleanNFeatures(nFeatures = nFeatures,

@@ -161,10 +157,9 @@ setMethod("crossValidate", "DataFrame",

                                   # Loop over classifiers

                                   set.seed(seed)

                                   measurementsUse <- measurements

-                                  if(!is.null(assayName)) attr(measurementsUse, "assayName") <- assayName

                                   if(assayIndex != 1) measurementsUse <- measurements[, mcols(measurements)[, "assay"] == assayIndex, drop = FALSE]

                                   CV(

-                                      measurements = measurementsUse, outcomes = outcomes,

+                                      measurements = measurementsUse, outcome = outcome,

                                       assayIDs = assayIndex,

                                       nFeatures = nFeatures[assayIndex],

                                       selectionMethod = selectionIndex,

@@ -206,7 +201,7 @@ setMethod("crossValidate", "DataFrame",

                   result <- sapply(assayCombinations, function(assayIndex){

                       CV(measurements = measurements[, mcols(measurements)[["assay"]] %in% assayIndex],

-                         outcomes = outcomes, assayIDs = assayIndex,

+                         outcome = outcome, assayIDs = assayIndex,

                          nFeatures = nFeatures[assayIndex],

                          selectionMethod = selectionMethod[assayIndex],

                          selectionOptimisation = selectionOptimisation,

@@ -239,7 +234,7 @@ setMethod("crossValidate", "DataFrame",

                   result <- sapply(assayCombinations, function(assayIndex){

                       CV(measurements = measurements[, mcols(measurements)[["assay"]] %in% assayIndex],

-                         outcomes = outcomes, assayIDs = assayIndex,

+                         outcome = outcome, assayIDs = assayIndex,

                          nFeatures = nFeatures[assayIndex],

                          selectionMethod = selectionMethod[assayIndex],

                          selectionOptimisation = selectionOptimisation,

@@ -272,7 +267,7 @@ setMethod("crossValidate", "DataFrame",

                   result <- sapply(assayCombinations, function(assayIndex){

                       CV(measurements = measurements[, mcols(measurements)$assay %in% assayIndex],

-                         outcomes = outcomes, assayIDs = assayIndex,

+                         outcome = outcome, assayIDs = assayIndex,

                          nFeatures = nFeatures[assayIndex],

                          selectionMethod = selectionMethod[assayIndex],

                          selectionOptimisation = selectionOptimisation,

@@ -296,7 +291,7 @@ setMethod("crossValidate", "DataFrame",

 # One or more omics data sets, possibly with clinical data.

 setMethod("crossValidate", "MultiAssayExperiment",

           function(measurements,

-                   outcomes, 

+                   outcome, 

                    nFeatures = 20,

                    selectionMethod = "t-test",

                    selectionOptimisation = "Resubstitution",

@@ -316,12 +311,12 @@ setMethod("crossValidate", "MultiAssayExperiment",

                       stop("Data set contains replicates. Please provide remove or average replicate observations and try again.")

               }

-              tablesAndoutcomes <- .MAEtoWideTable(measurements, targets, outcomes, restrict = NULL)

-              measurements <- tablesAndoutcomes[["dataTable"]]

-              outcomes <- tablesAndoutcomes[["outcomes"]]

+              tablesAndoutcome <- .MAEtoWideTable(measurements, targets, outcome, restrict = NULL)

+              measurements <- tablesAndoutcome[["dataTable"]]

+              outcome <- tablesAndoutcome[["outcome"]]

               crossValidate(measurements = measurements,

-                            outcomes = outcomes, 

+                            outcome = outcome, 

                             nFeatures = nFeatures,

                             selectionMethod = selectionMethod,

                             selectionOptimisation = selectionOptimisation,

@@ -338,8 +333,7 @@ setMethod("crossValidate", "MultiAssayExperiment",

 #' @export

 setMethod("crossValidate", "data.frame", # data.frame of numeric measurements.

           function(measurements,

-                   outcomes, 

-                   assayName = NULL,

+                   outcome, 

                    nFeatures = 20,

                    selectionMethod = "t-test",

                    selectionOptimisation = "Resubstitution",

@@ -353,8 +347,7 @@ setMethod("crossValidate", "data.frame", # data.frame of numeric measurements.

           {

               measurements <- DataFrame(measurements)

               crossValidate(measurements = measurements,

-                            outcomes = outcomes,

-                            assayName = assayName,

+                            outcome = outcome,

                             nFeatures = nFeatures,

                             selectionMethod = selectionMethod,

                             selectionOptimisation = selectionOptimisation,

@@ -371,8 +364,7 @@ setMethod("crossValidate", "data.frame", # data.frame of numeric measurements.

 #' @export

 setMethod("crossValidate", "matrix", # Matrix of numeric measurements.

           function(measurements,

-                   outcomes,

-                   assayName = NULL,

+                   outcome,

                    nFeatures = 20,

                    selectionMethod = "t-test",

                    selectionOptimisation = "Resubstitution",

@@ -386,8 +378,7 @@ setMethod("crossValidate", "matrix", # Matrix of numeric measurements.

           {

               measurements <- S4Vectors::DataFrame(measurements, check.names = FALSE)

               crossValidate(measurements = measurements,

-                            outcomes = outcomes,

-                            assayName = assayName,

+                            outcome = outcome,

                             nFeatures = nFeatures,

                             selectionMethod = selectionMethod,

                             selectionOptimisation = selectionOptimisation,

@@ -407,7 +398,7 @@ setMethod("crossValidate", "matrix", # Matrix of numeric measurements.

 #' @export

 setMethod("crossValidate", "list",

           function(measurements,

-                   outcomes, 

+                   outcome, 

                    nFeatures = 20,

                    selectionMethod = "t-test",

                    selectionOptimisation = "Resubstitution",

@@ -439,9 +430,9 @@ setMethod("crossValidate", "list",

                   stop("All datasets must have the same number of samples")

               }

-              # Check the number of classes is the same

-              if ((measurements[[1]] |> dim())[1] != length(classes)) {

-                  stop("Classes must have same number of samples as measurements")

+              # Check the number of outcome is the same

+              if ((measurements[[1]] |> dim())[1] != length(outcome)) {

+                  stop("outcome must have same number of samples as measurements")

               }

               df_list <- sapply(measurements, t, simplify = FALSE)

@@ -458,7 +449,7 @@ setMethod("crossValidate", "list",

               colnames(combined_df) <- mcols(combined_df)$feature

               crossValidate(measurements = combined_df,

-                            outcomes = outcomes, 

+                            outcome = outcome, 

                             nFeatures = nFeatures,

                             selectionMethod = selectionMethod,

                             selectionOptimisation = selectionOptimisation,

@@ -563,7 +554,7 @@ generateCrossValParams <- function(nRepeats, nFolds, nCores, selectionOptimisati

 ######################################

 ######################################

-checkData <- function(measurements, outcomes){

+checkData <- function(measurements, outcome){

     if(is.null(rownames(measurements)))

         stop("'measurements' DataFrame must have sample identifiers as its row names.")

     if(any(is.na(measurements)))

@@ -702,8 +693,8 @@ generateModellingParams <- function(assayIDs,

     #

     # if(multiViewMethod == "prevalidation"){

-    #     params$trainParams <- function(measurements, outcomes) prevalTrainInterface(measurements, outcomes, params)

-    #     params$trainParams <- function(measurements, outcomes) prevalTrainInterface(measurements, outcomes, params)

+    #     params$trainParams <- function(measurements, outcome) prevalTrainInterface(measurements, outcome, params)

+    #     params$trainParams <- function(measurements, outcome) prevalTrainInterface(measurements, outcome, params)

     # }

     #

@@ -849,7 +840,7 @@ generateMultiviewParams <- function(assayIDs,

 CV <- function(measurements,

-               outcomes,

+               outcome,

                assayIDs,

                nFeatures = NULL,

                selectionMethod = "t-test",

@@ -864,7 +855,7 @@ CV <- function(measurements,

 {

     # Check that data is in the right format

-    checkData(measurements, outcomes)

+    checkData(measurements, outcome)

     # Check that other variables are in the right format and fix

     nFeatures <- cleanNFeatures(nFeatures = nFeatures,

@@ -893,12 +884,12 @@ CV <- function(measurements,

                                                classifier = classifier,

                                                multiViewMethod = multiViewMethod

     )

-    if(assayIDs != 1) assayText <- assayIDs else if(!is.null(attr(measurements, "assayName"))) assayText <- attr(measurements, "assayName") else assayText <- NULL

+    if(length(assayIDs) > 1 || length(assayIDs) == 1 && assayIDs != 1) assayText <- assayIDs else assayText <- NULL

     characteristics <- S4Vectors::DataFrame(characteristic = c(if(!is.null(assayText)) "Assay Name" else NULL, "Classifier Name", "Selection Name", "multiViewMethod", "characteristicsLabel"), value = c(if(!is.null(assayText)) paste(assayText, collapse = ", ") else NULL, paste(classifier, collapse = ", "),  paste(selectionMethod, collapse = ", "), multiViewMethod, characteristicsLabel))

-    classifyResults <- runTests(measurements, outcomes, crossValParams = crossValParams, modellingParams = modellingParams, characteristics = characteristics)

+    classifyResults <- runTests(measurements, outcome, crossValParams = crossValParams, modellingParams = modellingParams, characteristics = characteristics)

-    fullResult <- runTest(measurements, outcomes, measurements, outcomes, crossValParams = crossValParams, modellingParams = modellingParams, characteristics = characteristics, .iteration = 1)

+    fullResult <- runTest(measurements, outcome, measurements, outcome, crossValParams = crossValParams, modellingParams = modellingParams, characteristics = characteristics, .iteration = 1)

     classifyResults@finalModel <- list(fullResult$models)

     classifyResults

@@ -922,8 +913,4 @@ setMethod("predict", "ClassifyResult",

           function(object, newData)

           {

               object@modellingParams@predictParams@predictor(object@finalModel[[1]], newData)

-          })

-

-

-

-

+          })

\ No newline at end of file

@@ -86,7 +86,7 @@ setMethod("distribution", "ClassifyResult",

   {

     errors <- by(allPredictions, allPredictions[, "sample"], function(samplePredicitons)

               {

-                sampleClass <- rep(actualOutcomes(result)[samplePredicitons[1, 1]], nrow(samplePredicitons))

+                sampleClass <- rep(actualOutcome(result)[samplePredicitons[1, 1]], nrow(samplePredicitons))

                 confusion <- table(samplePredicitons[, 2], sampleClass)

                 (confusion[upper.tri(confusion)] + confusion[lower.tri(confusion)]) /

                 (sum(diag(confusion)) + confusion[upper.tri(confusion)] + confusion[lower.tri(confusion)])

@@ -21,7 +21,7 @@

 #' name of the data table to be used.

 #' @param classesColumn If \code{measurementsTrain} is a \code{MultiAssayExperiment}, the

 #' names of the class column in the table extracted by \code{colData(multiAssayExperiment)}

-#' that contains the samples' outcomes to use for prediction.

+#' that contains each sample's outcome to use for prediction.

 #' @param ... Variables not used by the \code{matrix} nor the

 #' \code{MultiAssayExperiment} method which are passed into and used by the

 #' \code{DataFrame} method.

@@ -82,8 +82,8 @@ setMethod("classifyInterface", "DataFrame", function(countsTrain, classesTrain,

   returnType <- match.arg(returnType)

   # Ensure that any non-integer variables are removed from the training and testing matrices.

-  splitDataset <- .splitDataAndOutcomes(countsTrain, classesTrain, restrict = "integer")

-  classesTrain <- splitDataset[["outcomes"]]

+  splitDataset <- .splitDataAndOutcome(countsTrain, classesTrain, restrict = "integer")

+  classesTrain <- splitDataset[["outcome"]]

   trainingMatrix <- as.matrix(splitDataset[["measurements"]])

   isInteger <- sapply(countsTest, is.integer)

   testingMatrix <- as.matrix(countsTest[, isInteger, drop = FALSE])

@@ -106,9 +106,9 @@ setMethod("classifyInterface", "DataFrame", function(countsTrain, classesTrain,

 setMethod("classifyInterface", "MultiAssayExperiment",

 function(countsTrain, countsTest, targets = names(countsTrain), classesTrain, ...)

 {

-  tablesAndOutcomes <- .MAEtoWideTable(countsTrain, targets, classesTrain, "integer")

-  trainingMatrix <- tablesAndOutcomes[["dataTable"]]

-  classesTrain <- tablesAndOutcomes[["outcomes"]]

+  tablesAndOutcome <- .MAEtoWideTable(countsTrain, targets, classesTrain, "integer")

+  trainingMatrix <- tablesAndOutcome[["dataTable"]]

+  classesTrain <- tablesAndOutcome[["outcome"]]

   testingMatrix <- .MAEtoWideTable(countsTest, targets, "integer")

   .checkVariablesAndSame(trainingMatrix, testingMatrix)

@@ -89,8 +89,8 @@ setMethod("coxphTrainInterface", "DataFrame", function(measurementsTrain, surviv

     message("Fitting coxph classifier to training data and making predictions on test

             data.")

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, survivalTrain)  

-  survivalTrain <- splitDataset[["outcomes"]]

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, survivalTrain)  

+  survivalTrain <- splitDataset[["outcome"]]

   measurementsTrain <- splitDataset[["measurements"]]

   survival::coxph(survivalTrain ~ ., measurementsTrain)

@@ -102,7 +102,7 @@ setMethod("coxphTrainInterface", "MultiAssayExperiment", function(measurementsTr

 {

   tablesAndSurvival <- .MAEtoWideTable(measurementsTrain, targets, survivalTrain, restrict = NULL)

   measurementsTrain <- tablesAndSurvival[["dataTable"]]

-  survivalTrain <- tablesAndSurvival[["outcomes"]]

+  survivalTrain <- tablesAndSurvival[["outcome"]]

   coxphTrainInterface(measurementsTrain, survivalTrain, ...)

 })

@@ -101,12 +101,12 @@ setMethod("coxnetTrainInterface", "DataFrame", function(measurementsTrain, survi

   if(verbose == 3)

     message("Fitting coxnet model to data.")

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, survivalTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, survivalTrain)

   measurementsTrain <- data.frame(splitDataset[["measurements"]], check.names = FALSE)

   measurementsMatrix <- glmnet::makeX(as(measurementsTrain, "data.frame"))

   # The response variable is a Surv class of object.

-  fit <- glmnet::cv.glmnet(measurementsMatrix, splitDataset[["outcomes"]], family = "cox", type = "C", ...)

+  fit <- glmnet::cv.glmnet(measurementsMatrix, splitDataset[["outcome"]], family = "cox", type = "C", ...)

   fitted <- fit$glmnet.fit

   offset <- -mean(predict(fitted, measurementsMatrix, s = fit$lambda.min, type = "link"))

@@ -123,7 +123,7 @@ setMethod("coxnetTrainInterface", "MultiAssayExperiment",

           {

             tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, survivalTrain)

             measurementsTrain <- tablesAndClasses[["dataTable"]]

-            survivalTrain <- tablesAndClasses[["outcomes"]]

+            survivalTrain <- tablesAndClasses[["outcome"]]

             if(ncol(measurementsTrain) == 0)

               stop("No variables in data tables specified by \'targets\' are numeric.")

@@ -159,7 +159,7 @@ setMethod("coxnetPredictInterface", c("coxnet", "DataFrame"), function(model, me

 { # ... just consumes emitted tuning variables from .doTrain which are unused.

   if(!is.null(survivalTest))

   {

-    splitDataset <- .splitDataAndOutcomes(measurementsTest, survivalTest)  # Remove any classes, if present.

+    splitDataset <- .splitDataAndOutcome(measurementsTest, survivalTest)  # Remove any classes, if present.

     measurementsTest <- splitDataset[["measurements"]]

   }

@@ -82,9 +82,9 @@ setMethod("DLDAtrainInterface", "matrix", function(measurementsTrain, classesTra

 #' @export

 setMethod("DLDAtrainInterface", "DataFrame", function(measurementsTrain, classesTrain, verbose = 3)

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

   trainingMatrix <- as.matrix(splitDataset[["measurements"]]) # DLDA demands matrix input type.

-  classesTrain <- splitDataset[["outcomes"]]

+  classesTrain <- splitDataset[["outcome"]]

   #if(!requireNamespace("sparsediscrim", quietly = TRUE))

   #stop("The package 'sparsediscrim' could not be found. Please install it.")

@@ -101,7 +101,7 @@ setMethod("DLDAtrainInterface", "MultiAssayExperiment", function(measurementsTra

 {

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, classesTrain)

   measurementsTrain <- tablesAndClasses[["dataTable"]]

-  classesTrain <- tablesAndClasses[["outcomes"]]

+  classesTrain <- tablesAndClasses[["outcome"]]

   if(ncol(measurementsTrain) == 0)

     stop("No variables in data tables specified by \'targets\' are numeric.")

@@ -117,18 +117,18 @@ setMethod("elasticNetGLMtrainInterface", "DataFrame", function(measurementsTrain

   if(verbose == 3)

     message("Fitting elastic net regularised GLM classifier to data.")

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain, restrict = NULL)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain, restrict = NULL)

   measurementsTrain <- data.frame(splitDataset[["measurements"]], check.names = FALSE)

   measurementsMatrix <- glmnet::makeX(as(measurementsTrain, "data.frame"))

-  fitted <- glmnet::glmnet(measurementsMatrix, splitDataset[["outcomes"]], family = "multinomial", ...)

+  fitted <- glmnet::glmnet(measurementsMatrix, splitDataset[["outcome"]], family = "multinomial", ...)

   if(is.null(lambda)) # fitted has numerous models for automatically chosen lambda values.

   { # Pick one lambda based on resubstitution performance.

     bestLambda <- fitted[["lambda"]][which.min(sapply(fitted[["lambda"]], function(lambda) # Largest Lambda with minimum balanced error rate.

     {

       classPredictions <- factor(as.character(predict(fitted, measurementsMatrix, s = lambda, type = "class")), levels = fitted[["classnames"]])

-      calcExternalPerformance(splitDataset[["outcomes"]], classPredictions, "Balanced Error")

+      calcExternalPerformance(splitDataset[["outcome"]], classPredictions, "Balanced Error")

     }))[1]]

     attr(fitted, "tune") <- list(lambda = bestLambda)

   }

@@ -141,9 +141,9 @@ setMethod("elasticNetGLMtrainInterface", "DataFrame", function(measurementsTrain

 setMethod("elasticNetGLMtrainInterface", "MultiAssayExperiment",

 function(measurementsTrain, targets = names(measurementsTrain), classesTrain, ...)

 {

-  tablesAndOutcomes <- .MAEtoWideTable(measurementsTrain, targets, classesTrain, restrict = NULL)

-  measurementsTrain <- tablesAndOutcomes[["dataTable"]]

-  classesTrain <- tablesAndOutcomes[["outcomes"]]

+  tablesAndOutcome <- .MAEtoWideTable(measurementsTrain, targets, classesTrain, restrict = NULL)

+  measurementsTrain <- tablesAndOutcome[["dataTable"]]

+  classesTrain <- tablesAndOutcome[["outcome"]]

   if(ncol(measurementsTrain) == 0)

     stop("No variables in data tables specified by \'targets\' are numeric.")

@@ -74,9 +74,9 @@ setMethod("fisherDiscriminant", "matrix", function(measurementsTrain, classesTra

 setMethod("fisherDiscriminant", "DataFrame", # Sample information data or one of the other inputs, transformed.

           function(measurementsTrain, classesTrain, measurementsTest, returnType = c("both", "class", "score"), verbose = 3)

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

   trainingMatrix <- as.matrix(splitDataset[["measurements"]])

-  classesTrain <- splitDataset[["outcomes"]]

+  classesTrain <- splitDataset[["outcome"]]

   isNumeric <- sapply(measurementsTest, is.numeric)

   testingMatrix <- as.matrix(measurementsTest[, isNumeric, drop = FALSE])

@@ -117,7 +117,7 @@ setMethod("fisherDiscriminant", "MultiAssayExperiment", function(measurementsTra

 {

   tablesAndClasses <- .MAEtoWideTable(measurements, targets, classesTrain)

   trainingMatrix <- tablesAndClasses[["dataTable"]]

-  classesTrain <- tablesAndClasses[["outcomes"]]

+  classesTrain <- tablesAndClasses[["outcome"]]

   testingMatrix <- .MAEtoWideTable(measurementsTest, targets)

   .checkVariablesAndSame(trainingMatrix, testingMatrix)

@@ -115,9 +115,9 @@ setMethod("GLMtrainInterface", "DataFrame", function(measurementsTrain, classesT

 setMethod("GLMtrainInterface", "MultiAssayExperiment",

 function(measurementsTrain, targets = names(measurementsTrain), classesTrain, ...)

 {

-  tablesAndOutcomes <- .MAEtoWideTable(measurementsTrain, targets, classesTrain, restrict = NULL)

-  measurementsTrain <- tablesAndOutcomes[["dataTable"]]

-  classesTrain <- tablesAndOutcomes[["outcomes"]]

+  tablesAndOutcome <- .MAEtoWideTable(measurementsTrain, targets, classesTrain, restrict = NULL)

+  measurementsTrain <- tablesAndOutcome[["dataTable"]]

+  classesTrain <- tablesAndOutcome[["outcome"]]

   if(ncol(measurementsTrain) == 0)

     stop("No variables in data tables specified by \'targets\' are numeric.")

@@ -71,8 +71,8 @@ setMethod("kNNinterface", "matrix",

 #' @export

 setMethod("kNNinterface", "DataFrame", function(measurementsTrain, classesTrain, measurementsTest, ..., classifierName = "k Nearest Neighbours", verbose = 3)

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

-  classesTrain <- splitDataset[["outcomes"]]

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

+  classesTrain <- splitDataset[["outcome"]]

   trainingMatrix <- as.matrix(splitDataset[["measurements"]])

   measurementsTest <- measurementsTest[, colnames(measurementsTrain), drop = FALSE]

@@ -91,7 +91,7 @@ function(measurementsTrain, measurementsTest, targets = names(measurementsTrain)

 {

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, classesTrain)

   trainingTable <- tablesAndClasses[["dataTable"]]

-  classes <- tablesAndClasses[["outcomes"]]

+  classes <- tablesAndClasses[["outcome"]]

   testingTable <- .MAEtoWideTable(measurementsTest, targets)

   .checkVariablesAndSame(trainingTable, testingTable)

@@ -115,8 +115,8 @@ setMethod("kTSPclassifier", "DataFrame", # Sample information data or one of the

   if(!"Pairs" %in% class(featurePairs))

     stop("'featurePairs' must be of type Pairs.")            

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

-  classesTrain <- splitDataset[["outcomes"]]

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

+  classesTrain <- splitDataset[["outcome"]]

   trainingMatrix <- splitDataset[["measurements"]]

   isNumeric <- sapply(measurementsTest, is.numeric)

   testingMatrix <- as.matrix(measurementsTest[, isNumeric, drop = FALSE])

@@ -205,7 +205,7 @@ setMethod("kTSPclassifier", "MultiAssayExperiment",

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, target)

   trainingMatrix <- tablesAndClasses[["dataTable"]]

-  classes <- tablesAndClasses[["outcomes"]]

+  classes <- tablesAndClasses[["outcome"]]

   testingMatrix <- .MAEtoWideTable(measurementsTest, target)

   .checkVariablesAndSame(trainingMatrix, testingMatrix)

@@ -121,9 +121,9 @@ setMethod("mixModelsTrain", "matrix", function(measurementsTrain, ...) # Matrix

 #' @export

 setMethod("mixModelsTrain", "DataFrame", function(measurementsTrain, classesTrain, ..., verbose = 3) # Mixed data types.

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

   measurementsTrain <- splitDataset[["measurements"]]

-  classesTrain <- splitDataset[["outcomes"]]

+  classesTrain <- splitDataset[["outcome"]]

   if(verbose == 3)

     message("Fitting mixtures of normals for features.")

@@ -162,7 +162,7 @@ setMethod("mixModelsTrain", "MultiAssayExperiment", function(measurementsTrain,

 {

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, classesTrain)

   dataTable <- tablesAndClasses[["dataTable"]]

-  classesTrain <- tablesAndClasses[["outcomes"]]

+  classesTrain <- tablesAndClasses[["outcome"]]

   mixModelsTrain(dataTable, classesTrain, ...)

 })

@@ -71,9 +71,9 @@ setMethod("NSCtrainInterface", "matrix", function(measurementsTrain, classesTrai

 setMethod("NSCtrainInterface", "DataFrame", # Sample information data or one of the other inputs, transformed.

           function(measurementsTrain, classesTrain, ..., verbose = 3)

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

   measurementsTrain <- splitDataset[["measurements"]]

-  classesTrain <- splitDataset[["outcomes"]]

+  classesTrain <- splitDataset[["outcome"]]

   if(!requireNamespace("pamr", quietly = TRUE))

     stop("The package 'pamr' could not be found. Please install it.")

@@ -94,7 +94,7 @@ setMethod("NSCtrainInterface", "MultiAssayExperiment",

 { 

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, classesTrain)

   measurementsTrain <- tablesAndClasses[["dataTable"]]

-  classesTrain <- tablesAndClasses[["outcomes"]]

+  classesTrain <- tablesAndClasses[["outcome"]]

   if(ncol(measurementsTrain) == 0)

     stop("No variables in data tables specified by \'targets\' are numeric.")

@@ -184,7 +184,7 @@ setMethod("NSCpredictInterface", c("pamrtrained", "DataFrame"), function(model,

   if(!is.null(classesColumnTest)) # Remove the column, since pamr uses positional matching of features.

   {

-    splitDataset <- .splitDataAndOutcomes(measurementsTest, classesColumnTest) 

+    splitDataset <- .splitDataAndOutcome(measurementsTest, classesColumnTest) 

     measurementsTest <- splitDataset[["measurements"]] # Without classes column.

   }

@@ -122,9 +122,9 @@ setMethod("naiveBayesKernel", "DataFrame", # Sample information data or one of t

                    weighting = c("height difference", "crossover distance"),

                    minDifference = 0, returnType = c("both", "class", "score"), verbose = 3)

 {

-  splitDataset <- .splitDataAndOutcomes(measurementsTrain, classesTrain)

+  splitDataset <- .splitDataAndOutcome(measurementsTrain, classesTrain)

   trainingMatrix <- splitDataset[["measurements"]]

-  classesTrain <- splitDataset[["outcomes"]]

+  classesTrain <- splitDataset[["outcome"]]

   testingMatrix <- as.matrix(measurementsTest[, colnames(trainingMatrix), drop = FALSE])

   .checkVariablesAndSame(trainingMatrix, testingMatrix)

@@ -249,7 +249,7 @@ setMethod("naiveBayesKernel", "MultiAssayExperiment",

 {

   tablesAndClasses <- .MAEtoWideTable(measurementsTrain, targets, classesTrain)

   trainingMatrix <- tablesAndClasses[["dataTable"]]

-  classesTrain <- tablesAndClasses[["outcomes"]]

+  classesTrain <- tablesAndClasses[["outcome"]]

   testingMatrix <- .MAEtoWideTable(measurementsTest, targets)