fastmatch

DESCRIPTION

@@ -19,8 +19,10 @@ BugReports: https://github.com/berndbischl/ParamHelpers/issues
 License: BSD_2_clause + file LICENSE
 Roxygen: list(wrap = FALSE)
 Imports:
+    backports,
     BBmisc (>= 1.10),
     checkmate (>= 1.8.1),
+    fastmatch,
     methods
 Suggests:
     akima,
@@ -38,4 +40,4 @@ Suggests:
 LazyData: yes
 ByteCompile: yes
 Version: 1.10
-RoxygenNote: 5.0.1
+RoxygenNote: 6.0.1

NAMESPACE

@@ -177,9 +177,12 @@ export(trafoOptPath)
 export(trafoValue)
 export(updateParVals)
 import(BBmisc)
+import(backports)
 import(checkmate)
 import(methods)
 import(stats)
+importFrom(fastmatch,"%fin%")
+importFrom(fastmatch,fmatch)
 useDynLib(ParamHelpers,c_dfRowsToList)
 useDynLib(ParamHelpers,c_generateDesign)
 useDynLib(ParamHelpers,c_trafo_and_set_dep_to_na)

R/convertTypesToCInts.R

@@ -1,5 +1,4 @@
 # integer encoding of types for easier use
 convertTypesToCInts = function(types) {
-  nlookup = c("numeric", "integer", "factor", "logical", "character")
-  match(types, nlookup, nomatch = 99L)
+  fmatch(types, ph$convert.to.ctypes, nomatch = 99L)
 }

R/getParamTypes.R

@@ -34,35 +34,20 @@ getParamTypes = function(par.set, df.cols = FALSE, df.discretes.as.factor = TRUE
   if (length(types) == 0L)
     return(character(0L))
 
-  recode = function(types, ...) {
-    args = as.character(list(...))
-    for (i in seq(1, length(args), 2)) {
-      types[types == args[i]] = args[i + 1]
-    }
-    types = rep(types, getParamLengths(par.set))
-    return(types)
+  recode = function(types, from, to) {
+    i = fmatch(types, from, nomatch = 0L)
+    types[i > 0L] = to[i]
+    rep(types, getParamLengths(par.set))
   }
 
+
   if (df.cols) {
-    types = if (df.discretes.as.factor) {
-      recode(types,
-        "numericvector", "numeric",
-        "integervector", "integer",
-        "discrete", "factor",
-        "discretevector", "factor",
-        "logicalvector", "logical",
-        "charactervector", "character"
-      )
+    to = if (df.discretes.as.factor) {
+      c("numeric", "integer", "factor", "factor", "logical", "character")
     } else {
-      recode(types,
-        "numericvector", "numeric",
-        "integervector", "integer",
-        "discrete", "character",
-        "discretevector", "character",
-        "logicalvector", "logical",
-        "charactervector", "character"
-      )
+      c("numeric", "integer",  "character", "character", "logical","character")
     }
+    types = recode(types, ph$convert.param.types.from, to)
   }
 
   ns = if (use.names)

R/hasType.R

@@ -23,21 +23,21 @@ hasDiscrete = function(par.set, include.logical = TRUE) {
 #' @rdname hasType
 hasInteger = function(par.set) {
   assertClass(par.set, "ParamSet")
-  return(hasSomeParamsOfTypes(par.set, types = c("integer", "integervector")))
+  hasSomeParamsOfTypes(par.set, types = getTypeStringsInteger())
 }
 
 #' @export
 #' @rdname hasType
 hasLogical = function(par.set) {
   assertClass(par.set, "ParamSet")
-  return(hasSomeParamsOfTypes(par.set, types = c("logical", "logicalvector")))
+  hasSomeParamsOfTypes(par.set, types = getTypeStringsLogical())
 }
 
 #' @export
 #' @rdname hasType
 hasCharacter = function(par.set) {
   assertClass(par.set, "ParamSet")
-  return(hasSomeParamsOfTypes(par.set, types = c("character", "charactervector")))
+  hasSomeParamsOfTypes(par.set, types = getTypeStringsCharacter())
 }
 
 #' @export
@@ -51,11 +51,10 @@ hasNumeric = function(par.set, include.int = TRUE) {
 
 # is at least one of types somewhere in par.set?
 hasSomeParamsOfTypes = function(par.set, types) {
-  return(any(types %in% getParamTypes(par.set, df.cols = FALSE, with.nr = FALSE , use.names = FALSE)))
+  any(types %in% getParamTypes(par.set, df.cols = FALSE, with.nr = FALSE, use.names = FALSE))
 }
 
 # are all param types contained in 'types'
 hasAllParamsOfTypes = function(par.set, types) {
-  return(all(getParamTypes(par.set, df.cols = FALSE, with.nr = FALSE , use.names = FALSE) %in% types))
+  all(getParamTypes(par.set, df.cols = FALSE, with.nr = FALSE, use.names = FALSE) %fin% types)
 }
-

R/isTypeString.R

@@ -16,36 +16,35 @@ NULL
 #' @export
 #' @rdname isTypeString
 isNumericTypeString = function(type, include.int = TRUE) {
-  type %in% getTypeStringsNumeric(include.int)
+  type %fin% getTypeStringsNumeric(include.int)
 }
 
 #' @export
 #' @rdname isTypeString
 isIntegerTypeString = function(type) {
-  type %in% getTypeStringsInteger()
+  type %fin% getTypeStringsInteger()
 }
 
 #' @export
 #' @rdname isTypeString
 isCharacterTypeString = function(type) {
-  type %in% getTypeStringsCharacter()
+  type %fin% getTypeStringsCharacter()
 }
 
 #' @export
 #' @rdname isTypeString
 isDiscreteTypeString = function(type, include.logical = TRUE) {
-  type %in% getTypeStringsDiscrete(include.logical)
+  type %fin% getTypeStringsDiscrete(include.logical)
 }
 
 #' @export
 #' @rdname isTypeString
 isLogicalTypeString = function(type) {
-  type %in% getTypeStringsLogical()
+  type %fin% getTypeStringsLogical()
 }
 
 #' @export
 #' @rdname isTypeString
 isVectorTypeString = function(type) {
-  grepl("vector", fixed = TRUE, type)
+  endsWith(type, "vector")
 }
-

R/zzz.R

@@ -1,7 +1,9 @@
+#' @import backports
 #' @import BBmisc
 #' @import checkmate
 #' @import methods
 #' @import stats
+#' @importFrom fastmatch %fin% fmatch
 NULL
 
 ph = new.env(parent = emptyenv())
@@ -12,3 +14,6 @@ ph$type.strings.logical = c("logical", "logicalvector")
 ph$type.strings.discrete =  c("discrete", "discretevector")
 ph$type.strings.numeric = c(ph$type.strings.integer, ph$type.strings.double)
 ph$type.strings = c(ph$type.strings.integer, ph$type.strings.double, ph$type.strings.character, ph$type.strings.logical, ph$type.strings.discrete, "untyped", "function")
+
+ph$convert.param.types.from = c("numericvector", "integervector", "discrete", "discretevector", "logicalvector", "charactervector")
+ph$convert.to.ctypes = c("numeric", "integer", "factor", "logical", "character")