@@ -27,6 +27,7 @@ Description: The software formalises a framework for classification in R.

 License: GPL-3

 Packaged: 2014-10-18 11:16:55 UTC; dario

 RoxygenNote: 7.2.0

+SystemRequirements: C++14

 Collate:

     'ROCplot.R'

     'available.R'

@@ -60,6 +61,7 @@ Collate:

     'interfaceSVM.R'

     'performancePlot.R'

     'plotFeatureClasses.R'

+    'prepareData.R'

     'previousSelection.R'

     'previousTrained.R'

     'rankingBartlett.R'

deleted file mode 100644

@@ -1,187 +0,0 @@

-# Generated by roxygen2: do not edit by hand

-

-export(ClassifyResult)

-export(CrossValParams)

-export(DLDApredictInterface)

-export(DLDAtrainInterface)

-export(DMDranking)

-export(FeatureSetCollection)

-export(GLMpredictInterface)

-export(GLMtrainInterface)

-export(KolmogorovSmirnovRanking)

-export(KullbackLeiblerRanking)

-export(ModellingParams)

-export(NSCfeatures)

-export(NSCpredictInterface)

-export(NSCtrainInterface)

-export(PredictParams)

-export(ROCplot)

-export(SVMpredictInterface)

-export(SVMtrainInterface)

-export(SelectParams)

-export(TrainParams)

-export(TransformParams)

-export(actualOutcome)

-export(available)

-export(bartlettRanking)

-export(calcCVperformance)

-export(calcExternalPerformance)

-export(chosenFeatureNames)

-export(classifyInterface)

-export(coxnetPredictInterface)

-export(coxnetTrainInterface)

-export(coxphPredictInterface)

-export(coxphRanking)

-export(coxphTrainInterface)

-export(crossValidate)

-export(differentMeansRanking)

-export(distribution)

-export(edgeRranking)

-export(edgesToHubNetworks)

-export(elasticNetFeatures)

-export(elasticNetGLMpredictInterface)

-export(elasticNetGLMtrainInterface)

-export(featureSetSummary)

-export(featuresInfo)

-export(fisherDiscriminant)

-export(forestFeatures)

-export(generateCrossValParams)

-export(generateModellingParams)

-export(getLocationsAndScales)

-export(interactorDifferences)

-export(kNNinterface)

-export(kTSPclassifier)

-export(leveneRanking)

-export(likelihoodRatioRanking)

-export(limmaRanking)

-export(mixModelsPredict)

-export(mixModelsTrain)

-export(models)

-export(naiveBayesKernel)

-export(pairsDifferencesRanking)

-export(performance)

-export(performancePlot)

-export(plotFeatureClasses)

-export(predictions)

-export(previousSelection)

-export(previousTrained)

-export(randomForestPredictInterface)

-export(randomForestTrainInterface)

-export(rankingPlot)

-export(rfsrcPredictInterface)

-export(rfsrcTrainInterface)

-export(runTest)

-export(runTests)

-export(sampleNames)

-export(samplesMetricMap)

-export(selectionPlot)

-export(subtractFromLocation)

-export(totalPredictions)

-export(tunedParameters)

-exportClasses(ClassifyResult)

-exportClasses(CrossValParams)

-exportClasses(FeatureSetCollection)

-exportClasses(ModellingParams)

-exportClasses(PredictParams)

-exportClasses(SelectParams)

-exportClasses(TrainParams)

-exportClasses(TransformParams)

-exportMethods("[")

-exportMethods("[[")

-exportMethods(ClassifyResult)

-exportMethods(DLDApredictInterface)

-exportMethods(DLDAtrainInterface)

-exportMethods(DMDranking)

-exportMethods(FeatureSetCollection)

-exportMethods(GLMpredictInterface)

-exportMethods(GLMtrainInterface)

-exportMethods(KolmogorovSmirnovRanking)

-exportMethods(KullbackLeiblerRanking)

-exportMethods(NSCfeatures)

-exportMethods(NSCpredictInterface)

-exportMethods(NSCtrainInterface)

-exportMethods(PredictParams)

-exportMethods(ROCplot)

-exportMethods(SVMpredictInterface)

-exportMethods(SVMtrainInterface)

-exportMethods(SelectParams)

-exportMethods(TrainParams)

-exportMethods(TransformParams)

-exportMethods(actualOutcome)

-exportMethods(bartlettRanking)

-exportMethods(calcCVperformance)

-exportMethods(calcExternalPerformance)

-exportMethods(chosenFeatureNames)

-exportMethods(classifyInterface)

