Fast way to get numeric precision and scale (n/o decimal points) for a numeric vector

Question

I have a vector with many numbers (> 1E9 elements) and want to derive the numeric precision (number of digits in a number) and numeric scale (the number of digits to the right of the decimal point in a number).

How can I do this very fast (vectorized)?

There exists a question with a partial answer (how to return number of decimal places in R) but the solution neither fast (vectorized) nor calculates the numeric precision.

Example:

# small example vector with numeric data
x <- c(7654321, 54321.1234, 321.123, 321.123456789)

> numeric.precision(x)  # implementation is the answer
[1] 7, 9, 6, 12

> numeric.scale(x)      # implementation is the answer
[1] 0, 4, 3, 9

Optional "sugar" (added later to this question - thx to @thc and @gregor):

How can I avoid over-counting the number of digits due to internal imprecision how numbers are stored in computers (e. g. float)?

> x = 54321.1234
> as.character(x)
[1] "54321.1234"
> print(x, digits = 22)
[1] 54321.12339999999676365

Answer 1

Here is a base R method to start with It is bound to be too slow, but at least calculates the desired results.

# precision
nchar(sub(".", "", x, fixed=TRUE))
[1]  7  9  6 12

# scale
nchar(sub("\\d+\\.?(.*)$", "\\1", x))
[1] 0 4 3 9

---

For this method, I'd recommend using the colClasses argument in with data.table's fread to avoid conversion to numeric precision issues in the first place:

x <- unlist(fread("7654321
54321.1234
321.123
321.123456789", colClasses="character"), use.names=FALSE)

---

It may be necessary to convert the vector to numeric during the input, as mentioned in the comments, for example some of the input values are in scientific notation in the text file. In this instance, using a formatting statement or options(scipen=999) to force the conversion from this format to standard decimal format may be necessary as noted in this answer.

Answer 2

Here is idea of math version (faster then manipulate with characters). You can put this in functions scale and precision, where in function precision call scale function.

for (i in 1:length(x)) {
     after <- 0
     while(x[i]*(10^after) != round(x[i]*(10^after))) 
     { after <- after + 1 }
     cat(sprintf("Scale: %s\n", after))
     before <- floor(log10(abs(x[i])))+1
     cat(sprintf("Precision: %s\n", before+after))
 }

Result:

Scale: 0
Precision: 7
Scale: 4
Precision: 9
Scale: 3
Precision: 6
Scale: 9
Precision: 12

Answer 3

Just to consolidate all comments and answers into one ready-to-use solution that also considers different countries (locales) and NA I post this as an answer (please give credits to @Imo, @Gregor et al.).

Edit (Feb 09, 2017): Added the SQL.precision as return value since it may be different from the mathematical precision.

#' Calculates the biggest precision and scale that occurs in a numeric vector
#'
#' The scale of a numeric is the count of decimal digits in the fractional part (to the right of the decimal point).
#' The precision of a numeric is the total count of significant digits in the whole number,
#' that is, the number of digits to both sides of the decimal point. 
#'
#' To create a suitable numeric data type in a SQL data base use the returned \code{SQL.precision} which
#' is defined by \code{max(precision, non.fractional.precision + scale)}.
#'
#' @param x numeric vector
#'
#' @return A list with four elements:
#'         precision (total number of significant digits in the whole number),
#'         scale (number of digits in the fractional part),
#'         non.fractional.precision (number of digits at the left side and SQL precision.
#'
#' @details NA will be counted as precision 1 and scale 0!
#'
#' @examples
#'
#' \preformatted{
#' x <- c(0, 7654321, 54321.1234, 321.123, 321.123456789, 54321.1234, 100000000000, 1E4, NA)
#' numeric.precision.and.scale(x)
#' numeric.precision.and.scale(c(10.0, 1.2))   # shows why the SQL.precision is different
#' }
numeric.precision.and.scale <- function(x) {

  # Remember current options
  old.scipen <- getOption("scipen")

  # Overwrite options
  options(scipen = 999)   # avoid scientific notation when converting numerics to strings

  # Extract the decimal point character of the computer's current locale
  decimal.sign <- substr( 1 / 2, 2, 2)

  x.string <- as.character(x[!is.na(x)])

  if (length(x.string) > 0) {
    # calculate
    precision <- max(nchar(sub(decimal.sign, "", x.string, fixed = TRUE)))
    scale <- max(nchar(sub(paste0("\\d+\\", decimal.sign, "?(.*)$"), "\\1", x.string)))
    non.fractional.precision <- max(trunc(log10(abs(x))) + 1, na.rm = TRUE)
    SQL.precision <- max(precision, non.fractional.precision + scale)

    # Reset changed options
    options(scipen = old.scipen)
  } else {
    precision <- 1
    scale <- 0
    non.fractional.precision <- 1
    SQL.precision <- 1
  }

  return(list(precision = precision,
              scale = scale,
              non.fractional.precision = non.fractional.precision,
              SQL.precision = SQL.precision))
}