Bitwise operations

NAMESPACE

@@ -192,6 +192,12 @@ export(as.integer64)
 export(as.ordered)
 export(benchmark64)
 export(binattr)
+export(bitwAnd)
+export(bitwNot)
+export(bitwOr)
+export(bitwShiftL)
+export(bitwShiftR)
+export(bitwXor)
 export(cache)
 export(colSums)
 export(factor)

NEWS.md

@@ -8,6 +8,10 @@
 
 1. Supplying `keep.names=` to `as.integer64()` now emits a warning, which will become an error in the next release.
 
+## NEW FEATURES
+
+1. `bitwNot`, `bitwAnd`, `bitwOr`, `bitwXor`, `bitwShiftL` and `bitwShiftR` get an overload to work correctly with `integer64` (#33).
+
 ## NOTES
 
 1. The R version dependency has been bumped from 3.5.0 (2018) to 3.6.0 (2019).

R/bitwise64.R

@@ -0,0 +1,159 @@
+# /*
+# R-Code
+# S3 atomic 64bit integers for R
+# (c) 2026 Michael Chirico
+# Licence: GPL2
+# Provided 'as is', use at your own risk
+#*/
+
+#' @title Bitwise Logical Operations
+#' @description Logical operations on integer vectors with elements viewed as sets of bits.
+#'   As soon as an integer64 vector is involved, the operations are performed using integer64
+#'   semantics. Otherwise the base package functions are called.
+#' @inheritParams base::bitwAnd
+#' @inheritParams base::bitShiftL
+#' @return
+#' An integer64 vector of length the longer of the arguments, or zero length if one is zero-length.
+#'
+#' @seealso [bitwAnd][base::bitwAnd], [bitwOr][base::bitwOr], [bitwXor][base::bitwXor],
+#'   [bitwNot][base::bitwNot], [bitwShiftL][base::bitwShiftL], [bitwShiftR][base::bitwShiftR]
+#' @examples
+#' x <- as.integer64(1:5)
+#' y <- c(1L, 3L, 5L, 7L)
+#' bitwAnd(x, y)
+#' bitwOr(x, y)
+#' bitwXor(x, y)
+#' bitwNot(x)
+#' bitwShiftL(x, 1L)
+#' bitwShiftR(x, 1L)
+#'
+#' @export
+#' @name bitwise
+#' @rdname bitwise
+bitwNot = function(a) {
+  if (!is.integer64(a))
+    return(base::bitwNot(a))
+
+  ret = .Call(C_bitwNot_integer64, a, double(length(a)))
+  oldClass(ret) = "integer64"
+  ret
+}
+
+#' @export
+#' @rdname bitwise
+bitwAnd = function(a, b) {
+  if (!(is.integer64(a) || is.integer64(b)))
+    return(base::bitwAnd(a, b))
+
+  if (is.factor(a) || inherits(a, "POSIXct") || inherits(a, "Date"))
+    a = as.integer(a)
+  if (is.factor(b) || inherits(b, "POSIXct") || inherits(b, "Date"))
+    b = as.integer(b)
+
+  if (!is.numeric(a) || !is.numeric(b))
+    stop("'a' and 'b' must have the same type", domain="R")
+
+  if (!is.integer64(a) && !is.integer(a))
+    a = as.integer64(a)
+  if (!is.integer64(b) && !is.integer(b))
+    b = as.integer64(b)
+
+  l1 = length(a)
+  l2 = length(b)
+  l = if (l1 == 0L || l2 == 0L) 0L else max(l1, l2)
+  ret = .Call(C_bitwAnd_integer64, a, b, double(l))
+  oldClass(ret) = "integer64"
+  ret
+}
+
+#' @export
+#' @rdname bitwise
+bitwOr = function(a, b) {
+  if (!(is.integer64(a) || is.integer64(b)))
+    return(base::bitwOr(a, b))
+
+  if (is.factor(a) || inherits(a, "POSIXct") || inherits(a, "Date"))
+    a = as.integer(a)
+  if (is.factor(b) || inherits(b, "POSIXct") || inherits(b, "Date"))
+    b = as.integer(b)
+
+  if (!is.numeric(a) || !is.numeric(b))
+    stop("'a' and 'b' must have the same type", domain="R")
+
+  if (!is.integer64(a) && !is.integer(a))
+    a = as.integer64(a)
+  if (!is.integer64(b) && !is.integer(b))
+    b = as.integer64(b)
+
+  l1 = length(a)
+  l2 = length(b)
+  l = if (l1 == 0L || l2 == 0L) 0L else max(l1, l2)
+  ret = .Call(C_bitwOr_integer64, a, b, double(l))
+  oldClass(ret) = "integer64"
+  ret
+}
+
+#' @export
+#' @rdname bitwise
+bitwXor = function(a, b) {
+  if (!(is.integer64(a) || is.integer64(b)))
+    return(base::bitwXor(a, b))
+
+  if (is.factor(a) || inherits(a, "POSIXct") || inherits(a, "Date"))
+    a = as.integer(a)
+  if (is.factor(b) || inherits(b, "POSIXct") || inherits(b, "Date"))
+    b = as.integer(b)
+
+  if (!is.numeric(a) || !is.numeric(b))
+    stop("'a' and 'b' must have the same type", domain="R")
+
+  if (!is.integer64(a) && !is.integer(a))
+    a = as.integer64(a)
+  if (!is.integer64(b) && !is.integer(b))
+    b = as.integer64(b)
+
+  l1 = length(a)
+  l2 = length(b)
+  l = if (l1 == 0L || l2 == 0L) 0L else max(l1, l2)
+  ret = .Call(C_bitwXor_integer64, a, b, double(l))
+  oldClass(ret) = "integer64"
+  ret
+}
+
+#' @export
+#' @rdname bitwise
+bitwShiftL = function(a, n) {
+  if (!(is.integer64(a) || is.integer64(n)))
+    return(base::bitwShiftL(a, n))
+  if (!is.integer64(a))
+    return(base::bitwShiftL(a, as.integer(n)))
+
+  if (!is.integer64(n))
+    n = as.integer(n)
+
+  l1 = length(a)
+  l2 = length(n)
+  l = if (l1 == 0L || l2 == 0L) 0L else max(l1, l2)
+  ret = .Call(C_bitwShiftL_integer64, a, n, double(l))
+  oldClass(ret) = "integer64"
+  ret
+}
+
+#' @export
+#' @rdname bitwise
+bitwShiftR = function(a, n) {
+  if (!(is.integer64(a) || is.integer64(n)))
+    return(base::bitwShiftR(a, n))
+  if (!is.integer64(a))
+    return(base::bitwShiftR(a, as.integer(n)))
+
+  if (!is.integer64(n))
+    n = as.integer(n)
+
+  l1 = length(a)
+  l2 = length(n)
+  l = if (l1 == 0L || l2 == 0L) 0L else max(l1, l2)
+  ret = .Call(C_bitwShiftR_integer64, a, n, double(l))
+  oldClass(ret) = "integer64"
+  ret
+}