-exportMethods(coxnetPredictInterface)

-exportMethods(coxnetTrainInterface)

-exportMethods(coxphPredictInterface)

-exportMethods(coxphRanking)

-exportMethods(coxphTrainInterface)

-exportMethods(crossValidate)

-exportMethods(differentMeansRanking)

-exportMethods(distribution)

-exportMethods(edgeRranking)

-exportMethods(elasticNetFeatures)

-exportMethods(elasticNetGLMpredictInterface)

-exportMethods(elasticNetGLMtrainInterface)

-exportMethods(featureSetSummary)

-exportMethods(featuresInfo)

-exportMethods(fisherDiscriminant)

-exportMethods(forestFeatures)

-exportMethods(getLocationsAndScales)

-exportMethods(interactorDifferences)

-exportMethods(kNNinterface)

-exportMethods(kTSPclassifier)

-exportMethods(length)

-exportMethods(leveneRanking)

-exportMethods(likelihoodRatioRanking)

-exportMethods(limmaRanking)

-exportMethods(mixModelsPredict)

-exportMethods(mixModelsTrain)

-exportMethods(models)

-exportMethods(naiveBayesKernel)

-exportMethods(pairsDifferencesRanking)

-exportMethods(performance)

-exportMethods(performancePlot)

-exportMethods(plotFeatureClasses)

-exportMethods(predict)

-exportMethods(predictions)

-exportMethods(previousSelection)

-exportMethods(previousTrained)

-exportMethods(randomForestPredictInterface)

-exportMethods(randomForestTrainInterface)

-exportMethods(rankingPlot)

-exportMethods(rfsrcPredictInterface)

-exportMethods(rfsrcTrainInterface)

-exportMethods(runTest)

-exportMethods(runTests)

-exportMethods(sampleNames)

-exportMethods(samplesMetricMap)

-exportMethods(selectionPlot)

-exportMethods(show)

-exportMethods(subtractFromLocation)

-exportMethods(totalPredictions)

-exportMethods(tunedParameters)

-import(BiocParallel)

-import(grid)

-import(methods)

-import(stats)

-import(utils)

-importFrom(MultiAssayExperiment,colData)

-importFrom(MultiAssayExperiment,wideFormat)

-importFrom(S4Vectors,as.data.frame)

-importFrom(S4Vectors,do.call)

-importFrom(S4Vectors,mcols)

-importFrom(dplyr,mutate)

-importFrom(dplyr,n)

-importFrom(genefilter,rowFtests)

-importFrom(genefilter,rowttests)

-importFrom(randomForest,importance)

-importFrom(randomForest,varUsed)

-importFrom(rlang,sym)

-importFrom(survival,Surv)

-importFrom(survival,concordance)

-importFrom(survival,coxph)

-importFrom(tidyr,gather)

-useDynLib(ClassifyR, .registration = TRUE)

@@ -59,9 +59,7 @@

 #'   actual <- factor(c(rep("Healthy", 10), rep("Cancer", 10)), levels = c("Healthy", "Cancer"))

 #'   result1 <- ClassifyResult(DataFrame(characteristic = c("Data Set", "Selection Name", "Classifier Name", "Cross-validation"),

 #'                             value = c("Melanoma", "t-test", "Random Forest", "2-fold")),

-#'                             LETTERS[1:20], DataFrame(`Original Feature` = paste("Gene", LETTERS[1:10]),

-#'                             `Renamed Feature` = paste("Feature", 1:10, sep = ''), check.names = FALSE),

-#'                             list(paste("Gene", LETTERS[1:10]), paste("Gene", LETTERS[c(5:1, 6:10)])),

+#'                             LETTERS[1:20], list(paste("Gene", LETTERS[1:10]), paste("Gene", LETTERS[c(5:1, 6:10)])),

 #'                             list(paste("Gene", LETTERS[1:3]), paste("Gene", LETTERS[1:5])),

 #'                             list(function(oracle){}), NULL, predicted, actual)

 #'   

@@ -69,9 +67,7 @@

 #'   predicted[c(2, 6), "Cancer"] <- c(0.60, 0.40)

 #'   result2 <- ClassifyResult(DataFrame(characteristic = c("Data Set", "Selection Name", "Classifier Name", "Cross-validation"),

 #'                                       value = c("Example", "Bartlett Test", "Differential Variability", "2-fold")),

-#'                             LETTERS[1:20], DataFrame(`Original Feature` = paste("Gene", LETTERS[1:10]),

-#'                             `Renamed Feature` = paste("Feature", 1:10, sep = ''), check.names = FALSE),

