implement frev as fast base::rev alternative (#5907)

ben-schwen · MichaelChirico · OfekShilon · web-flow · commit 8ea8f7239c6e · 2025-07-14T07:14:54.000-07:00
* add macro version * write explicit parallel version * copy attributes * add tests * add to NAMESPACE * add to tests * copy names * add man page * update man * fix typos * update tests * add coverage * add benchmark example * coverage * NEWS * trim NEWS * update NEWS * add bit64 * update naming in NEWS * 1.15.0 on CRAN. Bump to 1.15.99 * Fix transform slowness (#5493) * Fix 5492 by limiting the costly deparse to `nlines=1` * Implementing PR feedbacks * Added inside * Fix typo in name * Idiomatic use of inside * Separating the deparse line limit to a different PR --------- Co-authored-by: Michael Chirico <chiricom@google.com> * Improvements to the introductory vignette (#5836) * Added my improvements to the intro vignette * Removed two lines I added extra as a mistake earlier * Requested changes * Vignette typo patch (#5402) * fix typos and grammatical mistakes * fix typos and punctuation * remove double spaces where it wasn't necessary * fix typos and adhere to British English spelling * fix typos * fix typos * add missing closing bracket * fix typos * review fixes * Update vignettes/datatable-benchmarking.Rmd Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * Update vignettes/datatable-benchmarking.Rmd Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * Apply suggestions from code review benchmarking Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * remove unnecessary [ ] from datatable-keys-fast-subset.Rmd * Update vignettes/datatable-programming.Rmd Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * Update vignettes/datatable-reshape.Rmd Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * One last batch of fine-tuning --------- Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> Co-authored-by: Michael Chirico <chiricom@google.com> * Improved handling of list columns with NULL entries (#4250) * Updated documentation for rbindlist(fill=TRUE) * Print NULL entries of list as NULL * Added news item * edit NEWS, use '[NULL]' not 'NULL' * fix test * split NEWS item * add example --------- Co-authored-by: Michael Chirico <chiricom@google.com> Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> Co-authored-by: Benjamin Schwendinger <benjamin.schwendinger@tuwien.ac.at> * clarify that list input->unnamed list output (#5383) * clarify that list input->unnamed list output * Add example where make.names is used * mention role of make.names * fix subsetting issue in split.data.table (#5368) * fix subsetting issue in split.data.table * add a test * drop=FALSE on inner [ * switch to 3.2.0 R dep (#5905) * Allow early exit from check for eval/evalq in cedta (#5660) * Allow early exit from check for eval/evalq in cedta Done in the browser+untested, please take a second look :) * Use %chin% * nocov new code * frollmax1: frollmax, frollmax adaptive, left adaptive support (#5889) * frollmax exact, buggy fast, no fast adaptive * frollmax fast fixing bugs * frollmax man to fix CRAN check * frollmax fast adaptive non NA, dev * froll docs, adaptive left * no frollmax fast adaptive * frollmax adaptive exact NAs handling * PR summary in news * copy-edit changes from reviews Co-authored-by: Benjamin Schwendinger <52290390+ben-schwen@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> Co-authored-by: Benjamin Schwendinger <52290390+ben-schwen@users.noreply.github.com> * comment requested by Michael * update NEWS file * Apply suggestions from code review Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * Apply suggestions from code review Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * add comment requested by Michael * add comment about int iterator for loop over k-1 obs * extra comments * Revert "extra comments" This reverts commit 03af0e3. * add comments to frollmax and frollsum * typo fix --------- Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> Co-authored-by: Benjamin Schwendinger <52290390+ben-schwen@users.noreply.github.com> * Friendlier error in assignment with trailing comma (#5467) * friendlier error in assignment with trailing comma e.g. `DT[, `:=`(a = 1, b = 2,)`. WIP. Need to add tests and such, but editing from browser before I forget. * Another pass * include unnamed indices on RHS too * tests * NEWS * test numbering * explicit example in NEWS * Link to ?read.delim in ?fread to give a closer analogue of expected behavior (#5635) * fread is similar to read.delim (#5634) * Use ?read.csv / ?read.delim --------- Co-authored-by: Michael Chirico <chiricom@google.com> Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> * Run GHA jobs on 1-15-99 dev branch (#5909) * prohibit matrix * readd deleted line * Make declarations static for covr (#5910) * reorder code * return invisible if inplace * cut to 1 line * use isTRUE for copy=NA * speedup strings and lists * add Hughs comments * add coverage * dedup INTSXP LGLSXP * make tests lighter * rm altrep include * change testnum * remove altrep * remove duplicated tests * mostly fix botched merge * migrate NEWS item * revert bad search+replace * update NEWS wording * add small body * add additional test cases * rerun benchmarks single threaded * update doc * remove unnecessary assignment * change to frev/setrev * add symbol for setrev * update docs * update NEWS * add details about attributes * drop attributes except names, class and levels * update docs * vestigial copy= reference * use parity tests * change tests to capture behavior after side-effects * change man * allow matrix frev * rotate idiom * use frev and setrev internally * item numbering * block future rev() usage * setrev->setfrev * dont use setfrev on caller-owned object * update wording that was contrasting frev+setfrev; tweak examples * mention that levels are retained * add names test * remove temp variables * fix test ordering * move temporary variables --------- Co-authored-by: Michael Chirico <chiricom@google.com> Co-authored-by: Ofek <ofekshilon@gmail.com> Co-authored-by: Ani <bloodraven166@gmail.com> Co-authored-by: David Budzynski <56514985+davidbudzynski@users.noreply.github.com> Co-authored-by: Michael Chirico <michaelchirico4@gmail.com> Co-authored-by: Scott Ritchie <sritchie73@gmail.com> Co-authored-by: Jan Gorecki <J.Gorecki@wit.edu.pl> Co-authored-by: Manuel López-Ibáñez <2620021+MLopez-Ibanez@users.noreply.github.com>
diff --git a/.ci/.lintr.R b/.ci/.lintr.R
@@ -21,6 +21,7 @@ linters = c(dt_linters, all_linters(
     message = "Use messagef to avoid fragmented translations.",
     warning = "Use warningf to avoid fragmented translations.",
     stop = "Use stopf to avoid fragmented translations.",
+    rev = "Use frev internally, or setfrev if by-reference is safe.",
     NULL
   )),
   # undesirable_function_linter(modify_defaults(
diff --git a/NAMESPACE b/NAMESPACE
@@ -208,6 +208,7 @@ S3method(format_list_item, data.frame)
 
 export(fdroplevels, setdroplevels)
 S3method(droplevels, data.table)
+export(frev)
 
 # sort_by added in R 4.4.0, #6662, https://stat.ethz.ch/pipermail/r-announce/2024/000701.html
 if (getRversion() >= "4.4.0") S3method(sort_by, data.table)  
diff --git a/NEWS.md b/NEWS.md
@@ -46,6 +46,8 @@
 
 10. `data.table()` and `as.data.table()` with `keep.rownames=TRUE` now extract row names from named vectors, matching `data.frame()` behavior. Names from the first named vector in the input are used to create the row names column (default name `"rn"` or custom name via `keep.rownames="column_name"`), [#1916](https://github.com/Rdatatable/data.table/issues/1916). Thanks to @richierocks for the feature request and @Mukulyadav2004 for the implementation.
 
+11. New `frev(x)` as a faster analogue to `base::rev()` for atomic vectors/lists, [#5885](https://github.com/Rdatatable/data.table/issues/5885). Twice as fast as `base::rev()` on large inputs, and faster with more threads. Thanks to Benjamin Schwendinger for suggesting and implementing.
+
 ### BUG FIXES
 
 1. `fread()` no longer warns on certain systems on R 4.5.0+ where the file owner can't be resolved, [#6918](https://github.com/Rdatatable/data.table/issues/6918). Thanks @ProfFancyPants for the report and PR.
diff --git a/R/as.data.table.R b/R/as.data.table.R
@@ -36,11 +36,11 @@ as.data.table.table = function(x, keep.rownames=FALSE, key=NULL, ...) {
   # prevent #4179 & just cut out here
   if (any(dim(x) == 0L)) return(null.data.table())
   # Fix for bug #43 - order of columns are different when doing as.data.table(with(DT, table(x, y)))
-  val = rev(dimnames(provideDimnames(x)))
+  val = frev(dimnames(provideDimnames(x)))
   if (is.null(names(val)) || !any(nzchar(names(val))))
-    setattr(val, 'names', paste0("V", rev(seq_along(val))))
+    setattr(val, 'names', paste0("V", frev(seq_along(val))))
   ans = data.table(do.call(CJ, c(val, sorted=FALSE)), N = as.vector(x), key=key)
-  setcolorder(ans, c(rev(head(names(ans), -1L)), "N"))
+  setcolorder(ans, c(frev(head(names(ans), -1L)), "N"))
   ans
 }
 
@@ -104,18 +104,18 @@ as.data.table.array = function(x, keep.rownames=FALSE, key=NULL, sorted=TRUE, va
     dnx[nulldnx] = lapply(dx[nulldnx], seq_len) #3636
     dnx
   } else dnx
-  val = rev(val)
+  setfrev(val)
   if (is.null(names(val)) || !any(nzchar(names(val))))
-    setattr(val, 'names', paste0("V", rev(seq_along(val))))
+    setattr(val, 'names', paste0("V", frev(seq_along(val))))
   if (value.name %chin% names(val))
-    stopf("Argument 'value.name' should not overlap with column names in result: %s", brackify(rev(names(val))))
+    stopf("Argument 'value.name' should not overlap with column names in result: %s", brackify(frev(names(val))))
   N = NULL
   ans = do.call(CJ, c(val, sorted=FALSE))
   set(ans, j="N", value=as.vector(x))
   if (isTRUE(na.rm))
     ans = ans[!is.na(N)]
   setnames(ans, "N", value.name)
-  dims = rev(head(names(ans), -1L))
+  dims = frev(head(names(ans), -1L))
   setcolorder(ans, c(dims, value.name))
   if (isTRUE(sorted) && is.null(key)) key = dims
   setkeyv(ans, key)
diff --git a/R/bmerge.R b/R/bmerge.R
@@ -110,7 +110,7 @@ bmerge = function(i, x, icols, xcols, roll, rollends, nomatch, mult, ops, verbos
     }
     if (x_merge_type=="integer64" || i_merge_type=="integer64") {
       nm = c(iname, xname)
-      if (x_merge_type=="integer64") { w=i; wc=icol; wclass=i_merge_type; } else { w=x; wc=xcol; wclass=x_merge_type; nm=rev(nm) }  # w is which to coerce
+      if (x_merge_type=="integer64") { w=i; wc=icol; wclass=i_merge_type; } else { w=x; wc=xcol; wclass=x_merge_type; setfrev(nm) }  # w is which to coerce
       if (wclass=="integer" || (wclass=="double" && fitsInInt64(w[[wc]]))) {
         from_detail = if (wclass == "double") gettext(" (which has integer64 representation, e.g. no fractions)") else ""
         coerce_col(w, wc, wclass, "integer64", nm[1L], nm[2L], from_detail, verbose=verbose)
diff --git a/R/utils.R b/R/utils.R
@@ -86,7 +86,7 @@ which.last = function(x)
   if (!is.logical(x)) {
     stopf("x not boolean")
   }
-  length(x) - match(TRUE, rev(x)) + 1L
+  length(x) - match(TRUE, frev(x)) + 1L
 }
 
 require_bit64_if_needed = function(DT) {
@@ -226,7 +226,7 @@ fctr = function(x, levels=unique(x), ..., sort=FALSE, rev=FALSE) {
   if (!isTRUEorFALSE(rev))
     stopf("argument 'rev' must be TRUE or FALSE")
   if (sort) levels = sort(levels)
-  if (rev) levels = rev(levels)
+  if (rev) levels = frev(levels)
   factor(x, levels=levels, ...)
 }
 
diff --git a/R/wrappers.R b/R/wrappers.R
@@ -21,3 +21,6 @@ fitsInInt32 = function(x) .Call(CfitsInInt32R, x)
 fitsInInt64 = function(x) .Call(CfitsInInt64R, x)
 
 coerceAs = function(x, as, copy=TRUE) .Call(CcoerceAs, x, as, copy)
+
+frev   = function(x) .Call(Cfrev, x, TRUE)
+setfrev = function(x) invisible(.Call(Cfrev, x, FALSE))
diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
@@ -71,6 +71,7 @@ if (exists("test.data.table", .GlobalEnv, inherits=FALSE)) {
   setcoalesce = data.table:::setcoalesce
   setdiff_ = data.table:::setdiff_
   setreordervec = data.table:::setreordervec
+  setfrev = data.table:::setfrev
   shallow = data.table:::shallow # until exported
   .shallow = data.table:::.shallow
   split.data.table = data.table:::split.data.table
@@ -4227,7 +4228,7 @@ test(1159.6, setDT(x), error="Argument 'x' to 'setDT' should be a")
 x <- list(1, 2:3)
 test(1159.7, setDT(x), error="All elements in argument 'x' to 'setDT'")
 
-# test 1160 was for setrev, now removed
+# test 1160 was for setfrev, now removed
 
 # tests for setreordervec
 # integer
@@ -21429,3 +21430,62 @@ test(2330.8, as.data.table(list(M), keep.rownames=TRUE), data.table(rn=rep("", 3
 
 # .SD reference in '...' passed to lapply(FUN=) is recognized as data.table
 test(2331, lapply(list(data.table(a=1:2)), `[`, j=.SD[1L]), list(data.table(a=1L)))
+
+# 5885 implement frev
+d = c(NA, NaN, Inf, -Inf)
+test(2332.00, frev(c(FALSE, NA)),     rev(c(FALSE, NA)))
+test(2332.01, frev(c(0L, NA)),        rev(c(0L, NA)))
+test(2332.02, frev(d),                rev(d))
+test(2332.03, frev(c(NA, 1, 0+2i)),   rev(c(NA, 1, 0+2i)))
+test(2332.04, frev(as.raw(0:1)),      rev(as.raw(0:1)))
+test(2332.05, frev(NULL),             rev(NULL))
+test(2332.06, frev(character(5)),     rev(character(5)))
+test(2332.07, frev(integer(0)),       rev(integer(0)))
+test(2332.08, frev(list(1, "a")),     rev(list(1, "a")))
+test(2332.09, {x=c(0L, NA); setfrev(x); x},      c(NA, 0L))
+test(2332.10, {x=d; setfrev(x); x},              c(-Inf, Inf, NaN, NA))
+test(2332.11, {x=c(NA, 1, 0+2i); setfrev(x); x}, c(0+2i, 1, NA))
+test(2332.12, {x=as.raw(0:1); setfrev(x); x},    as.raw(1:0))
+test(2332.13, {x=NULL; setfrev(x); x},           NULL)
+test(2332.14, {x=character(5); setfrev(x); x},   character(5))
+test(2332.15, {x=integer(0); setfrev(x); x},     integer(0))
+test(2332.16, {x=list(1, "a"); setfrev(x); x},   list("a", 1))
+test(2332.17, frev(1:1e2),            rev(1:1e2))
+# copy arguments
+x = 1:3
+test(2332.21, {frev(x);  x}, 1:3)
+test(2332.22, {setfrev(x); x}, 3:1)
+test(2332.23, address(x) == address(setfrev(x)))
+test(2332.24, address(x) != address(frev(x)))
+# do not alter on subsets
+test(2332.25, {setfrev(x[1:2]);  x}, 1:3)
+# levels
+f = as.factor(letters)
+test(2332.31, frev(f), rev(f))
+test(2332.32, frev(as.IDate(1:10)), as.IDate(10:1))
+test(2332.33, frev(as.IDate(1:10)), as.IDate(10:1))
+# names
+x = c(a=1L, b=2L, c=3L)
+test(2332.41, frev(x), rev(x))
+test(2332.42, setfrev(x), x)
+x = c(a=1L, b=2L, c=3L)
+test(2332.43, {frev(x); names(x)}, c("a","b","c"))
+# attributes
+x = structure(1:10, class = c("IDate", "Date"), att = 1L)
+test(2332.51, attr(frev(x), "att"), attr(rev(x), "att"))
+test(2332.52, class(frev(x)), class(rev(x)))
+test(2332.53, attr(setfrev(x), "att"), 1L)
+test(2332.54, class(setfrev(x)), c("IDate", "Date"))
+x = structure(integer(0), att = 1L)
+test(2332.55, attr(frev(x), "att"), attr(rev(x), "att"))
+# errors
+test(2332.61, frev(data.table()), error="should not be data.frame or data.table")
+test(2332.62, frev(expression(1)), error="is not supported by frev")
+if (test_bit64) {
+  x = as.integer64(c(1, NA, 3))
+  test(2332.71, frev(x), rev(x))
+  test(2332.72, setfrev(x), x)
+}
+# support rotate idiom
+M1 = M2 = matrix(1:4, nrow=2)
+test(2332.81, {M1[]=frev(M1); M1}, {M2[]=rev(M2); M2})
diff --git a/man/frev.Rd b/man/frev.Rd
@@ -0,0 +1,32 @@
+\name{frev}
+\alias{frev}
+\alias{rev}
+\title{Fast reverse}
+\description{
+  Similar to \code{\link[base]{rev}} but \emph{faster}.
+}
+
+\usage{
+frev(x)
+}
+\arguments{
+  \item{x}{ An atomic \code{vector} or \code{list}. }
+}
+
+\details{
+  Similar to \code{\link[base]{rev}}, \code{frev} only retains three attributes: names, class, and factor levels.
+}
+
+\value{
+  Returns the input reversed.
+}
+
+\examples{
+# on vectors
+x = setNames(1:10, letters[1:10])
+frev(x)
+
+# list
+frev(list(1, "a", TRUE))
+}
+\keyword{ data }
diff --git a/src/data.table.h b/src/data.table.h
@@ -278,6 +278,7 @@ bool isDataTable(SEXP x);
 bool isRectangularList(SEXP x);
 bool perhapsDataTable(SEXP x);
 SEXP perhapsDataTableR(SEXP x);
+SEXP frev(SEXP x, SEXP copyArg);
 NORET void internal_error(const char *call_name, const char *format, ...);
 
 // types.c
diff --git a/src/init.c b/src/init.c
@@ -153,6 +153,7 @@ R_CallMethodDef callMethods[] = {
 {"CperhapsDataTableR", (DL_FUNC) &perhapsDataTableR, -1},
 {"CcopyCols", (DL_FUNC) &copyCols, -1},
 {"Cwarn_matrix_column_r", (DL_FUNC)&warn_matrix_column_r, -1},
+{"Cfrev", (DL_FUNC) &frev, -1},
 {NULL, NULL, 0}
 };
 
diff --git a/src/utils.c b/src/utils.c
@@ -542,6 +542,113 @@ SEXP perhapsDataTableR(SEXP x) {
   return ScalarLogical(perhapsDataTable(x));
 }
 
+SEXP frev(SEXP x, SEXP copyArg) {
+  SEXP names;
+  if (INHERITS(x, char_dataframe))
+    error(_("'x' should not be data.frame or data.table."));
+  if (!IS_TRUE_OR_FALSE(copyArg))
+    error(_("%s must be TRUE or FALSE."), "copy"); // # nocov
+  bool copy = LOGICAL(copyArg)[0];
+  R_xlen_t n = xlength(x);
+  int nprotect = 0;
+  if (copy) {
+    x = PROTECT(duplicate(x));
+    nprotect++;
+  }
+  if (n==0) {
+    UNPROTECT(nprotect);
+    return x;
+  }
+  switch (TYPEOF(x)) {
+    case LGLSXP: case INTSXP: {
+      int *restrict xd = INTEGER(x);
+      #pragma omp parallel for num_threads(getDTthreads(n, true))
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const int tmp = xd[i];
+        xd[i] = xd[k];
+        xd[k] = tmp;
+      }
+    } break;
+    case REALSXP: if (INHERITS(x, char_integer64)) {
+      int64_t *xd = (int64_t *)REAL(x);
+      #pragma omp parallel for num_threads(getDTthreads(n, true))
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const int64_t tmp = xd[i];
+        xd[i] = xd[k];
+        xd[k] = tmp;
+      }
+    } else {
+      double *xd = REAL(x);
+      #pragma omp parallel for num_threads(getDTthreads(n, true))
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const double tmp = xd[i];
+        xd[i] = xd[k];
+        xd[k] = tmp;
+      }
+    } break;
+    case STRSXP: {
+      const SEXP *xd = SEXPPTR_RO(x);
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const SEXP tmp = xd[i];
+        SET_STRING_ELT(x, i, xd[k]);
+        SET_STRING_ELT(x, k, tmp);
+      }
+    } break;
+    case VECSXP: {
+      const SEXP *xd = SEXPPTR_RO(x);
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const SEXP tmp = xd[i];
+        SET_VECTOR_ELT(x, i, xd[k]);
+        SET_VECTOR_ELT(x, k, tmp);
+      }
+    } break;
+    case CPLXSXP: {
+      Rcomplex *xd = COMPLEX(x);
+      #pragma omp parallel for num_threads(getDTthreads(n, true))
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const Rcomplex tmp = xd[i];
+        xd[i] = xd[k];
+        xd[k] = tmp;
+      }
+    } break;
+    case RAWSXP: {
+      Rbyte *xd = RAW(x);
+      #pragma omp parallel for num_threads(getDTthreads(n, true))
+      for (uint64_t i=0; i<n/2; ++i) {
+        const int k = n-1-i;
+        const Rbyte tmp = xd[i];
+        xd[i] = xd[k];
+        xd[k] = tmp;
+      }
+    } break;
+  default:
+    error(_("Type '%s' is not supported by frev"), type2char(TYPEOF(x)));
+  }
+  names = PROTECT(getAttrib(x, R_NamesSymbol));
+  nprotect++;
+  if (copy) {
+    SEXP klass = PROTECT(getAttrib(x, R_ClassSymbol));
+    SEXP levels = PROTECT(getAttrib(x, R_LevelsSymbol));
+    nprotect += 2;
+    // swipe attributes from x
+    SET_ATTRIB(x, R_NilValue);
+    setAttrib(x, R_NamesSymbol, names);
+    setAttrib(x, R_ClassSymbol, klass);
+    setAttrib(x, R_LevelsSymbol, levels);
+  }
+  if (!isNull(names)) {
+    frev(names, ScalarLogical(FALSE));
+  }
+  UNPROTECT(nprotect);
+  return x;
+}
+
 void internal_error(const char *call_name, const char *format, ...) {
   char buff[1024];
   va_list args;

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ bmerge = function(i, x, icols, xcols, roll, rollends, nomatch, mult, ops, verbos`
`110`	`110`	`}`
`111`	`111`	`if (x_merge_type=="integer64" \|\| i_merge_type=="integer64") {`
`112`	`112`	`nm = c(iname, xname)`
`113`		`- if (x_merge_type=="integer64") { w=i; wc=icol; wclass=i_merge_type; } else { w=x; wc=xcol; wclass=x_merge_type; nm=rev(nm) } # w is which to coerce`
	`113`	`+ if (x_merge_type=="integer64") { w=i; wc=icol; wclass=i_merge_type; } else { w=x; wc=xcol; wclass=x_merge_type; setfrev(nm) } # w is which to coerce`
`114`	`114`	`if (wclass=="integer" \|\| (wclass=="double" && fitsInInt64(w[[wc]]))) {`
`115`	`115`	`from_detail = if (wclass == "double") gettext(" (which has integer64 representation, e.g. no fractions)") else ""`
`116`	`116`	`coerce_col(w, wc, wclass, "integer64", nm[1L], nm[2L], from_detail, verbose=verbose)`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ which.last = function(x)`
`86`	`86`	`if (!is.logical(x)) {`
`87`	`87`	`stopf("x not boolean")`
`88`	`88`	`}`
`89`		`- length(x) - match(TRUE, rev(x)) + 1L`
	`89`	`+ length(x) - match(TRUE, frev(x)) + 1L`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`require_bit64_if_needed = function(DT) {`
`@@ -226,7 +226,7 @@ fctr = function(x, levels=unique(x), ..., sort=FALSE, rev=FALSE) {`
`226`	`226`	`if (!isTRUEorFALSE(rev))`
`227`	`227`	`stopf("argument 'rev' must be TRUE or FALSE")`
`228`	`228`	`if (sort) levels = sort(levels)`
`229`		`- if (rev) levels = rev(levels)`
	`229`	`+ if (rev) levels = frev(levels)`
`230`	`230`	`factor(x, levels=levels, ...)`
`231`	`231`	`}`
`232`	`232`