-#'                             list(paste("Gene", LETTERS[1:10]), paste("Gene", LETTERS[c(5:1, 6:10)])),

+#'                             LETTERS[1:20], list(paste("Gene", LETTERS[1:10]), paste("Gene", LETTERS[c(5:1, 6:10)])),

 #'                             list(paste("Gene", LETTERS[1:3]), paste("Gene", LETTERS[1:5])),

 #'                             list(function(oracle){}), NULL, predicted, actual)

 #'   ROCplot(list(result1, result2), plotTitle = "Cancer ROC")

@@ -75,9 +75,7 @@

 #'                             class = factor(sample(LETTERS[1:2], 50, replace = TRUE)))

 #'   actual <- factor(sample(LETTERS[1:2], 10, replace = TRUE))                             

 #'   result <- ClassifyResult(DataFrame(characteristic = "Data Set", value = "Example"),

-#'                            paste("A", 1:10, sep = ''), DataFrame(`Original Feature` = paste("Gene", 1:50),

-#'                            `Renamed Feature` = paste("Feature", 1:50, sep = '')),

-#'                            list(paste("Gene", 1:50), paste("Gene", 1:50)), list(paste("Gene", 1:5), paste("Gene", 1:10)),

+#'                            paste("A", 1:10, sep = ''), list(paste("Gene", 1:50), paste("Gene", 1:50)), list(paste("Gene", 1:5), paste("Gene", 1:10)),

 #'                            list(function(oracle){}), NULL, predictTable, actual)

 #'   result <- calcCVperformance(result) 

 #'   performance(result)

@@ -462,7 +462,7 @@ setMethod("TransformParams", "function",

           {

             if(ncol(characteristics) == 0 || !"Transform Name" %in% characteristics[, "characteristic"])

             {

-              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Transform Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == transform@generic, "name"]))

+              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Transform Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == attr(transform, "name"), "name"]))

             }

             new("TransformParams", transform = transform, characteristics = characteristics,

                 intermediate = intermediate, otherParams = list(...))

@@ -829,11 +829,11 @@ setMethod("SelectParams", c("functionOrList"),

           {

             if(!is.list(featureRanking) && (ncol(characteristics) == 0 || !"Selection Name" %in% characteristics[, "characteristic"]))

             {

-              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Selection Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == featureRanking@generic, "name"]))

+              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Selection Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == attr(featureRanking, "name"), "name"]))

             }

             if(is.list(featureRanking) && (ncol(characteristics) == 0 || !"Ensemble Selection" %in% characteristics[, "characteristic"]))

             {

-              selectMethodNames <- unlist(lapply(featureRanking, function(rankingFunction) .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == rankingFunction@generic, "name"]))

+              selectMethodNames <- unlist(lapply(featureRanking, function(rankingFunction) .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == attr(rankingFunction, "name"), "name"]))

               characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Ensemble Selection", value = paste(selectMethodNames, collapse = ", ")))

             }

             others <- list(...)

@@ -966,7 +966,7 @@ setMethod("TrainParams", c("function"),

           {

             if(ncol(characteristics) == 0 || !"Classifier Name" %in% characteristics[, "characteristic"])

             {

-              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Classifier Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == classifier@generic, "name"]))

+              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Classifier Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == attr(classifier, "name"), "name"]))

             }

             new("TrainParams", classifier = classifier, characteristics = characteristics,

                 intermediate = intermediate, getFeatures = getFeatures, tuneParams = tuneParams,

@@ -991,15 +991,8 @@ setMethod("show", "TrainParams",

                 cat(otherInfo[rowIndex, "characteristic"], ": ", otherInfo[rowIndex, "value"], ".\n", sep = '')

               }

             }

-

-            if(!is.null(object@getFeatures))

-              cat("Selected Features Extracted By: ", object@getFeatures@generic, ".\n", sep = '')

           })

-

-

-

-

 ##### PredictParams #####

 #' @exportClass PredictParams

@@ -1082,10 +1075,6 @@ setMethod("PredictParams", c("functionOrNULL"),

           {

             if(missing(predictor))

               stop("Either a function or NULL must be specified by 'predictor'.")

-            if(!is.null(predictor) && (ncol(characteristics) == 0 || !"Predictor Name" %in% characteristics[, "characteristic"]))

-            {

-              characteristics <- rbind(characteristics, S4Vectors::DataFrame(characteristic = "Predictor Name", value = .ClassifyRenvir[["functionsTable"]][.ClassifyRenvir[["functionsTable"]][, "character"] == predictor@generic, "name"]))

-            }

             others <- list(...)

             if(length(others) == 0) others <- NULL

             new("PredictParams", predictor = predictor, characteristics = characteristics,

@@ -1227,7 +1216,6 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' @aliases ClassifyResult ClassifyResult-class

 #' ClassifyResult,DataFrame,character,characterOrDataFrame-method

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

-#' featuresInfo featuresInfo,ClassifyResult-method

 #' predictions predictions,ClassifyResult-method actualOutcome

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

 #' models models,ClassifyResult-method performance

@@ -1247,10 +1235,9 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' package, the function names will automatically be generated and therefore it

 #' is not necessary to specify them.}

 #' \item{\code{originalNames}}{All sample names.}

-#' \item{\code{featuresInfo}}{A \code{\link{DataFrame}} containing all feature names in original format

-#' and a safe format without any unusual symbols that R would automatically convert into another format and cause trouble.}

-#' \item{\code{rankedFeatures}}{All features, from most to least important. Character vector

-#' or a data frame if data set has multiple kinds of measurements on the same set of samples.}

+#' \item{\code{originalFeatures}}{All feature names. Character vector

+#' or \code{\link{DataFrame}} with one row for each feature if the data set has multiple kinds

+#' of measurements on the same set of samples.}

 #' \item{\code{chosenFeatures}}{Features selected at each fold. Character

 #' vector or a data frame if data set has multiple kinds of measurements on the same set of samples.}

 #' \item{\code{models}}{All of the models fitted to the training data.}

@@ -1276,8 +1263,6 @@ setClassUnion("ModellingParamsOrNULL", c("ModellingParams", "NULL"))

 #' \describe{

 #' \item{\code{sampleNames(result)}}{Returns a vector of sample names present in the data set.}}

 #' \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{actualOutcome(result)}}{Returns the known outcome of each sample.}}

 #' \describe{

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

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

 #' @importFrom S4Vectors as.data.frame

 #' @usage NULL

 #' @export

-setGeneric("ClassifyResult", function(characteristics, originalNames, featuresInfo, ...)

+setGeneric("ClassifyResult", function(characteristics, originalNames, ...)

 standardGeneric("ClassifyResult"))

 #' @rdname ClassifyResult-class

@@ -1325,7 +1310,7 @@ standardGeneric("ClassifyResult"))

 setClass("ClassifyResult", representation(

   characteristics = "DataFrame",

   originalNames = "character",

-  featuresInfo = "DataFrame",

+  originalFeatures = "characterOrDataFrame",    

   rankedFeatures = "listOrNULL",

   chosenFeatures = "listOrNULL",

   actualOutcome = "factorOrSurv",

@@ -1340,12 +1325,11 @@ setClass("ClassifyResult", representation(

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

-          function(characteristics, originalNames, featuresInfo,

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

+          function(characteristics, originalNames, originalFeatures,

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

           {

-            new("ClassifyResult", characteristics = characteristics,

-                originalNames = originalNames, featuresInfo = featuresInfo,

+            new("ClassifyResult", characteristics = characteristics, originalNames = originalNames, originalFeatures = originalFeatures,

                 rankedFeatures = rankedFeatures, chosenFeatures = chosenFeatures,

                 models = models, tune = tunedParameters,

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

@@ -1383,7 +1367,7 @@ standardGeneric("sampleNames"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("sampleNames", "ClassifyResult",

           function(object)

           {

             object@originalNames

@@ -1392,16 +1376,16 @@ setMethod("sampleNames", c("ClassifyResult"),

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

-standardGeneric("featuresInfo"))

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

+standardGeneric("allFeatureNames"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

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

           function(object)

           {

-            object@featuresInfo

+            object@originalFeatures

           })

 #' @rdname ClassifyResult-class

@@ -1413,7 +1397,7 @@ standardGeneric("chosenFeatureNames"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("chosenFeatureNames", "ClassifyResult",

           function(object)

           {

             object@chosenFeatures

@@ -1427,7 +1411,7 @@ standardGeneric("models"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("models", "ClassifyResult",

           function(object)

           {

             object@models

@@ -1441,7 +1425,7 @@ standardGeneric("predictions"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("predictions", "ClassifyResult",

           function(object)

           {

             object@predictions

@@ -1455,7 +1439,7 @@ standardGeneric("performance"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("performance", "ClassifyResult",

           function(object)

           {

             object@performance

@@ -1469,7 +1453,7 @@ standardGeneric("actualOutcome"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("actualOutcome", "ClassifyResult",

           function(object)

           {

             object@actualOutcome

@@ -1496,7 +1480,7 @@ standardGeneric("totalPredictions"))

 #' @rdname ClassifyResult-class

 #' @usage NULL

 #' @export

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

+setMethod("totalPredictions", "ClassifyResult",

           function(result)

           {

               nrow(predictions(result))

@@ -24,13 +24,10 @@

     "classifyInterface", "Poisson LDA",

     "differentMeansRanking", "Difference in Means",

     "DLDAtrainInterface", "Diagonal LDA",

-    "DLDApredictInterface", "Diagonal LDA",

     "DMDranking", "Differences of Medians and Deviations",

     "edgeRranking", "edgeR LRT",

     "GLMtrainInterface", "Logistic Regression",

-    "GLMpredictInterface", "Logistic Regression",

     "elasticNetGLMtrainInterface", "Elastic Net GLM",

-    "elasticNetGLMpredictInterface", "Elastic Net GLM",

     "fisherDiscriminant", "Fisher's LDA",

     "kNNinterface", "k Nearest Neighbours",

     "KolmogorovSmirnovRanking", "Kolmogorov-Smirnov Test",

@@ -40,27 +37,19 @@

     "likelihoodRatioRanking", "Likelihood Ratio Test (Normal)",

     "limmaRanking", "Moderated t-test",

     "mixModelsTrain", "Mixtures of Normals",

-    "mixModelsPredict", "Mixtures of Normals",

     "naiveBayesKernel", "Naive Bayes Kernel",

     "NSCtrainInterface",  "Nearest Shrunken Centroids",

-    "NSCpredictInterface", "Nearest Shrunken Centroids",

     "pairsDifferencesRanking", "Pairs Differences",

     "previousSelection", "Previous Selection", 

     "previousTrained", "Previous Trained",

     "randomForestTrainInterface", "Random Forest",

-    "randomForestPredictInterface", "Random Forest",

     "subtractFromLocation", "Location Subtraction",

     "SVMtrainInterface", "Support Vector Machine",

-    "SVMpredictInterface", "Support Vector Machine",

     "coxphTrainInterface", "Cox Proportional Hazards",

-    "coxphPredictInterface", "Cox Proportional Hazards",

     "coxphRanking", "Cox Proportional Hazards",

     "coxnetTrainInterface", "Penalised Cox Proportional Hazards",

-    "coxnetPredictInterface", "Penalised Cox Proportional Hazards",

     #"NEMOEtrainInterface", "Nutrition-Ecotype Mixture of Experts",

-    #"NEMOEpredictInterface", "Nutrition-Ecotype Mixture of Experts",

-    "rfsrcTrainInterface", "Random Survival Forest",

-    "rfsrcPredictInterface", "Random Survival Forest"),

+    "rfsrcTrainInterface", "Random Survival Forest"),

   ncol = 2, byrow = TRUE, dimnames = list(NULL, c("character", "name"))

 ) |> as.data.frame()

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

 #' 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 outcome in the generic.

+#' @param ... Parameters passed into \code{\link{prepareData}}.

 #' @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. 

@@ -95,18 +95,21 @@ setMethod("crossValidate", "DataFrame",

                    nFolds = 5,

                    nRepeats = 20,

                    nCores = 1,

-                   characteristicsLabel = NULL)

+                   characteristicsLabel = NULL, ...)

           {

-              # Check that data is in the right format

-              splitAssay <- .splitDataAndOutcome(measurements, outcome)

-              measurements <- splitAssay[["measurements"]]

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

+              # Check that data is in the right format, if not already done for MultiAssayExperiment input.

+              if(is.null(mcols(measurements)$assay))

+              {

+                splitAssay <- prepareData(measurements, outcome, ...)

+                measurements <- splitAssay[["measurements"]]

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

+              }

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

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

-              if(is.null(assayIDs))

-                assayIDs <- 1

+              if(!is.null(characteristicsLabel)) assayIDs <- characteristicsLabel

+              if(is.null(assayIDs)) assayIDs <- 1

               checkData(measurements, outcome)

@@ -303,8 +306,8 @@ setMethod("crossValidate", "MultiAssayExperiment",

                    nCores = 1,

                    characteristicsLabel = NULL)

           {

-              targets <- c(names(measurements), "sampleInfo")

-              omicsTargets <- setdiff(targets, "sampleInfo")  

+              targets <- c(names(measurements), "clinical")

+              omicsTargets <- setdiff(targets, "clinical")  

               if(length(omicsTargets) > 0)

               {

                   if(any(anyReplicated(measurements[, , omicsTargets])))

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

       allFeaturesText <- allFeatures

     } else if(is(chosenFeatures[[1]], "DataFrame")) {

       allFeatures <- do.call(rbind, chosenFeatures)

-      allFeaturesText <- paste(allFeatures[, "Original Assay"], allFeatures[, "Original Feature"], sep = ':')

+      allFeaturesText <- paste(allFeatures[, "assay"], allFeatures[, "feature"], sep = ':')

     } else if("Pairs" %in% class(chosenFeatures[[1]])) {

       allFeatures <- do.call(c, unname(chosenFeatures))

       allFeaturesText <- paste(first(allFeatures), second(allFeatures), sep = ', ')

@@ -14,8 +14,8 @@

 #' If of type \code{\link{DataFrame}} or \code{\link{MultiAssayExperiment}}, the data set is subset

 #' to only those features of type \code{numeric}.

 #' @param targets If \code{measurements} is a \code{MultiAssayExperiment}, the

-#' names of the data tables to be used. \code{"sampleInfo"} is also a valid value

-#' and specifies that numeric variables from the sample information data table will be

+#' names of the data tables to be used. \code{"clinical"} is also a valid value

+#' and specifies that numeric variables from the clinical data table will be

 #' used.

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

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

@@ -74,17 +74,17 @@ setMethod("getLocationsAndScales", "DataFrame", # Sample information data or one

                 c(location, scale))

 })

-# One or more omics data sets, possibly with sample information data.

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

 #' @rdname getLocationsAndScales

 #' @export

 setMethod("getLocationsAndScales", "MultiAssayExperiment",

           function(measurements, targets = names(measurements), ...)

 {

-  if(!all(targets %in% c(names(measurements), "sampleInfo")))

-    stop("Some table names in 'targets' are not assay names in 'measurements' or \"sampleInfo\".")  

+  if(!all(targets %in% c(names(measurements), "clinical")))

+    stop("Some table names in 'targets' are not assay names in 'measurements' or \"clinical\".")  

   combinedData <- .MAEtoWideTable(measurements, targets, NULL)

   if(class(combinedData) == "list")

     combinedData <- combinedData[["dataTable"]]

   getLocationsAndScales(combinedData, ...)            

-})

\ No newline at end of file

+})

@@ -1,94 +1,12 @@

-#' An Interface for PoiClaClu Package's Classify Function

-#' 

-#' More details of Poisson LDA are available in the documentation of

-#' \code{\link[PoiClaClu]{Classify}}. Data tables which consist entirely of

-#' non-integer data cannot be analysed.

-#' 

-#' @aliases classifyInterface classifyInterface,matrix-method

-#' classifyInterface,DataFrame-method

-#' classifyInterface,MultiAssayExperiment-method

-#' @param countsTrain Either a \code{\link{matrix}}, \code{\link{DataFrame}}

-#' or \code{\link{MultiAssayExperiment}} containing the training data. For a

-#' \code{matrix} or \code{\link{DataFrame}}, the rows are samples, and the columns are features.

-#' If of type \code{\link{DataFrame}} or \code{\link{MultiAssayExperiment}}, the data set is subset

-#' to only those features of type \code{numeric}.

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

-#' same length as the number of samples in \code{countsTrain} if it is a

-#' \code{\link{matrix}} or a \code{\link{DataFrame}} or a character vector of length 1

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

-#' column name in \code{colData(countsTrain)} if \code{countsTrain} is a

-#' \code{\link{MultiAssayExperiment}}. If a column name, that column will be

-#' removed before training.

-#' @param countsTest An object of the same class as \code{countsTrain} with no

-#' samples in common with \code{countsTrain} and the same number of features

-#' as it.

-#' @param targets If \code{countsTrain} is a \code{MultiAssayExperiment}, the

-#' names of the data tables to be used. \code{"sampleInfo"} is also a valid value

-#' and specifies that integer variables from the sample information table will be

-#' used.

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

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

-#' \code{DataFrame} method or parameters that \code{\link[PoiClaClu]{Classify}}

-#' can accept.

-#' @param returnType Default: \code{"both"}. Either \code{"class"},

-#' \code{"score"} or \code{"both"}.  Sets the return value from the prediction

-#' to either a vector of class labels, matrix of scores for each class, or both

-#' labels and scores in a \code{data.frame}.

-#' @param verbose Default: 3. A number between 0 and 3 for the amount of

-#' progress messages to give.  This function only prints progress messages if

-#' the value is 3.

-#' @return Either a factor vector of predicted classes, a matrix of scores for

-#' each class, or a table of both the class labels and class scores, depending

-#' on the setting of \code{returnType}.

-#' @author Dario Strbenac

-#' @examples

-#' 

-#'   if(require(PoiClaClu))

-#'   {

-#'     readCounts <- CountDataSet(n = 100, p = 1000, 2, 5, 0.1)

-#'     # Rows are for features, columns are for samples.

-#'     trainData <- readCounts[['x']]

-#'     trainClasses <- factor(paste("Class", readCounts[['y']]))

-#'     testData <- readCounts[['xte']]

-#'     storage.mode(trainData) <- storage.mode(testData) <- "integer"

-#'     classified <- classifyInterface(trainData, trainClasses, testData)

-#'     

-#'     setNames(table(paste("Class", readCounts[["yte"]]) == classified), c("Incorrect", "Correct"))

-#'   }

-#'   

-#' @usage NULL

-#' @export

-setGeneric("classifyInterface", function(countsTrain, ...)

-standardGeneric("classifyInterface"))

+# An Interface for PoiClaClu Package's Classify Function. Poisson LDA for counts.

-#' @rdname classifyInterface

-#' @export

-setMethod("classifyInterface", "matrix", # Matrix of integer measurements.

-          function(countsTrain, classesTrain, countsTest, ...)

-{

-  classifyInterface(S4Vectors::DataFrame(countsTrain, check.names = FALSE),

-                    classesTrain,

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

-})

-

-# Sample information data or one of the other inputs, transformed.

-#' @rdname classifyInterface

-#' @export

-setMethod("classifyInterface", "DataFrame", function(countsTrain, classesTrain, countsTest, ...,

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

+classifyInterface <- function(countsTrain, classesTrain, countsTest, ...,

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

 {

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

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

   returnType <- match.arg(returnType)

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

-  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])

-  .checkVariablesAndSame(trainingMatrix, testingMatrix)

-  

   if(verbose == 3)

     message("Fitting Poisson LDA classifier to training data and making predictions on test data.")

@@ -99,18 +17,5 @@ setMethod("classifyInterface", "DataFrame", function(countsTrain, classesTrain,

   switch(returnType, class = classPredictions, # Factor vector.

          score = classScores, # Numeric matrix.

          both = data.frame(class = classPredictions, classScores, check.names = FALSE))

-})

-

-#' @rdname classifyInterface

-#' @export

-setMethod("classifyInterface", "MultiAssayExperiment",

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

-{

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

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

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

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

-            

-  .checkVariablesAndSame(trainingMatrix, testingMatrix)

-  classifyInterface(trainingMatrix, classesTrain, testingMatrix, ...)

-})

\ No newline at end of file

+}

+attr(classifyInterface, "name") <- "classifyInterface"

\ No newline at end of file

@@ -1,151 +1,18 @@

-################################################################################

-#

-# Train interface

-#

-################################################################################

-

-

-#' An Interface for survival Package's coxph Function

-#' 

-#' Cox proportional hazards.

-#' 

-#' @aliases coxphInterface coxphTrainInterface coxphPredictInterface

-#' coxphInterface,matrix-method

-#' coxphInterface,DataFrame-method

-#' coxphInterface,MultiAssayExperiment-method

-#' coxphPredictInterface

-#' coxphPredictInterface,coxph,matrix-method

-#' coxphPredictInterface,coxph,DataFrame-method

-#' coxphPredictInterface,coxph,MultiAssayExperiment-method

-#' @param measurementsTrain Either a \code{\link{matrix}}, \code{\link{DataFrame}}

-#' or \code{\link{MultiAssayExperiment}} containing the training data.  For a

-#' \code{matrix} or \code{\link{DataFrame}}, the rows are samples, and the columns are features.

-#' @param survivalTrain A tabular data type of survival information of the

-#' same number of rows as the number of samples in \code{measurementsTrain} and 2 to 3 columns if it is a

-#' \code{\link{matrix}} or a \code{\link{DataFrame}}, or a character vector of length 2 to 3 containing the

-#' column names in \code{measurementsTrain} if it is a \code{\link{DataFrame}} or the

-#' column name in \code{colData(measurementsTrain)} if \code{measurementsTrain} is a

-#' \code{\link{MultiAssayExperiment}}. If a vector of column names, those columns will be

-#' removed before training.

-#' @param model A trained coxph classifier, as created by

-#' \code{coxphTrainInterface}, which has the same form as the output of

-#' \code{\link[survival]{coxph}}.

-#' @param measurementsTest An object of the same class as \code{measurementsTrain} with no

-#' samples in common with \code{measurementsTrain} and the same number of features

-#' as it.

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

-#' names of the data tables to be used. \code{"sampleInfo"} is also a valid value

-#' and specifies that integer variables from the clinical data table will be

-#' used.

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

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

-#' \code{DataFrame} method (e.g. \code{verbose}) or options which are accepted

-#' by the \code{\link[survival]{coxph}} or \code{\link[survival]{predict.coxph}} functions.

-#' @param verbose Default: 3. A number between 0 and 3 for the amount of

-#' progress messages to give.  This function only prints progress messages if

-#' the value is 3.

-#' @return For \code{coxphTrainInterface}, the trained Cox proportional hazards model.

-#' For \code{coxphPredictInterface}, a risk score prediction for each sample.

-#' @examples

-#' #' 

-#'   # if(require(randomForest))

-#'   # {

-#'   #   # Genes 76 to 100 have differential expression.

-#'   #   genesMatrix <- sapply(1:25, function(sample) c(rnorm(100, 9, 2)))

-#'   #   genesMatrix <- cbind(genesMatrix, sapply(1:25, function(sample)

-#'   #                                     c(rnorm(75, 9, 2), rnorm(25, 14, 2))))

-#'   #   classes <- factor(rep(c("Poor", "Good"), each = 25))

-#'   #   colnames(genesMatrix) <- paste("Sample", 1:ncol(genesMatrix), sep = ' ')

-#'   #   rownames(genesMatrix) <- paste("Gene", 1:nrow(genesMatrix), sep = '-')

-#'   #   trainingSamples <- c(1:20, 26:45)

-#'   #   testingSamples <- c(21:25, 46:50)

-#'   # 

-#'   #   trained <- randomForestTrainInterface(genesMatrix[, trainingSamples],

-#'   #                                         classes[trainingSamples])

-#'   #   predicted <- randomForestPredictInterface(trained, genesMatrix[, testingSamples])

-#'   # }

-#' 

-#' @importFrom survival coxph concordance

-#' @rdname coxphInterface

-#' @usage NULL

-#' @export

-setGeneric("coxphTrainInterface", function(measurementsTrain, ...) standardGeneric("coxphTrainInterface"))

-

-#' @rdname coxphInterface

-#' @export

-setMethod("coxphTrainInterface", "matrix", function(measurementsTrain, survivalTrain, ...)

-{

-  coxphTrainInterface(S4Vectors::DataFrame(measurementsTrain, check.names = FALSE), survivalTrain, ...)

-})

-

-# Clinical data or one of the other inputs, transformed.

-#' @rdname coxphInterface

-#' @export

-setMethod("coxphTrainInterface", "DataFrame", function(measurementsTrain, survivalTrain, ..., verbose = 3)

+# An Interface for survival Package's coxph Function. The standard Cox proportional hazards.

+coxphTrainInterface <- function(measurementsTrain, survivalTrain, ..., verbose = 3)

 {

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

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

   if(verbose == 3)

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

             data.")

-

-  splitDataset <- .splitDataAndOutcome(measurementsTrain, survivalTrain)  

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

-  measurementsTrain <- splitDataset[["measurements"]]

   survival::coxph(survivalTrain ~ ., measurementsTrain)

-})

-

-#' @rdname coxphInterface

-#' @export

-setMethod("coxphTrainInterface", "MultiAssayExperiment", function(measurementsTrain, targets = names(measurementsTrain), survivalTrain, ...)

-{

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

-  measurementsTrain <- tablesAndSurvival[["dataTable"]]

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

-  

-  coxphTrainInterface(measurementsTrain, survivalTrain, ...)

-})

-

+}

+attr(coxphTrainInterface, "name") <- "coxphTrainInterface"

-

-################################################################################

-#

-# Predict Interface

-#

-################################################################################

-

-

-#' @rdname coxphInterface

-#' @usage NULL

-#' @export

-setGeneric("coxphPredictInterface", function(model, measurementsTest, ...)

-  standardGeneric("coxphPredictInterface"))

-

-#' @rdname coxphInterface

-#' @export

-setMethod("coxphPredictInterface", c("coxph", "matrix"), # Matrix of numeric measurements.

-          function(model, measurementsTest, ...)

-{

-  coxphPredictInterface(model, S4Vectors::DataFrame(measurementsTest, check.names = FALSE), ...)

-})

-

-#' @rdname coxphInterface

-#' @export

-setMethod("coxphPredictInterface", c("coxph", "DataFrame"),

-function(model, measurementsTest, ..., verbose = 3)